create-fhevm-example 1.3.2 → 1.4.1

package/test/basic/encryption/FHECounter.ts

@@ -0,0 +1,112 @@
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { ethers, fhevm } from "hardhat";
+import { FHECounter, FHECounter__factory } from "../types";
+import { expect } from "chai";
+import { FhevmType } from "@fhevm/hardhat-plugin";
+
+type Signers = {
+  deployer: HardhatEthersSigner;
+  alice: HardhatEthersSigner;
+  bob: HardhatEthersSigner;
+};
+
+async function deployFixture() {
+  const factory = (await ethers.getContractFactory(
+    "FHECounter"
+  )) as FHECounter__factory;
+  const fheCounterContract = (await factory.deploy()) as FHECounter;
+  const fheCounterContractAddress = await fheCounterContract.getAddress();
+
+  return { fheCounterContract, fheCounterContractAddress };
+}
+
+describe("FHECounter", function () {
+  let signers: Signers;
+  let fheCounterContract: FHECounter;
+  let fheCounterContractAddress: string;
+
+  before(async function () {
+    const ethSigners: HardhatEthersSigner[] = await ethers.getSigners();
+    signers = {
+      deployer: ethSigners[0],
+      alice: ethSigners[1],
+      bob: ethSigners[2],
+    };
+  });
+
+  beforeEach(async function () {
+    // Check whether the tests are running against an FHEVM mock environment
+    if (!fhevm.isMock) {
+      console.warn(`This hardhat test suite cannot run on Sepolia Testnet`);
+      this.skip();
+    }
+
+    ({ fheCounterContract, fheCounterContractAddress } = await deployFixture());
+  });
+
+  it("encrypted count should be uninitialized after deployment", async function () {
+    const encryptedCount = await fheCounterContract.getCount();
+    // Expect initial count to be bytes32(0) after deployment,
+    // (meaning the encrypted count value is uninitialized)
+    expect(encryptedCount).to.eq(ethers.ZeroHash);
+  });
+
+  it("increment the counter by 1", async function () {
+    const encryptedCountBeforeInc = await fheCounterContract.getCount();
+    expect(encryptedCountBeforeInc).to.eq(ethers.ZeroHash);
+    const clearCountBeforeInc = 0;
+
+    // Encrypt constant 1 as a euint32
+    const clearOne = 1;
+    const encryptedOne = await fhevm
+      .createEncryptedInput(fheCounterContractAddress, signers.alice.address)
+      .add32(clearOne)
+      .encrypt();
+
+    const tx = await fheCounterContract
+      .connect(signers.alice)
+      .increment(encryptedOne.handles[0], encryptedOne.inputProof);
+    await tx.wait();
+
+    const encryptedCountAfterInc = await fheCounterContract.getCount();
+    const clearCountAfterInc = await fhevm.userDecryptEuint(
+      FhevmType.euint32,
+      encryptedCountAfterInc,
+      fheCounterContractAddress,
+      signers.alice
+    );
+
+    expect(clearCountAfterInc).to.eq(clearCountBeforeInc + clearOne);
+  });
+
+  it("decrement the counter by 1", async function () {
+    // Encrypt constant 1 as a euint32
+    const clearOne = 1;
+    const encryptedOne = await fhevm
+      .createEncryptedInput(fheCounterContractAddress, signers.alice.address)
+      .add32(clearOne)
+      .encrypt();
+
+    // First increment by 1, count becomes 1
+    let tx = await fheCounterContract
+      .connect(signers.alice)
+      .increment(encryptedOne.handles[0], encryptedOne.inputProof);
+    await tx.wait();
+
+    // Then decrement by 1, count goes back to 0
+    tx = await fheCounterContract
+      .connect(signers.alice)
+      .decrement(encryptedOne.handles[0], encryptedOne.inputProof);
+    await tx.wait();
+
+    const encryptedCountAfterDec = await fheCounterContract.getCount();
+    const clearCountAfterInc = await fhevm.userDecryptEuint(
+      FhevmType.euint32,
+      encryptedCountAfterDec,
+      fheCounterContractAddress,
+      signers.alice
+    );
+
+    expect(clearCountAfterInc).to.eq(0);
+  });
+});

package/test/basic/fhe-operations/FHEAdd.ts

@@ -0,0 +1,97 @@
+import {
+  FhevmType,
+  HardhatFhevmRuntimeEnvironment,
+} from "@fhevm/hardhat-plugin";
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { expect } from "chai";
+import { ethers } from "hardhat";
+import * as hre from "hardhat";
+
+import { FHEAdd, FHEAdd__factory } from "../types";
+import type { Signers } from "./types";
+
+async function deployFixture() {
+  // Contracts are deployed using the first signer/account by default
+  const factory = (await ethers.getContractFactory(
+    "FHEAdd"
+  )) as FHEAdd__factory;
+  const fheAdd = (await factory.deploy()) as FHEAdd;
+  const fheAdd_address = await fheAdd.getAddress();
+
+  return { fheAdd, fheAdd_address };
+}
+
+/**
+ * This trivial example demonstrates the FHE encryption mechanism
+ * and highlights a common pitfall developers may encounter.
+ */
+describe("FHEAdd", function () {
+  let contract: FHEAdd;
+  let contractAddress: string;
+  let signers: Signers;
+  let bob: 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];
+  });
+
+  beforeEach(async function () {
+    // Deploy a new contract each time we run a new test
+    const deployment = await deployFixture();
+    contractAddress = deployment.fheAdd_address;
+    contract = deployment.fheAdd;
+  });
+
+  it("a + b should succeed", async function () {
+    const fhevm: HardhatFhevmRuntimeEnvironment = hre.fhevm;
+
+    let tx;
+
+    // Let's compute 80 + 123 = 203
+    const a = 80;
+    const b = 123;
+
+    // Alice encrypts and sets `a` as 80
+    const inputA = await fhevm
+      .createEncryptedInput(contractAddress, signers.alice.address)
+      .add8(a)
+      .encrypt();
+    tx = await contract
+      .connect(signers.alice)
+      .setA(inputA.handles[0], inputA.inputProof);
+    await tx.wait();
+
+    // Alice encrypts and sets `b` as 203
+    const inputB = await fhevm
+      .createEncryptedInput(contractAddress, signers.alice.address)
+      .add8(b)
+      .encrypt();
+    tx = await contract
+      .connect(signers.alice)
+      .setB(inputB.handles[0], inputB.inputProof);
+    await tx.wait();
+
+    // Why Bob has FHE permissions to execute the operation in this case ?
+    // See `computeAPlusB()` in `FHEAdd.sol` for a detailed answer
+    tx = await contract.connect(bob).computeAPlusB();
+    await tx.wait();
+
+    const encryptedAplusB = await contract.result();
+
+    const clearAplusB = await fhevm.userDecryptEuint(
+      FhevmType.euint8, // Specify the encrypted type
+      encryptedAplusB,
+      contractAddress, // The contract address
+      bob // The user wallet
+    );
+
+    expect(clearAplusB).to.equal(a + b);
+  });
+});

package/test/basic/fhe-operations/FHEArithmetic.ts

@@ -0,0 +1,161 @@
+import {
+  FhevmType,
+  HardhatFhevmRuntimeEnvironment,
+} from "@fhevm/hardhat-plugin";
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { expect } from "chai";
+import { ethers } from "hardhat";
+import * as hre from "hardhat";
+
+import { FHEArithmetic, FHEArithmetic__factory } from "../types";
+import type { Signers } from "./types";
+
+async function deployFixture() {
+  const factory = (await ethers.getContractFactory(
+    "FHEArithmetic"
+  )) as FHEArithmetic__factory;
+  const contract = (await factory.deploy()) as FHEArithmetic;
+  const contractAddress = await contract.getAddress();
+  return { contract, contractAddress };
+}
+
+/**
+ * @notice Demonstrates all FHE arithmetic operations on encrypted integers.
+ * Tests: add, sub, mul, div, rem, min, max
+ */
+describe("FHEArithmetic", function () {
+  let contract: FHEArithmetic;
+  let contractAddress: string;
+  let signers: Signers;
+
+  before(async function () {
+    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] };
+  });
+
+  beforeEach(async function () {
+    const deployment = await deployFixture();
+    contractAddress = deployment.contractAddress;
+    contract = deployment.contract;
+  });
+
+  describe("Arithmetic Operations", function () {
+    const valueA = 100;
+    const valueB = 25;
+
+    beforeEach(async function () {
+      const fhevm: HardhatFhevmRuntimeEnvironment = hre.fhevm;
+
+      // Set encrypted values A and B
+      const inputA = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add32(valueA)
+        .encrypt();
+      await contract
+        .connect(signers.alice)
+        .setA(inputA.handles[0], inputA.inputProof);
+
+      const inputB = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add32(valueB)
+        .encrypt();
+      await contract
+        .connect(signers.alice)
+        .setB(inputB.handles[0], inputB.inputProof);
+    });
+
+    it("should compute addition correctly (100 + 25 = 125)", async function () {
+      await contract.connect(signers.alice).computeAdd();
+      const encrypted = await contract.getResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(valueA + valueB);
+    });
+
+    it("should compute subtraction correctly (100 - 25 = 75)", async function () {
+      await contract.connect(signers.alice).computeSub();
+      const encrypted = await contract.getResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(valueA - valueB);
+    });
+
+    it("should compute multiplication correctly (100 * 25 = 2500)", async function () {
+      await contract.connect(signers.alice).computeMul();
+      const encrypted = await contract.getResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(valueA * valueB);
+    });
+
+    it("should compute division correctly (100 / 25 = 4)", async function () {
+      await contract.connect(signers.alice).computeDiv(valueB);
+      const encrypted = await contract.getResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(Math.floor(valueA / valueB));
+    });
+
+    it("should compute remainder correctly (100 % 25 = 0)", async function () {
+      await contract.connect(signers.alice).computeRem(valueB);
+      const encrypted = await contract.getResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(valueA % valueB);
+    });
+
+    it("should compute minimum correctly (min(100, 25) = 25)", async function () {
+      await contract.connect(signers.alice).computeMin();
+      const encrypted = await contract.getResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(Math.min(valueA, valueB));
+    });
+
+    it("should compute maximum correctly (max(100, 25) = 100)", async function () {
+      await contract.connect(signers.alice).computeMax();
+      const encrypted = await contract.getResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(Math.max(valueA, valueB));
+    });
+  });
+});

package/test/basic/fhe-operations/FHEComparison.ts

@@ -0,0 +1,167 @@
+import {
+  FhevmType,
+  HardhatFhevmRuntimeEnvironment,
+} from "@fhevm/hardhat-plugin";
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { expect } from "chai";
+import { ethers } from "hardhat";
+import * as hre from "hardhat";
+
+import { FHEComparison, FHEComparison__factory } from "../types";
+import type { Signers } from "./types";
+
+async function deployFixture() {
+  const factory = (await ethers.getContractFactory(
+    "FHEComparison"
+  )) as FHEComparison__factory;
+  const contract = (await factory.deploy()) as FHEComparison;
+  const contractAddress = await contract.getAddress();
+  return { contract, contractAddress };
+}
+
+/**
+ * @notice Demonstrates all FHE comparison operations on encrypted integers.
+ * Tests: eq, ne, gt, lt, ge, le, select
+ */
+describe("FHEComparison", function () {
+  let contract: FHEComparison;
+  let contractAddress: string;
+  let signers: Signers;
+
+  before(async function () {
+    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] };
+  });
+
+  beforeEach(async function () {
+    const deployment = await deployFixture();
+    contractAddress = deployment.contractAddress;
+    contract = deployment.contract;
+  });
+
+  describe("Comparison Operations with A=100, B=25", function () {
+    const valueA = 100;
+    const valueB = 25;
+
+    beforeEach(async function () {
+      const fhevm: HardhatFhevmRuntimeEnvironment = hre.fhevm;
+
+      const inputA = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add32(valueA)
+        .encrypt();
+      await contract
+        .connect(signers.alice)
+        .setA(inputA.handles[0], inputA.inputProof);
+
+      const inputB = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add32(valueB)
+        .encrypt();
+      await contract
+        .connect(signers.alice)
+        .setB(inputB.handles[0], inputB.inputProof);
+    });
+
+    it("should compute equality correctly (100 == 25 is false)", async function () {
+      await contract.connect(signers.alice).computeEq();
+      const encrypted = await contract.getBoolResult();
+
+      const decrypted = await hre.fhevm.userDecryptEbool(
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(false);
+    });
+
+    it("should compute inequality correctly (100 != 25 is true)", async function () {
+      await contract.connect(signers.alice).computeNe();
+      const encrypted = await contract.getBoolResult();
+
+      const decrypted = await hre.fhevm.userDecryptEbool(
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(true);
+    });
+
+    it("should compute greater than correctly (100 > 25 is true)", async function () {
+      await contract.connect(signers.alice).computeGt();
+      const encrypted = await contract.getBoolResult();
+
+      const decrypted = await hre.fhevm.userDecryptEbool(
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(true);
+    });
+
+    it("should compute less than correctly (100 < 25 is false)", async function () {
+      await contract.connect(signers.alice).computeLt();
+      const encrypted = await contract.getBoolResult();
+
+      const decrypted = await hre.fhevm.userDecryptEbool(
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(false);
+    });
+
+    it("should compute greater or equal correctly (100 >= 25 is true)", async function () {
+      await contract.connect(signers.alice).computeGe();
+      const encrypted = await contract.getBoolResult();
+
+      const decrypted = await hre.fhevm.userDecryptEbool(
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(true);
+    });
+
+    it("should compute less or equal correctly (100 <= 25 is false)", async function () {
+      await contract.connect(signers.alice).computeLe();
+      const encrypted = await contract.getBoolResult();
+
+      const decrypted = await hre.fhevm.userDecryptEbool(
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(false);
+    });
+
+    it("should compute max via select correctly (max(100, 25) = 100)", async function () {
+      await contract.connect(signers.alice).computeMaxViaSelect();
+      const encrypted = await contract.getSelectedResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(valueA);
+    });
+
+    it("should compute min via select correctly (min(100, 25) = 25)", async function () {
+      await contract.connect(signers.alice).computeMinViaSelect();
+      const encrypted = await contract.getSelectedResult();
+
+      const decrypted = await hre.fhevm.userDecryptEuint(
+        FhevmType.euint32,
+        encrypted,
+        contractAddress,
+        signers.alice
+      );
+      expect(decrypted).to.equal(valueB);
+    });
+  });
+});

package/test/basic/fhe-operations/FHEIfThenElse.ts

@@ -0,0 +1,97 @@
+import {
+  FhevmType,
+  HardhatFhevmRuntimeEnvironment,
+} from "@fhevm/hardhat-plugin";
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { expect } from "chai";
+import { ethers } from "hardhat";
+import * as hre from "hardhat";
+
+import { FHEIfThenElse, FHEIfThenElse__factory } from "../types";
+import type { Signers } from "./types";
+
+async function deployFixture() {
+  // Contracts are deployed using the first signer/account by default
+  const factory = (await ethers.getContractFactory(
+    "FHEIfThenElse"
+  )) as FHEIfThenElse__factory;
+  const fheIfThenElse = (await factory.deploy()) as FHEIfThenElse;
+  const fheIfThenElse_address = await fheIfThenElse.getAddress();
+
+  return { fheIfThenElse, fheIfThenElse_address };
+}
+
+/**
+ * This trivial example demonstrates the FHE encryption mechanism
+ * and highlights a common pitfall developers may encounter.
+ */
+describe("FHEIfThenElse", function () {
+  let contract: FHEIfThenElse;
+  let contractAddress: string;
+  let signers: Signers;
+  let bob: 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];
+  });
+
+  beforeEach(async function () {
+    // Deploy a new contract each time we run a new test
+    const deployment = await deployFixture();
+    contractAddress = deployment.fheIfThenElse_address;
+    contract = deployment.fheIfThenElse;
+  });
+
+  it("a >= b ? a : b should succeed", async function () {
+    const fhevm: HardhatFhevmRuntimeEnvironment = hre.fhevm;
+
+    let tx;
+
+    // Let's compute `a >= b ? a : b`
+    const a = 80;
+    const b = 123;
+
+    // Alice encrypts and sets `a` as 80
+    const inputA = await fhevm
+      .createEncryptedInput(contractAddress, signers.alice.address)
+      .add8(a)
+      .encrypt();
+    tx = await contract
+      .connect(signers.alice)
+      .setA(inputA.handles[0], inputA.inputProof);
+    await tx.wait();
+
+    // Alice encrypts and sets `b` as 203
+    const inputB = await fhevm
+      .createEncryptedInput(contractAddress, signers.alice.address)
+      .add8(b)
+      .encrypt();
+    tx = await contract
+      .connect(signers.alice)
+      .setB(inputB.handles[0], inputB.inputProof);
+    await tx.wait();
+
+    // Why Bob has FHE permissions to execute the operation in this case ?
+    // See `computeAPlusB()` in `FHEAdd.sol` for a detailed answer
+    tx = await contract.connect(bob).computeMax();
+    await tx.wait();
+
+    const encryptedMax = await contract.result();
+
+    const clearMax = await fhevm.userDecryptEuint(
+      FhevmType.euint8, // Specify the encrypted type
+      encryptedMax,
+      contractAddress, // The contract address
+      bob // The user wallet
+    );
+
+    expect(clearMax).to.equal(a >= b ? a : b);
+  });
+});