A decentralized academic peer review platform built on Zama's FHEVM, enabling completely confidential review scoring on Ethereum blockchain.

Watch the complete workflow demonstration: YouTube Demo

Live Demo: https://peerreviewfth.vercel.app/

PeerReviewFHE is a fully decentralized peer review system that leverages Fully Homomorphic Encryption (FHE) to maintain complete privacy throughout the review process. Reviewers submit encrypted scores that are aggregated on-chain without ever being decrypted, preventing bias and manipulation while maintaining transparency.

Traditional academic peer review systems suffer from critical flaws:

1. Reviewer Bias: Reviewers can be influenced by seeing each other's scores
2. Lack of Transparency: Centralized systems provide no audit trail
3. Score Manipulation: Central authorities can alter results
4. Privacy Concerns: Individual review scores should remain confidential
5. Trust Requirements: Authors and reviewers must trust a central organization

These issues lead to unfair evaluations, delayed publications, and compromised academic integrity.

Our FHE-powered platform solves these problems through:

• Encrypted Scoring: Review scores (1-10) are encrypted client-side before blockchain submission
• Homomorphic Computation: Average scores calculated directly on encrypted data using FHE.add() and FHE.div()
• Selective Decryption: Only the conference chair can decrypt final averages after all reviews are submitted
• Complete Privacy: Individual reviewer scores remain encrypted forever - even the chair cannot see them
• Blockchain Transparency: All actions (submission, assignment, reviews) recorded immutably on Ethereum
• Zero-Knowledge Process: Reviewers never see each other's scores during the entire workflow

• End-to-End Encryption: Scores encrypted in browser using Zama's fhevmjs SDK
• On-Chain Computation: Sum encrypted scores without decryption (euint8 → euint32 aggregation)
• Controlled Decryption: Chair-only access to final average via calculateAverageScore()
• Permanent Confidentiality: Individual scores cannot be revealed by anyone

• Role-Based Access: Distinct interfaces for Authors, Reviewers, and Conference Chair
• Paper Submission: Authors submit title, abstract, and required reviewer count
• Reviewer Assignment: Chair assigns qualified reviewers to each paper
• Encrypted Reviews: Reviewers submit scores + comments with client-side FHE encryption
• Automatic Aggregation: Smart contract sums encrypted scores homomorphically
• Result Publication: Chair decrypts average and publishes Accept/Reject decision
• Real-Time Progress: Track review status (X of N reviews submitted)

┌─────────────────────────────────────────────────────────────────────┐
│                         Frontend (React + TypeScript)               │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────────┐ │
│  │ Author View  │  │ Reviewer View│  │   Chair View             │ │
│  │ - Submit     │  │ - Assigned   │  │ - Assign Reviewers       │ │
│  │ - Track      │  │ - Review     │  │ - Decrypt & Publish      │ │
│  └──────────────┘  └──────────────┘  └──────────────────────────┘ │
│         │                  │                       │                │
│         └──────────────────┴───────────────────────┘                │
│                            │                                         │
│                   ┌────────▼────────┐                               │
│                   │  FHE SDK        │ (Client-Side Encryption)      │
│                   │  (fhevmjs)      │                               │
│                   └────────┬────────┘                               │
└────────────────────────────┼──────────────────────────────────────┘
                             │
                             │ Encrypted Data
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    Ethereum Blockchain (Sepolia)                     │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │              PeerReviewFHE Smart Contract                      │ │
│  │  ┌─────────────┐  ┌─────────────┐  ┌──────────────────────┐  │ │
│  │  │ submitPaper │  │assignReview │  │ submitReview          │  │ │
│  │  │             │  │ers          │  │ (FHE.fromExternal)    │  │ │
│  │  └─────────────┘  └─────────────┘  └──────────────────────┘  │ │
│  │                                                                 │ │
│  │  ┌─────────────────────────────┐  ┌──────────────────────┐   │ │
│  │  │ Encrypted Storage           │  │ calculateAverageScore│   │ │
│  │  │ - euint8 scores            │  │ (FHE.add, FHE.div)   │   │ │
│  │  │ - euint32 totalScore       │  │                      │   │ │
│  │  └─────────────────────────────┘  └──────────────────────┘   │ │
│  │                                                                 │ │
│  │  ┌─────────────────────────────────────────────────────────┐  │ │
│  │  │ publishResults (decrypt average, emit result event)      │  │ │
│  │  └─────────────────────────────────────────────────────────┘  │ │
│  └────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘

1. Submission: Author → submitPaper() → Paper struct created (status: Pending)
2. Assignment: Chair → assignReviewers() → Status changes to UnderReview
3. Review:
   • Reviewer encrypts score (1-10) using fhevmjs
   • Calls submitReview() with externalEuint8 + inputProof
   • Contract validates and imports: FHE.fromExternal(encryptedScore, inputProof)
   • Adds to encrypted sum: totalScore = FHE.add(totalScore, FHE.asEuint32(score))
4. Aggregation: Chair → calculateAverageScore() → Computes FHE.div(totalScore, reviewCount)
5. Publication: Chair → publishResults() → Decrypts average, emits result event

• Solidity: 0.8.27
• Zama FHEVM Library: v0.5.0
• Framework: Hardhat
• Network: Ethereum Sepolia Testnet
• Deployment: Deployed at 0xA170eDedef0b9E4E08590549AEE475efecbd54C5

• Framework: React 19 + TypeScript
• Build Tool: Vite 7
• Styling: Tailwind CSS 4
• Blockchain: ethers.js v6
• FHE: @zama-fhe/relayer-sdk v0.3.0
• Routing: React Router v7
• Deployment: Vercel

• Testing: Hardhat (37 tests, 100% passing)
• Type Checking: TypeScript 5.9
• Linting: ESLint

• Node.js: v20 or higher
• npm: v9 or higher
• MetaMask: Browser extension installed
• Sepolia ETH: Get from Sepolia Faucet

1. Clone the repository:

git clone https://github.com/YOUR_USERNAME/peer-review-fhe.git
cd peer-review-fhe

2. Install dependencies:

npm install

3. Configure environment variables:

cp .env.example .env
# Edit .env and add your MNEMONIC and ALCHEMY_URL

4. Compile contracts:

npm run compile

5. Run tests:

npm test

6. Deploy to Sepolia (optional - already deployed):

npx hardhat deploy --network sepolia --tags PeerReviewFHE

1. Navigate to frontend directory:

cd frontend

2. Install frontend dependencies:

npm install

3. Start development server:

npm run dev

4. Build for production:

npm run build

The application will be available at http://localhost:5173

1. Connect MetaMask wallet to Sepolia network
2. Navigate to "Author" tab
3. Click "Submit New Paper"
4. Fill in:
   • Paper Title
   • Abstract
   • Required number of reviewers (e.g., 3)
5. Confirm transaction in MetaMask
6. Track your paper's status in the dashboard

1. Connect assigned reviewer wallet
2. Navigate to "Reviewer" tab
3. View assigned papers
4. Click on a paper to review
5. Assign a score (1-10 scale)
6. Add review comments
7. Submit review (score is automatically encrypted with FHE)
8. Transaction confirms on blockchain

1. Connect chair wallet (deployer address)
2. Navigate to "Chair" tab
3. Assign Reviewers:
   • Select a pending paper
   • Enter reviewer Ethereum addresses
   • Confirm transaction
4. Monitor Progress: View how many reviews submitted
5. Decrypt & Publish (when all reviews are in):
   • Click "Decrypt & Publish" button
   • System fetches encrypted total score
   • FHE decrypts the average score client-side
   • Review recommendation (Accept if ≥7/10, Reject if <7/10)
   • Confirm decision and publish results

function submitReview(
    uint256 paperId,
    externalEuint8 encryptedScore,  // Encrypted from client
    bytes calldata inputProof,      // Zero-knowledge proof
    string memory comment
) external {
    // Import encrypted score with validation
    euint8 score = FHE.fromExternal(encryptedScore, inputProof);

    // Validate range (1-10) without revealing value
    FHE.req(FHE.ge(score, FHE.asEuint8(1)));
    FHE.req(FHE.le(score, FHE.asEuint8(10)));

    // Accumulate encrypted scores
    euint32 totalScore = paperReviews[paperId].totalScore;
    paperReviews[paperId].totalScore = FHE.add(
        totalScore,
        FHE.asEuint32(score)
    );
}

function calculateAverageScore(uint256 paperId)
    public
    onlyChair
    returns (euint32)
{
    PaperReviews storage pr = paperReviews[paperId];

    // Divide encrypted total by review count (homomorphic division)
    euint32 average = FHE.div(pr.totalScore, pr.reviewCount);

    // Grant chair permission to decrypt
    FHE.allow(average, chair);

    return average;
}

function publishResults(
    uint256 paperId,
    bool decision,
    uint8 averageScore
) external onlyChair {
    // averageScore is decrypted client-side by chair
    papers[paperId].status = decision
        ? PaperStatus.Accepted
        : PaperStatus.Rejected;

    emit ResultPublished(paperId, averageScore, papers[paperId].status);
}

• euint8: Individual review scores (1-10)
• euint32: Total sum of scores (prevents overflow)
• ebool: Comparison results (internal to FHE operations)

• Chair (Deployer): Can assign reviewers, decrypt averages, publish results
• Authors: Can submit papers, view their own submissions
• Reviewers: Can only review assigned papers

• Efficient type casting (euint8 → euint32 only when aggregating)
• Batch permission grants using FHE.allowThis() and FHE.allow()
• Minimal storage for encrypted values

Run the comprehensive test suite:

npm test

Test Coverage: 37 tests covering:

• Paper submission workflow
• Reviewer assignment
• FHE-encrypted review submission
• Access control restrictions
• Score aggregation
• Result publication
• Edge cases and error handling

Important: Tests use Hardhat's FHEVM mock for encryption simulation. They automatically skip on real networks.

Sample test output:

PeerReviewFHE
  ✓ Should deploy with correct initial values
  ✓ Should allow paper submission
  ✓ Should assign reviewers
  ✓ Should submit encrypted reviews
  ✓ Should calculate average score
  ✓ Should publish results
  ...
  37 passing (2.5s)

• Network: Ethereum Sepolia Testnet
• Contract Address: 0xA170eDedef0b9E4E08590549AEE475efecbd54C5
• Deployment Block: 7270801
• Chair Address: 0x662e7aaF16Ad093291084235517A96Ca294cC41e
• Transaction Hash: 0x1a52dcc0ccebad1e00e1e5fd3cd9b17a2b6d2e49f088c63f54b5da5a2e0a6f8b

View on Etherscan: Contract Link

• Platform: Vercel
• URL: https://peerreviewfth.vercel.app/
• Build: Vite production build
• Environment: Sepolia testnet

• Smart Contract: 446 lines of Solidity
• Tests: 37 test cases (100% passing)
• Frontend: React with TypeScript
• Total Commits: Meaningful development history
• Development Time: Focused Zama Developer Program submission

1. Multi-Round Reviews: Support revision and re-review cycles
2. Reviewer Reputation: On-chain reputation scores for reviewers
3. Author Rebuttals: Allow authors to respond to reviews
4. Custom Thresholds: Configurable acceptance criteria per conference

1. IPFS Integration: Store full papers on decentralized storage
2. NFT Certificates: Issue NFT certificates for accepted papers
3. Multi-Signature Chair: Distribute chair powers to committee
4. Cross-Chain Support: Deploy on multiple EVM chains
5. Reviewer Anonymity: Enhanced identity protection using zk-SNARKs
6. Automatic Reviewer Matching: AI-powered reviewer assignment
7. Conference Management: Multi-conference support in single contract

1. FHE Performance: Optimize gas costs for encrypted operations
2. Scalability: Layer 2 integration for lower fees
3. Privacy Extensions: Combine FHE with other cryptographic techniques
4. Governance: DAO-based conference management

This project is licensed under the MIT License - see the LICENSE file for details.

• Zama: For the groundbreaking FHEVM technology and comprehensive documentation
• Ethereum Foundation: For the Sepolia testnet infrastructure
• Hardhat Team: For the excellent development framework
• React Team: For the powerful frontend library

• Demo Video: YouTube
• Live Demo: Vercel App
• Contract: Sepolia Etherscan
• Zama FHEVM Docs: docs.zama.ai

This project is a submission for the Zama Developer Program, demonstrating practical applications of Fully Homomorphic Encryption in solving real-world privacy challenges in academic publishing.

Why FHE is Essential for This Use Case:

• Reviewers must never see each other's scores (prevents bias)
• Scores must be aggregated without revealing individual values
• Final average must only be accessible to authorized parties
• System must maintain an immutable audit trail
• Traditional encryption cannot compute on encrypted data

FHE uniquely enables these requirements, making it the only technology capable of achieving truly private peer review on a public blockchain.

Built with 🔐 Privacy and ⛓️ Transparency
Powered by Zama FHEVM