Hidden Voting

Private voting system with homomorphic vote tallying (Yes/No). Ballots are added without decryption. Only final totals are revealed, ensuring individual vote secrecy forever.

To run this example correctly, make sure the files are placed in the following directories:

.sol file → <your-project-root-dir>/contracts/
.ts file → <your-project-root-dir>/test/

This ensures Hardhat can compile and test your contracts as expected.

🔐 FHE API Reference (12 items)

Types: ebool · euint64 · externalEuint8

Functions:

FHE.add() - Homomorphic addition: result = a + b (overflow wraps)
FHE.allowThis() - Grants contract permission to operate on ciphertext
FHE.asEuint64() - Encrypts a plaintext uint64 value into euint64
FHE.checkSignatures() - Verifies KMS decryption proof (reverts if invalid)
FHE.fromExternal() - Validates and converts external encrypted input using inputProof
FHE.gt() - Encrypted greater-than: returns ebool(a > b)
FHE.makePubliclyDecryptable() - Marks ciphertext for public decryption via relayer
FHE.select() - Encrypted if-then-else: select(cond, a, b) → returns a if true, b if false
FHE.toBytes32() - Converts encrypted handle to bytes32 for proof arrays

// SPDX-License-Identifier: BSD-3-Clause-Clear
pragma solidity ^0.8.24;

import {FHE, euint64, ebool, externalEuint8} from "@fhevm/solidity/lib/FHE.sol";
import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";

/**
 * @notice Private voting system with homomorphic vote tallying (Yes/No).
 *         Ballots are added without decryption. Only final totals are revealed,
 *         ensuring individual vote secrecy forever.
 *
 * @dev Flow: vote() → closeVoting() → revealResults()
 *      ⚡ Gas: Each vote costs ~200k gas (FHE.add + FHE.select operations)
 */
contract HiddenVoting is ZamaEthereumConfig {
    enum VotingState {
        Active, // Accepting votes
        Closed, // Voting ended, pending reveal
        Revealed // Results revealed on-chain
    }

    address public owner;

    /// Current voting state
    VotingState public votingState;

    /// Proposal description
    string public proposal;

    /// Voting end timestamp
    uint256 public endTime;

    /// Whether an address has voted
    mapping(address => bool) public hasVoted;

    /// Total number of voters
    uint256 public voterCount;

    /// Encrypted total of Yes votes (1s)
    euint64 private _yesVotes;

    /// Encrypted total of No votes (0s counted separately for verification)
    euint64 private _noVotes;

    /// Revealed results
    uint64 public revealedYesVotes;
    uint64 public revealedNoVotes;

    /// Emitted when a vote is cast
    /// @param voter Address of the voter
    event VoteCast(address indexed voter);

    /// @notice Emitted when voting is closed
    /// @param encryptedYes Handle for encrypted Yes count
    /// @param encryptedNo Handle for encrypted No count
    event VotingClosed(euint64 encryptedYes, euint64 encryptedNo);

    /// @notice Emitted when results are revealed
    /// @param yesVotes Final Yes vote count
    /// @param noVotes Final No vote count
    event ResultsRevealed(uint64 yesVotes, uint64 noVotes);

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call");
        _;
    }

    constructor(string memory _proposal, uint256 _durationSeconds) {
        require(bytes(_proposal).length > 0, "Empty proposal");
        require(_durationSeconds > 0, "Duration must be positive");

        owner = msg.sender;
        proposal = _proposal;
        endTime = block.timestamp + _durationSeconds;
        votingState = VotingState.Active;

        // Initialize encrypted counters
        _yesVotes = FHE.asEuint64(0);
        _noVotes = FHE.asEuint64(0);
        FHE.allowThis(_yesVotes);
        FHE.allowThis(_noVotes);
    }

    /// @notice Cast an encrypted vote (0=No, 1=Yes)
    /// @dev Homomorphic tallying: votes added without decryption!
    /// @param inputProof Proof validating the encrypted input
    function vote(
        externalEuint8 encryptedVote,
        bytes calldata inputProof
    ) external {
        require(votingState == VotingState.Active, "Voting not active");
        require(block.timestamp < endTime, "Voting has ended");
        require(!hasVoted[msg.sender], "Already voted");

        // Convert vote and normalize to 0 or 1
        euint64 voteValue = FHE.asEuint64(
            FHE.fromExternal(encryptedVote, inputProof)
        );

        // 🧮 Why homomorphic? Votes are tallied WITHOUT decrypting individual ballots!
        // Individual votes remain private forever
        ebool isYes = FHE.gt(voteValue, FHE.asEuint64(0));

        // ➕ Add to Yes counter if vote is Yes (1)
        euint64 yesIncrement = FHE.select(
            isYes,
            FHE.asEuint64(1),
            FHE.asEuint64(0)
        );
        _yesVotes = FHE.add(_yesVotes, yesIncrement);

        euint64 noIncrement = FHE.select(
            isYes,
            FHE.asEuint64(0),
            FHE.asEuint64(1)
        );
        _noVotes = FHE.add(_noVotes, noIncrement);

        FHE.allowThis(_yesVotes);
        FHE.allowThis(_noVotes);

        hasVoted[msg.sender] = true;
        voterCount++;

        emit VoteCast(msg.sender);
    }

    /// @notice Close voting and mark results for decryption
    /// @dev Only owner can call after voting period ends
    function closeVoting() external onlyOwner {
        require(votingState == VotingState.Active, "Voting not active");
        require(block.timestamp >= endTime, "Voting not yet ended");

        // Mark totals for public decryption via relayer
        FHE.makePubliclyDecryptable(_yesVotes);
        FHE.makePubliclyDecryptable(_noVotes);

        votingState = VotingState.Closed;

        emit VotingClosed(_yesVotes, _noVotes);
    }

    /// @notice Reveal voting results with KMS decryption proof
    /// @dev Anyone can call with valid decryption proof
    /// @param abiEncodedResults ABI-encoded (uint64 yes, uint64 no)
    /// @param decryptionProof KMS signature proving decryption
    function revealResults(
        bytes memory abiEncodedResults,
        bytes memory decryptionProof
    ) external {
        require(votingState == VotingState.Closed, "Voting not closed");

        // Build handle array for signature verification
        bytes32[] memory cts = new bytes32[](2);
        cts[0] = FHE.toBytes32(_yesVotes);
        cts[1] = FHE.toBytes32(_noVotes);

        // Verify KMS proof (reverts if invalid)
        FHE.checkSignatures(cts, abiEncodedResults, decryptionProof);

        // Decode verified plaintext results
        (uint64 yesCount, uint64 noCount) = abi.decode(
            abiEncodedResults,
            (uint64, uint64)
        );

        revealedYesVotes = yesCount;
        revealedNoVotes = noCount;
        votingState = VotingState.Revealed;

        emit ResultsRevealed(yesCount, noCount);
    }

    function getEncryptedYesVotes() external view returns (euint64) {
        require(votingState != VotingState.Active, "Voting still active");
        return _yesVotes;
    }

    function getEncryptedNoVotes() external view returns (euint64) {
        require(votingState != VotingState.Active, "Voting still active");
        return _noVotes;
    }

    /// @notice Check if proposal passed (more Yes than No)
    function hasPassed() external view returns (bool) {
        require(votingState == VotingState.Revealed, "Results not revealed");
        return revealedYesVotes > revealedNoVotes;
    }

    /// @notice Get time remaining for voting
    function timeRemaining() external view returns (uint256) {
        if (block.timestamp >= endTime) return 0;
        return endTime - block.timestamp;
    }
}

import { expect } from "chai";
import { ethers, fhevm } from "hardhat";
import * as hre from "hardhat";

/**
 * Hidden Voting Tests
 *
 * Tests the private voting mechanism and batched result decryption using FHE.
 * Validates that individual votes remain secret while final tallies are computed on-chain.
 */
describe("HiddenVoting", function () {
  let voting: any;
  let owner: any;
  let voter1: any;
  let voter2: any;
  let voter3: any;

  const PROPOSAL = "Should we upgrade to v2?";

  async function deployVoting(durationSeconds: number = 60) {
    const votingContract = await ethers.deployContract("HiddenVoting", [
      PROPOSAL,
      durationSeconds,
    ]);
    return votingContract;
  }

  beforeEach(async function () {
    [owner, voter1, voter2, voter3] = await ethers.getSigners();
  });

  describe("Voting Creation", function () {
    it("should create voting with correct parameters", async function () {
      voting = await deployVoting(120);

      expect(await voting.votingState()).to.equal(0); // Active
      expect(await voting.proposal()).to.equal(PROPOSAL);
      expect(await voting.voterCount()).to.equal(0);
    });

    it("should revert with empty proposal", async function () {
      await expect(
        ethers.deployContract("HiddenVoting", ["", 60])
      ).to.be.revertedWith("Empty proposal");
    });

    it("should revert with zero duration", async function () {
      await expect(
        ethers.deployContract("HiddenVoting", [PROPOSAL, 0])
      ).to.be.revertedWith("Duration must be positive");
    });
  });

  describe("Casting Votes", function () {
    beforeEach(async function () {
      voting = await deployVoting(3600); // 1 hour
    });

    it("should accept Yes vote (1)", async function () {
      // 🔐 Encrypt the vote locally:
      // 1 = Yes, 0 = No.
      const encryptedVote = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(1) // Yes
        .encrypt();

      // 🚀 Submit the encrypted vote handle and proof:
      await expect(
        voting
          .connect(voter1)
          .vote(encryptedVote.handles[0], encryptedVote.inputProof)
      ).to.not.be.reverted;

      expect(await voting.hasVoted(voter1.address)).to.be.true;
      expect(await voting.voterCount()).to.equal(1);
    });

    it("should accept No vote (0)", async function () {
      const encryptedVote = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(0) // No
        .encrypt();

      await expect(
        voting
          .connect(voter1)
          .vote(encryptedVote.handles[0], encryptedVote.inputProof)
      ).to.not.be.reverted;

      expect(await voting.hasVoted(voter1.address)).to.be.true;
    });

    it("should reject second vote from same address", async function () {
      const enc1 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(1)
        .encrypt();
      await voting.connect(voter1).vote(enc1.handles[0], enc1.inputProof);

      const enc2 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(0)
        .encrypt();

      await expect(
        voting.connect(voter1).vote(enc2.handles[0], enc2.inputProof)
      ).to.be.revertedWith("Already voted");
    });

    it("should track multiple voters", async function () {
      // Voter 1 - Yes
      const enc1 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(1)
        .encrypt();
      await voting.connect(voter1).vote(enc1.handles[0], enc1.inputProof);

      // Voter 2 - No
      const enc2 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter2.address)
        .add8(0)
        .encrypt();
      await voting.connect(voter2).vote(enc2.handles[0], enc2.inputProof);

      // Voter 3 - Yes
      const enc3 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter3.address)
        .add8(1)
        .encrypt();
      await voting.connect(voter3).vote(enc3.handles[0], enc3.inputProof);

      expect(await voting.voterCount()).to.equal(3);
    });
  });

  describe("Close Voting", function () {
    beforeEach(async function () {
      voting = await deployVoting(10); // 10 seconds

      // Cast some votes
      const enc1 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(1)
        .encrypt();
      await voting.connect(voter1).vote(enc1.handles[0], enc1.inputProof);

      const enc2 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter2.address)
        .add8(0)
        .encrypt();
      await voting.connect(voter2).vote(enc2.handles[0], enc2.inputProof);
    });

    it("should not allow closing before time ends", async function () {
      await expect(voting.connect(owner).closeVoting()).to.be.revertedWith(
        "Voting not yet ended"
      );
    });

    it("should allow owner to close after time passes", async function () {
      await hre.network.provider.send("evm_increaseTime", [12]);
      await hre.network.provider.send("evm_mine");

      await expect(voting.connect(owner).closeVoting()).to.not.be.reverted;
      expect(await voting.votingState()).to.equal(1); // Closed
    });

    it("should not allow non-owner to close", async function () {
      await hre.network.provider.send("evm_increaseTime", [12]);
      await hre.network.provider.send("evm_mine");

      await expect(voting.connect(voter1).closeVoting()).to.be.revertedWith(
        "Only owner can call"
      );
    });
  });

  describe("Full Voting Flow", function () {
    it("should correctly tally votes", async function () {
      if (!hre.fhevm.isMock) {
        console.log("Skipping: Test requires mock environment");
        this.skip();
      }

      // Deploy with short duration
      voting = await ethers.deployContract("HiddenVoting", [PROPOSAL, 10]);

      // Cast votes: 2 Yes, 1 No
      const enc1 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(1) // Yes
        .encrypt();
      await voting.connect(voter1).vote(enc1.handles[0], enc1.inputProof);

      const enc2 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter2.address)
        .add8(0) // No
        .encrypt();
      await voting.connect(voter2).vote(enc2.handles[0], enc2.inputProof);

      const enc3 = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter3.address)
        .add8(1) // Yes
        .encrypt();
      await voting.connect(voter3).vote(enc3.handles[0], enc3.inputProof);

      // Wait and close voting
      await hre.network.provider.send("evm_increaseTime", [12]);
      await hre.network.provider.send("evm_mine");

      await voting.connect(owner).closeVoting();

      // Get encrypted results
      const encYes = await voting.getEncryptedYesVotes();
      const encNo = await voting.getEncryptedNoVotes();

      // 🔓 Revelation Process (Public Decryption):
      // 1. Request decryption for the aggregated Yes and No vote counts.
      const handles = [encYes, encNo];
      const decryptResults = await fhevm.publicDecrypt(handles);

      // 2. Reveal results on-chain by providing the clear tallies and the KMS proof.
      await voting.revealResults(
        decryptResults.abiEncodedClearValues,
        decryptResults.decryptionProof
      );

      // Verify results
      expect(await voting.votingState()).to.equal(2); // Revealed
      expect(await voting.revealedYesVotes()).to.equal(2n);
      expect(await voting.revealedNoVotes()).to.equal(1n);
      expect(await voting.hasPassed()).to.be.true;

      console.log(`✅ Proposal: ${await voting.proposal()}`);
      console.log(`📊 Yes: ${await voting.revealedYesVotes()}`);
      console.log(`📊 No: ${await voting.revealedNoVotes()}`);
      console.log(`🏆 Passed: ${await voting.hasPassed()}`);
    });

    it("should handle unanimous No votes", async function () {
      if (!hre.fhevm.isMock) {
        this.skip();
      }

      voting = await ethers.deployContract("HiddenVoting", [PROPOSAL, 10]);

      // All vote No
      for (const voter of [voter1, voter2, voter3]) {
        const enc = await fhevm
          .createEncryptedInput(await voting.getAddress(), voter.address)
          .add8(0)
          .encrypt();
        await voting.connect(voter).vote(enc.handles[0], enc.inputProof);
      }

      await hre.network.provider.send("evm_increaseTime", [12]);
      await hre.network.provider.send("evm_mine");

      await voting.connect(owner).closeVoting();

      const encYes = await voting.getEncryptedYesVotes();
      const encNo = await voting.getEncryptedNoVotes();
      const decryptResults = await fhevm.publicDecrypt([encYes, encNo]);

      await voting.revealResults(
        decryptResults.abiEncodedClearValues,
        decryptResults.decryptionProof
      );

      expect(await voting.revealedYesVotes()).to.equal(0n);
      expect(await voting.revealedNoVotes()).to.equal(3n);
      expect(await voting.hasPassed()).to.be.false;
    });
  });

  // ============================================
  // EDGE CASES
  // ============================================

  describe("Edge Cases", function () {
    beforeEach(async function () {
      voting = await deployVoting(3600);
    });

    it("should reject vote after voting closes", async function () {
      // Fast forward past end time
      await hre.network.provider.send("evm_increaseTime", [3601]);
      await hre.network.provider.send("evm_mine");

      await voting.connect(owner).closeVoting();

      const encryptedVote = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(1)
        .encrypt();

      await expect(
        voting
          .connect(voter1)
          .vote(encryptedVote.handles[0], encryptedVote.inputProof)
      ).to.be.revertedWith("Voting not active");
    });

    it("should allow closing with no votes", async function () {
      // Contract allows closing with no votes
      await hre.network.provider.send("evm_increaseTime", [3601]);
      await hre.network.provider.send("evm_mine");

      await expect(voting.connect(owner).closeVoting()).to.not.be.reverted;
    });

    it("should reject reveal before closing", async function () {
      // Cast a vote
      const enc = await fhevm
        .createEncryptedInput(await voting.getAddress(), voter1.address)
        .add8(1)
        .encrypt();
      await voting.connect(voter1).vote(enc.handles[0], enc.inputProof);

      // Try to reveal without closing
      await expect(voting.revealResults("0x", "0x")).to.be.revertedWith(
        "Voting not closed"
      );
    });
  });
});

PreviousBlind Auction NextPrivate Payroll

Last updated 13 days ago

import { expect } from "chai"; import { ethers, fhevm } from "hardhat"; import * as hre from "hardhat"; /** * Hidden Voting Tests * * Tests the private voting mechanism and batched result decryption using FHE. * Validates that individual votes remain secret while final tallies are computed on-chain. */ describe("HiddenVoting", function () { let voting: any; let owner: any; let voter1: any; let voter2: any; let voter3: any; const PROPOSAL = "Should we upgrade to v2?"; async function deployVoting(durationSeconds: number = 60) { const votingContract = await ethers.deployContract("HiddenVoting", [ PROPOSAL, durationSeconds, ]); return votingContract; } beforeEach(async function () { [owner, voter1, voter2, voter3] = await ethers.getSigners(); }); describe("Voting Creation", function () { it("should create voting with correct parameters", async function () { voting = await deployVoting(120); expect(await voting.votingState()).to.equal(0); // Active expect(await voting.proposal()).to.equal(PROPOSAL); expect(await voting.voterCount()).to.equal(0); }); it("should revert with empty proposal", async function () { await expect( ethers.deployContract("HiddenVoting", ["", 60]) ).to.be.revertedWith("Empty proposal"); }); it("should revert with zero duration", async function () { await expect( ethers.deployContract("HiddenVoting", [PROPOSAL, 0]) ).to.be.revertedWith("Duration must be positive"); }); }); describe("Casting Votes", function () { beforeEach(async function () { voting = await deployVoting(3600); // 1 hour }); it("should accept Yes vote (1)", async function () { // 🔐 Encrypt the vote locally: // 1 = Yes, 0 = No. const encryptedVote = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(1) // Yes .encrypt(); // 🚀 Submit the encrypted vote handle and proof: await expect( voting .connect(voter1) .vote(encryptedVote.handles[0], encryptedVote.inputProof) ).to.not.be.reverted; expect(await voting.hasVoted(voter1.address)).to.be.true; expect(await voting.voterCount()).to.equal(1); }); it("should accept No vote (0)", async function () { const encryptedVote = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(0) // No .encrypt(); await expect( voting .connect(voter1) .vote(encryptedVote.handles[0], encryptedVote.inputProof) ).to.not.be.reverted; expect(await voting.hasVoted(voter1.address)).to.be.true; }); it("should reject second vote from same address", async function () { const enc1 = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(1) .encrypt(); await voting.connect(voter1).vote(enc1.handles[0], enc1.inputProof); const enc2 = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(0) .encrypt(); await expect( voting.connect(voter1).vote(enc2.handles[0], enc2.inputProof) ).to.be.revertedWith("Already voted"); }); it("should track multiple voters", async function () { // Voter 1 - Yes const enc1 = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(1) .encrypt(); await voting.connect(voter1).vote(enc1.handles[0], enc1.inputProof); // Voter 2 - No const enc2 = await fhevm .createEncryptedInput(await voting.getAddress(), voter2.address) .add8(0) .encrypt(); await voting.connect(voter2).vote(enc2.handles[0], enc2.inputProof); // Voter 3 - Yes const enc3 = await fhevm .createEncryptedInput(await voting.getAddress(), voter3.address) .add8(1) .encrypt(); await voting.connect(voter3).vote(enc3.handles[0], enc3.inputProof); expect(await voting.voterCount()).to.equal(3); }); }); describe("Close Voting", function () { beforeEach(async function () { voting = await deployVoting(10); // 10 seconds // Cast some votes const enc1 = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(1) .encrypt(); await voting.connect(voter1).vote(enc1.handles[0], enc1.inputProof); const enc2 = await fhevm .createEncryptedInput(await voting.getAddress(), voter2.address) .add8(0) .encrypt(); await voting.connect(voter2).vote(enc2.handles[0], enc2.inputProof); }); it("should not allow closing before time ends", async function () { await expect(voting.connect(owner).closeVoting()).to.be.revertedWith( "Voting not yet ended" ); }); it("should allow owner to close after time passes", async function () { await hre.network.provider.send("evm_increaseTime", [12]); await hre.network.provider.send("evm_mine"); await expect(voting.connect(owner).closeVoting()).to.not.be.reverted; expect(await voting.votingState()).to.equal(1); // Closed }); it("should not allow non-owner to close", async function () { await hre.network.provider.send("evm_increaseTime", [12]); await hre.network.provider.send("evm_mine"); await expect(voting.connect(voter1).closeVoting()).to.be.revertedWith( "Only owner can call" ); }); }); describe("Full Voting Flow", function () { it("should correctly tally votes", async function () { if (!hre.fhevm.isMock) { console.log("Skipping: Test requires mock environment"); this.skip(); } // Deploy with short duration voting = await ethers.deployContract("HiddenVoting", [PROPOSAL, 10]); // Cast votes: 2 Yes, 1 No const enc1 = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(1) // Yes .encrypt(); await voting.connect(voter1).vote(enc1.handles[0], enc1.inputProof); const enc2 = await fhevm .createEncryptedInput(await voting.getAddress(), voter2.address) .add8(0) // No .encrypt(); await voting.connect(voter2).vote(enc2.handles[0], enc2.inputProof); const enc3 = await fhevm .createEncryptedInput(await voting.getAddress(), voter3.address) .add8(1) // Yes .encrypt(); await voting.connect(voter3).vote(enc3.handles[0], enc3.inputProof); // Wait and close voting await hre.network.provider.send("evm_increaseTime", [12]); await hre.network.provider.send("evm_mine"); await voting.connect(owner).closeVoting(); // Get encrypted results const encYes = await voting.getEncryptedYesVotes(); const encNo = await voting.getEncryptedNoVotes(); // 🔓 Revelation Process (Public Decryption): // 1. Request decryption for the aggregated Yes and No vote counts. const handles = [encYes, encNo]; const decryptResults = await fhevm.publicDecrypt(handles); // 2. Reveal results on-chain by providing the clear tallies and the KMS proof. await voting.revealResults( decryptResults.abiEncodedClearValues, decryptResults.decryptionProof ); // Verify results expect(await voting.votingState()).to.equal(2); // Revealed expect(await voting.revealedYesVotes()).to.equal(2n); expect(await voting.revealedNoVotes()).to.equal(1n); expect(await voting.hasPassed()).to.be.true; console.log(`✅ Proposal: ${await voting.proposal()}`); console.log(`📊 Yes: ${await voting.revealedYesVotes()}`); console.log(`📊 No: ${await voting.revealedNoVotes()}`); console.log(`🏆 Passed: ${await voting.hasPassed()}`); }); it("should handle unanimous No votes", async function () { if (!hre.fhevm.isMock) { this.skip(); } voting = await ethers.deployContract("HiddenVoting", [PROPOSAL, 10]); // All vote No for (const voter of [voter1, voter2, voter3]) { const enc = await fhevm .createEncryptedInput(await voting.getAddress(), voter.address) .add8(0) .encrypt(); await voting.connect(voter).vote(enc.handles[0], enc.inputProof); } await hre.network.provider.send("evm_increaseTime", [12]); await hre.network.provider.send("evm_mine"); await voting.connect(owner).closeVoting(); const encYes = await voting.getEncryptedYesVotes(); const encNo = await voting.getEncryptedNoVotes(); const decryptResults = await fhevm.publicDecrypt([encYes, encNo]); await voting.revealResults( decryptResults.abiEncodedClearValues, decryptResults.decryptionProof ); expect(await voting.revealedYesVotes()).to.equal(0n); expect(await voting.revealedNoVotes()).to.equal(3n); expect(await voting.hasPassed()).to.be.false; }); }); // ============================================ // EDGE CASES // ============================================ describe("Edge Cases", function () { beforeEach(async function () { voting = await deployVoting(3600); }); it("should reject vote after voting closes", async function () { // Fast forward past end time await hre.network.provider.send("evm_increaseTime", [3601]); await hre.network.provider.send("evm_mine"); await voting.connect(owner).closeVoting(); const encryptedVote = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(1) .encrypt(); await expect( voting .connect(voter1) .vote(encryptedVote.handles[0], encryptedVote.inputProof) ).to.be.revertedWith("Voting not active"); }); it("should allow closing with no votes", async function () { // Contract allows closing with no votes await hre.network.provider.send("evm_increaseTime", [3601]); await hre.network.provider.send("evm_mine"); await expect(voting.connect(owner).closeVoting()).to.not.be.reverted; }); it("should reject reveal before closing", async function () { // Cast a vote const enc = await fhevm .createEncryptedInput(await voting.getAddress(), voter1.address) .add8(1) .encrypt(); await voting.connect(voter1).vote(enc.handles[0], enc.inputProof); // Try to reveal without closing await expect(voting.revealResults("0x", "0x")).to.be.revertedWith( "Voting not closed" ); }); }); });

Good morning