create-fhevm-example 1.3.2 → 1.4.1

package/test/advanced/PrivatePayroll.ts

@@ -0,0 +1,253 @@
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { ethers, fhevm } from "hardhat";
+import { PrivatePayroll, PrivatePayroll__factory } from "../types";
+import { expect } from "chai";
+
+type Signers = {
+  employer: HardhatEthersSigner;
+  employee1: HardhatEthersSigner;
+  employee2: HardhatEthersSigner;
+};
+
+const PAYMENT_PERIOD = 86400; // 1 day for testing
+
+async function deployFixture() {
+  const factory = (await ethers.getContractFactory(
+    "PrivatePayroll"
+  )) as PrivatePayroll__factory;
+  const payroll = (await factory.deploy(PAYMENT_PERIOD)) as PrivatePayroll;
+  const payrollAddress = await payroll.getAddress();
+
+  return { payroll, payrollAddress };
+}
+
+/**
+ * Private Payroll Tests
+ *
+ * Tests confidential salary management and FHE-based payment processing.
+ */
+describe("PrivatePayroll", function () {
+  let signers: Signers;
+  let payroll: PrivatePayroll;
+  let payrollAddress: string;
+
+  before(async function () {
+    const ethSigners: HardhatEthersSigner[] = await ethers.getSigners();
+    signers = {
+      employer: ethSigners[0],
+      employee1: ethSigners[1],
+      employee2: ethSigners[2],
+    };
+  });
+
+  beforeEach(async function () {
+    if (!fhevm.isMock) {
+      console.warn("This test suite cannot run on Sepolia Testnet");
+      this.skip();
+    }
+
+    ({ payroll, payrollAddress } = await deployFixture());
+  });
+
+  describe("Initialization", function () {
+    it("should initialize with correct parameters", async function () {
+      expect(await payroll.employer()).to.equal(signers.employer.address);
+      expect(await payroll.paymentPeriod()).to.equal(BigInt(PAYMENT_PERIOD));
+      expect(await payroll.getEmployeeCount()).to.equal(0n);
+    });
+
+    it("should default to 30 days if zero period provided", async function () {
+      const factory = await ethers.getContractFactory("PrivatePayroll");
+      const payroll30 = await factory.deploy(0);
+      expect(await payroll30.paymentPeriod()).to.equal(30n * 24n * 60n * 60n);
+    });
+  });
+
+  describe("Employee Management", function () {
+    it("should add employee with encrypted salary", async function () {
+      const salary = 5000n;
+
+      const encryptedSalary = await fhevm
+        .createEncryptedInput(payrollAddress, signers.employer.address)
+        .add64(salary)
+        .encrypt();
+
+      await expect(
+        payroll.addEmployee(
+          signers.employee1.address,
+          encryptedSalary.handles[0],
+          encryptedSalary.inputProof
+        )
+      )
+        .to.emit(payroll, "EmployeeAdded")
+        .withArgs(signers.employee1.address);
+
+      expect(await payroll.isEmployee(signers.employee1.address)).to.be.true;
+      expect(await payroll.getEmployeeCount()).to.equal(1n);
+    });
+
+    it("should prevent adding duplicate employee", async function () {
+      const enc1 = await fhevm
+        .createEncryptedInput(payrollAddress, signers.employer.address)
+        .add64(5000n)
+        .encrypt();
+
+      await payroll.addEmployee(
+        signers.employee1.address,
+        enc1.handles[0],
+        enc1.inputProof
+      );
+
+      const enc2 = await fhevm
+        .createEncryptedInput(payrollAddress, signers.employer.address)
+        .add64(6000n)
+        .encrypt();
+
+      await expect(
+        payroll.addEmployee(
+          signers.employee1.address,
+          enc2.handles[0],
+          enc2.inputProof
+        )
+      ).to.be.revertedWith("Already an employee");
+    });
+
+    it("should remove employee correctly", async function () {
+      const enc = await fhevm
+        .createEncryptedInput(payrollAddress, signers.employer.address)
+        .add64(5000n)
+        .encrypt();
+
+      await payroll.addEmployee(
+        signers.employee1.address,
+        enc.handles[0],
+        enc.inputProof
+      );
+
+      await expect(payroll.removeEmployee(signers.employee1.address))
+        .to.emit(payroll, "EmployeeRemoved")
+        .withArgs(signers.employee1.address);
+
+      expect(await payroll.isEmployee(signers.employee1.address)).to.be.false;
+      expect(await payroll.getEmployeeCount()).to.equal(0n);
+    });
+
+    it("should update employee salary", async function () {
+      // Add employee
+      const enc1 = await fhevm
+        .createEncryptedInput(payrollAddress, signers.employer.address)
+        .add64(5000n)
+        .encrypt();
+
+      await payroll.addEmployee(
+        signers.employee1.address,
+        enc1.handles[0],
+        enc1.inputProof
+      );
+
+      // Update salary
+      const enc2 = await fhevm
+        .createEncryptedInput(payrollAddress, signers.employer.address)
+        .add64(6000n)
+        .encrypt();
+
+      await expect(
+        payroll.updateSalary(
+          signers.employee1.address,
+          enc2.handles[0],
+          enc2.inputProof
+        )
+      )
+        .to.emit(payroll, "SalaryUpdated")
+        .withArgs(signers.employee1.address);
+    });
+  });
+
+  describe("Funding", function () {
+    it("should accept funds from employer", async function () {
+      const amount = ethers.parseEther("10");
+
+      await expect(payroll.fund({ value: amount }))
+        .to.emit(payroll, "ContractFunded")
+        .withArgs(amount);
+
+      expect(await payroll.getBalance()).to.equal(amount);
+    });
+
+    it("should accept direct ETH transfers", async function () {
+      const amount = ethers.parseEther("5");
+
+      await signers.employer.sendTransaction({
+        to: payrollAddress,
+        value: amount,
+      });
+
+      expect(await payroll.getBalance()).to.equal(amount);
+    });
+
+    it("should reject zero funding via fund()", async function () {
+      await expect(payroll.fund({ value: 0 })).to.be.revertedWith(
+        "Must send funds"
+      );
+    });
+  });
+
+  describe("Access Control", function () {
+    it("should prevent non-employer from adding employees", async function () {
+      const enc = await fhevm
+        .createEncryptedInput(payrollAddress, signers.employee1.address)
+        .add64(5000n)
+        .encrypt();
+
+      await expect(
+        payroll
+          .connect(signers.employee1)
+          .addEmployee(
+            signers.employee2.address,
+            enc.handles[0],
+            enc.inputProof
+          )
+      ).to.be.revertedWith("Only employer");
+    });
+
+    it("should allow employee to get their salary handle", async function () {
+      const enc = await fhevm
+        .createEncryptedInput(payrollAddress, signers.employer.address)
+        .add64(5000n)
+        .encrypt();
+
+      await payroll.addEmployee(
+        signers.employee1.address,
+        enc.handles[0],
+        enc.inputProof
+      );
+
+      // Employee should be able to call getMySalary
+      const salaryHandle = await payroll
+        .connect(signers.employee1)
+        .getMySalary();
+      expect(salaryHandle).to.not.equal(0n);
+    });
+
+    it("should prevent non-employee from getting salary", async function () {
+      await expect(
+        payroll.connect(signers.employee1).getMySalary()
+      ).to.be.revertedWith("Not an employee");
+    });
+  });
+
+  describe("View Functions", function () {
+    it("should return correct payroll info", async function () {
+      await payroll.fund({ value: ethers.parseEther("1") });
+
+      const info = await payroll.getPayrollInfo();
+      expect(info.employeeCount).to.equal(0n);
+      expect(info.balance).to.equal(ethers.parseEther("1"));
+      expect(info.period).to.equal(BigInt(PAYMENT_PERIOD));
+    });
+
+    it("should check payment due status", async function () {
+      expect(await payroll.isPaymentDue(signers.employee1.address)).to.be.false;
+    });
+  });
+});

package/test/basic/decryption/PublicDecryptMultipleValues.ts

@@ -0,0 +1,254 @@
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import type { ClearValueType } from "@zama-fhe/relayer-sdk/node";
+import { expect } from "chai";
+import { ethers as EthersT } from "ethers";
+import { ethers, fhevm } from "hardhat";
+import * as hre from "hardhat";
+
+import { HighestDieRoll, HighestDieRoll__factory } from "../types";
+import { Signers } from "./types";
+
+async function deployFixture() {
+  // Contracts are deployed using the first signer/account by default
+  const factory = (await ethers.getContractFactory(
+    "HighestDieRoll"
+  )) as HighestDieRoll__factory;
+  const highestDiceRoll = (await factory.deploy()) as HighestDieRoll;
+  const highestDiceRoll_address = await highestDiceRoll.getAddress();
+
+  return { highestDiceRoll, highestDiceRoll_address };
+}
+
+describe("HighestDieRoll", function () {
+  let contract: HighestDieRoll;
+  let contractAddress: string;
+  let signers: Signers;
+  let playerA: HardhatEthersSigner;
+  let playerB: HardhatEthersSigner;
+
+  before(async function () {
+    // Check whether the tests are running against an FHEVM mock environment
+    if (!hre.fhevm.isMock) {
+      throw new Error(`This hardhat test suite cannot run on Sepolia Testnet`);
+    }
+
+    const ethSigners: HardhatEthersSigner[] = await ethers.getSigners();
+    signers = {
+      owner: ethSigners[0],
+      alice: ethSigners[1],
+      bob: ethSigners[2],
+    };
+
+    playerA = signers.alice;
+    playerB = signers.bob;
+  });
+
+  beforeEach(async function () {
+    // Deploy a new contract each time we run a new test
+    const deployment = await deployFixture();
+    contractAddress = deployment.highestDiceRoll_address;
+    contract = deployment.highestDiceRoll;
+  });
+
+  /**
+   * Helper: Parses the GameCreated event from a transaction receipt.
+   * WARNING: This function is for illustrative purposes only and is not production-ready
+   * (it does not handle several events in same tx).
+   */
+  function parseGameCreatedEvent(
+    txReceipt: EthersT.ContractTransactionReceipt | null
+  ): {
+    txHash: `0x${string}`;
+    gameId: number;
+    playerA: `0x${string}`;
+    playerB: `0x${string}`;
+    playerAEncryptedDiceRoll: `0x${string}`;
+    playerBEncryptedDiceRoll: `0x${string}`;
+  } {
+    const gameCreatedEvents: Array<{
+      txHash: `0x${string}`;
+      gameId: number;
+      playerA: `0x${string}`;
+      playerB: `0x${string}`;
+      playerAEncryptedDiceRoll: `0x${string}`;
+      playerBEncryptedDiceRoll: `0x${string}`;
+    }> = [];
+
+    if (txReceipt) {
+      const logs = Array.isArray(txReceipt.logs)
+        ? txReceipt.logs
+        : [txReceipt.logs];
+      for (let i = 0; i < logs.length; ++i) {
+        const parsedLog = contract.interface.parseLog(logs[i]);
+        if (!parsedLog || parsedLog.name !== "GameCreated") {
+          continue;
+        }
+        const ge = {
+          txHash: txReceipt.hash as `0x${string}`,
+          gameId: Number(parsedLog.args[0]),
+          playerA: parsedLog.args[1],
+          playerB: parsedLog.args[2],
+          playerAEncryptedDiceRoll: parsedLog.args[3],
+          playerBEncryptedDiceRoll: parsedLog.args[4],
+        };
+        gameCreatedEvents.push(ge);
+      }
+    }
+
+    // In this example, we expect on one single GameCreated event
+    expect(gameCreatedEvents.length).to.eq(1);
+
+    return gameCreatedEvents[0];
+  }
+
+  // ✅ Test should succeed
+  it("decryption should succeed", async function () {
+    console.log(``);
+    console.log(`🎲 HighestDieRoll Game contract address: ${contractAddress}`);
+    console.log(`   🤖 playerA.address: ${playerA.address}`);
+    console.log(`   🎃 playerB.address: ${playerB.address}`);
+    console.log(``);
+
+    // Starts a new Heads or Tails game. This will emit a `GameCreated` event
+    const tx = await contract
+      .connect(signers.owner)
+      .highestDieRoll(playerA, playerB);
+
+    // Parse the `GameCreated` event
+    const gameCreatedEvent = parseGameCreatedEvent(await tx.wait())!;
+
+    // GameId is 1 since we are playing the first game
+    expect(gameCreatedEvent.gameId).to.eq(1);
+    expect(gameCreatedEvent.playerA).to.eq(playerA.address);
+    expect(gameCreatedEvent.playerB).to.eq(playerB.address);
+    expect(await contract.getGamesCount()).to.eq(1);
+
+    console.log(`✅ New game #${gameCreatedEvent.gameId} created!`);
+    console.log(JSON.stringify(gameCreatedEvent, null, 2));
+
+    const gameId = gameCreatedEvent.gameId;
+    const playerADiceRoll = gameCreatedEvent.playerAEncryptedDiceRoll;
+    const playerBDiceRoll = gameCreatedEvent.playerBEncryptedDiceRoll;
+
+    // Call the Zama Relayer to compute the decryption
+    const publicDecryptResults = await fhevm.publicDecrypt([
+      playerADiceRoll,
+      playerBDiceRoll,
+    ]);
+
+    // The Relayer returns a `PublicDecryptResults` object containing:
+    // - the ORDERED clear values (here we have only one single value)
+    // - the ORDERED clear values in ABI-encoded form
+    // - the KMS decryption proof associated with the ORDERED clear values in ABI-encoded form
+    const abiEncodedClearGameResult =
+      publicDecryptResults.abiEncodedClearValues;
+    const decryptionProof = publicDecryptResults.decryptionProof;
+
+    const clearValueA: ClearValueType =
+      publicDecryptResults.clearValues[playerADiceRoll];
+    const clearValueB: ClearValueType =
+      publicDecryptResults.clearValues[playerBDiceRoll];
+
+    expect(typeof clearValueA).to.eq("bigint");
+    expect(typeof clearValueB).to.eq("bigint");
+
+    // playerA's 8-sided die roll result (between 1 and 8)
+    const a = (Number(clearValueA) % 8) + 1;
+    // playerB's 8-sided die roll result (between 1 and 8)
+    const b = (Number(clearValueB) % 8) + 1;
+
+    const isDraw = a === b;
+    const playerAWon = a > b;
+    const playerBWon = a < b;
+
+    console.log(``);
+    console.log(`🎲 playerA's 8-sided die roll is ${a}`);
+    console.log(`🎲 playerB's 8-sided die roll is ${b}`);
+
+    // Let's forward the `PublicDecryptResults` content to the on-chain contract whose job
+    // will simply be to verify the proof and store the final winner of the game
+    await contract.recordAndVerifyWinner(
+      gameId,
+      abiEncodedClearGameResult,
+      decryptionProof
+    );
+
+    const isRevealed = await contract.isGameRevealed(gameId);
+    const winner = await contract.getWinner(gameId);
+
+    expect(isRevealed).to.eq(true);
+    expect(
+      winner === playerA.address ||
+        winner === playerB.address ||
+        winner === EthersT.ZeroAddress
+    ).to.eq(true);
+
+    expect(isDraw).to.eq(winner === EthersT.ZeroAddress);
+    expect(playerAWon).to.eq(winner === playerA.address);
+    expect(playerBWon).to.eq(winner === playerB.address);
+
+    console.log(``);
+    if (winner === playerA.address) {
+      console.log(`🤖 playerA is the winner 🥇🥇`);
+    } else if (winner === playerB.address) {
+      console.log(`🎃 playerB is the winner 🥇🥇`);
+    } else if (winner === EthersT.ZeroAddress) {
+      console.log(`Game is a draw!`);
+    }
+  });
+
+  // ❌ Test should fail because clear values are ABI-encoded in the wrong order.
+  it("decryption should fail when ABI-encoding is wrongly ordered", async function () {
+    // Test Case: Verify strict ordering is enforced for cryptographic proof generation.
+    // The `decryptionProof` is generated based on the expected order (A, B). By ABI-encoding
+    // the clear values in the **reverse order** (B, A), we create a mismatch when the contract
+    // internally verifies the proof (e.g., checks a signature against a newly computed hash).
+    // This intentional failure is expected to revert with the `KMSInvalidSigner` error,
+    // confirming the proof's order dependency.
+    const tx = await contract
+      .connect(signers.owner)
+      .highestDieRoll(playerA, playerB);
+    const gameCreatedEvent = parseGameCreatedEvent(await tx.wait())!;
+    const gameId = gameCreatedEvent.gameId;
+    const playerADiceRoll = gameCreatedEvent.playerAEncryptedDiceRoll;
+    const playerBDiceRoll = gameCreatedEvent.playerBEncryptedDiceRoll;
+    // Call `fhevm.publicDecrypt` using order (A, B)
+    const publicDecryptResults = await fhevm.publicDecrypt([
+      playerADiceRoll,
+      playerBDiceRoll,
+    ]);
+    const clearValueA: ClearValueType =
+      publicDecryptResults.clearValues[playerADiceRoll];
+    const clearValueB: ClearValueType =
+      publicDecryptResults.clearValues[playerBDiceRoll];
+    const decryptionProof = publicDecryptResults.decryptionProof;
+    expect(typeof clearValueA).to.eq("bigint");
+    expect(typeof clearValueB).to.eq("bigint");
+    expect(
+      ethers.AbiCoder.defaultAbiCoder().encode(
+        ["uint256", "uint256"],
+        [clearValueA, clearValueB]
+      )
+    ).to.eq(publicDecryptResults.abiEncodedClearValues);
+    const wrongOrderBAInsteadOfABAbiEncodedValues =
+      ethers.AbiCoder.defaultAbiCoder().encode(
+        ["uint256", "uint256"],
+        [clearValueB, clearValueA]
+      );
+    // ❌ Call `contract.recordAndVerifyWinner` using order (B, A)
+    await expect(
+      contract.recordAndVerifyWinner(
+        gameId,
+        wrongOrderBAInsteadOfABAbiEncodedValues,
+        decryptionProof
+      )
+    ).to.be.revertedWithCustomError(
+      {
+        interface: new EthersT.Interface([
+          "error KMSInvalidSigner(address invalidSigner)",
+        ]),
+      },
+      "KMSInvalidSigner"
+    );
+  });
+});