create-fhevm-example 1.3.2 → 1.4.0

package/test/advanced/HiddenVoting.ts

@@ -0,0 +1,268 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+import * as hre from "hardhat";
+
+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 () {
+      const encryptedVote = await fhevm
+        .createEncryptedInput(await voting.getAddress(), voter1.address)
+        .add8(1) // Yes
+        .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;
+      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 new Promise((resolve) => setTimeout(resolve, 11000));
+      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 new Promise((resolve) => setTimeout(resolve, 11000));
+      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();
+
+      // Request public decryption
+      const handles = [encYes, encNo];
+      const decryptResults = await fhevm.publicDecrypt(handles);
+
+      // Reveal results
+      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 new Promise((resolve) => setTimeout(resolve, 11000));
+      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;
+    });
+  });
+});

package/test/advanced/PrivateKYC.ts

@@ -0,0 +1,382 @@
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { ethers, fhevm } from "hardhat";
+import { PrivateKYC, PrivateKYC__factory } from "../types";
+import { expect } from "chai";
+
+type Signers = {
+  owner: HardhatEthersSigner;
+  user1: HardhatEthersSigner;
+  user2: HardhatEthersSigner;
+};
+
+// Country codes (ISO 3166-1 numeric simplified)
+const COUNTRY_US = 1;
+const COUNTRY_UK = 44;
+const COUNTRY_BLOCKED = 99;
+
+async function deployFixture() {
+  const factory = (await ethers.getContractFactory(
+    "PrivateKYC"
+  )) as PrivateKYC__factory;
+  // Allow US and UK initially
+  const kyc = (await factory.deploy([COUNTRY_US, COUNTRY_UK])) as PrivateKYC;
+  const kycAddress = await kyc.getAddress();
+
+  return { kyc, kycAddress };
+}
+
+/**
+ * Private KYC Tests
+ *
+ * Tests encrypted identity verification and predicate proofs.
+ * Demonstrates privacy-preserving KYC without revealing personal data.
+ */
+describe("PrivateKYC", function () {
+  let signers: Signers;
+  let kyc: PrivateKYC;
+  let kycAddress: string;
+
+  before(async function () {
+    const ethSigners: HardhatEthersSigner[] = await ethers.getSigners();
+    signers = {
+      owner: ethSigners[0],
+      user1: ethSigners[1],
+      user2: ethSigners[2],
+    };
+  });
+
+  beforeEach(async function () {
+    if (!fhevm.isMock) {
+      console.warn("This test suite cannot run on Sepolia Testnet");
+      this.skip();
+    }
+
+    ({ kyc, kycAddress } = await deployFixture());
+  });
+
+  describe("Initialization", function () {
+    it("should initialize with correct owner", async function () {
+      expect(await kyc.owner()).to.equal(signers.owner.address);
+    });
+
+    it("should set allowed countries from constructor", async function () {
+      expect(await kyc.isCountryAllowed(COUNTRY_US)).to.be.true;
+      expect(await kyc.isCountryAllowed(COUNTRY_UK)).to.be.true;
+      expect(await kyc.isCountryAllowed(COUNTRY_BLOCKED)).to.be.false;
+    });
+
+    it("should have correct age constants", async function () {
+      expect(await kyc.MIN_AGE_ADULT()).to.equal(18);
+      expect(await kyc.MIN_AGE_DRINKING_US()).to.equal(21);
+    });
+  });
+
+  describe("KYC Submission", function () {
+    it("should allow user to submit encrypted KYC", async function () {
+      // User1: 25 years old, US, credit score 750
+      const enc = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25) // age
+        .add8(COUNTRY_US) // country
+        .add16(750) // credit score
+        .encrypt();
+
+      await expect(
+        kyc
+          .connect(signers.user1)
+          .submitKYC(
+            enc.handles[0],
+            enc.handles[1],
+            enc.handles[2],
+            enc.inputProof
+          )
+      )
+        .to.emit(kyc, "KYCSubmitted")
+        .withArgs(signers.user1.address);
+
+      expect(await kyc.hasSubmittedKYC(signers.user1.address)).to.be.true;
+    });
+
+    it("should prevent duplicate KYC submission", async function () {
+      const enc1 = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25)
+        .add8(COUNTRY_US)
+        .add16(750)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user1)
+        .submitKYC(
+          enc1.handles[0],
+          enc1.handles[1],
+          enc1.handles[2],
+          enc1.inputProof
+        );
+
+      const enc2 = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(30)
+        .add8(COUNTRY_UK)
+        .add16(800)
+        .encrypt();
+
+      await expect(
+        kyc
+          .connect(signers.user1)
+          .submitKYC(
+            enc2.handles[0],
+            enc2.handles[1],
+            enc2.handles[2],
+            enc2.inputProof
+          )
+      ).to.be.revertedWith("Already verified");
+    });
+
+    it("should allow user to revoke their KYC", async function () {
+      const enc = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25)
+        .add8(COUNTRY_US)
+        .add16(750)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user1)
+        .submitKYC(
+          enc.handles[0],
+          enc.handles[1],
+          enc.handles[2],
+          enc.inputProof
+        );
+
+      await expect(kyc.connect(signers.user1).revokeKYC())
+        .to.emit(kyc, "KYCRevoked")
+        .withArgs(signers.user1.address);
+
+      expect(await kyc.hasSubmittedKYC(signers.user1.address)).to.be.false;
+    });
+  });
+
+  describe("Age Verification", function () {
+    beforeEach(async function () {
+      // User1: 25 years old (adult)
+      const enc1 = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25)
+        .add8(COUNTRY_US)
+        .add16(750)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user1)
+        .submitKYC(
+          enc1.handles[0],
+          enc1.handles[1],
+          enc1.handles[2],
+          enc1.inputProof
+        );
+
+      // User2: 17 years old (minor)
+      const enc2 = await fhevm
+        .createEncryptedInput(kycAddress, signers.user2.address)
+        .add8(17)
+        .add8(COUNTRY_US)
+        .add16(0)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user2)
+        .submitKYC(
+          enc2.handles[0],
+          enc2.handles[1],
+          enc2.handles[2],
+          enc2.inputProof
+        );
+    });
+
+    it("should return encrypted result for age verification", async function () {
+      // Verify age 18+ returns encrypted boolean handle
+      const result = await kyc.verifyAge18.staticCall(signers.user1.address);
+      expect(result).to.not.equal(0n);
+    });
+
+    it("should verify 21+ for adult user", async function () {
+      const result = await kyc.verifyAge21.staticCall(signers.user1.address);
+      expect(result).to.not.equal(0n);
+    });
+
+    it("should verify custom age threshold", async function () {
+      const result = await kyc.verifyAgeAbove.staticCall(
+        signers.user1.address,
+        20
+      );
+      expect(result).to.not.equal(0n);
+    });
+  });
+
+  describe("Credit Score Verification", function () {
+    beforeEach(async function () {
+      // User1: credit score 750 (good)
+      const enc1 = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25)
+        .add8(COUNTRY_US)
+        .add16(750)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user1)
+        .submitKYC(
+          enc1.handles[0],
+          enc1.handles[1],
+          enc1.handles[2],
+          enc1.inputProof
+        );
+    });
+
+    it("should verify good credit (700+)", async function () {
+      const result = await kyc.verifyGoodCredit.staticCall(
+        signers.user1.address
+      );
+      expect(result).to.not.equal(0n);
+    });
+
+    it("should verify credit above custom threshold", async function () {
+      const result = await kyc.verifyCreditAbove.staticCall(
+        signers.user1.address,
+        600
+      );
+      expect(result).to.not.equal(0n);
+    });
+  });
+
+  describe("Combined Verification", function () {
+    beforeEach(async function () {
+      const enc = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25)
+        .add8(COUNTRY_US)
+        .add16(750)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user1)
+        .submitKYC(
+          enc.handles[0],
+          enc.handles[1],
+          enc.handles[2],
+          enc.inputProof
+        );
+    });
+
+    it("should verify adult with good credit combined", async function () {
+      const result = await kyc.verifyAdultWithGoodCredit.staticCall(
+        signers.user1.address
+      );
+      expect(result).to.not.equal(0n);
+    });
+  });
+
+  describe("Decryptable Verification", function () {
+    beforeEach(async function () {
+      const enc = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25)
+        .add8(COUNTRY_US)
+        .add16(750)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user1)
+        .submitKYC(
+          enc.handles[0],
+          enc.handles[1],
+          enc.handles[2],
+          enc.inputProof
+        );
+    });
+
+    it("should request age verification with event", async function () {
+      await expect(kyc.requestAgeVerification(signers.user1.address, 18))
+        .to.emit(kyc, "AgeVerificationRequested")
+        .withArgs(signers.user1.address, 18);
+    });
+  });
+
+  describe("Admin Functions", function () {
+    it("should allow owner to update country allowlist", async function () {
+      await expect(kyc.setCountryAllowed(COUNTRY_BLOCKED, true))
+        .to.emit(kyc, "CountryAllowlistUpdated")
+        .withArgs(COUNTRY_BLOCKED, true);
+
+      expect(await kyc.isCountryAllowed(COUNTRY_BLOCKED)).to.be.true;
+    });
+
+    it("should allow batch country update", async function () {
+      await kyc.setCountriesAllowed([50, 51, 52], true);
+
+      expect(await kyc.isCountryAllowed(50)).to.be.true;
+      expect(await kyc.isCountryAllowed(51)).to.be.true;
+      expect(await kyc.isCountryAllowed(52)).to.be.true;
+    });
+
+    it("should prevent non-owner from updating allowlist", async function () {
+      await expect(
+        kyc.connect(signers.user1).setCountryAllowed(COUNTRY_BLOCKED, true)
+      ).to.be.revertedWith("Only owner");
+    });
+  });
+
+  describe("View Functions", function () {
+    it("should return verification time", async function () {
+      const enc = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25)
+        .add8(COUNTRY_US)
+        .add16(750)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user1)
+        .submitKYC(
+          enc.handles[0],
+          enc.handles[1],
+          enc.handles[2],
+          enc.inputProof
+        );
+
+      const verifiedAt = await kyc.getVerificationTime(signers.user1.address);
+      expect(verifiedAt).to.be.greaterThan(0n);
+    });
+
+    it("should allow user to get own identity handles", async function () {
+      const enc = await fhevm
+        .createEncryptedInput(kycAddress, signers.user1.address)
+        .add8(25)
+        .add8(COUNTRY_US)
+        .add16(750)
+        .encrypt();
+
+      await kyc
+        .connect(signers.user1)
+        .submitKYC(
+          enc.handles[0],
+          enc.handles[1],
+          enc.handles[2],
+          enc.inputProof
+        );
+
+      const identity = await kyc.connect(signers.user1).getMyIdentity();
+      expect(identity.age).to.not.equal(0n);
+      expect(identity.countryCode).to.not.equal(0n);
+      expect(identity.creditScore).to.not.equal(0n);
+    });
+
+    it("should prevent non-verified user from getting identity", async function () {
+      await expect(
+        kyc.connect(signers.user1).getMyIdentity()
+      ).to.be.revertedWith("No KYC submitted");
+    });
+  });
+});