create-fhevm-example 1.3.1 → 1.4.0

package/test/gaming/RockPaperScissors.ts

@@ -0,0 +1,205 @@
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { ethers, fhevm } from "hardhat";
+import { RockPaperScissors, RockPaperScissors__factory } from "../types";
+import { expect } from "chai";
+
+type Signers = {
+  deployer: HardhatEthersSigner;
+  player1: HardhatEthersSigner;
+  player2: HardhatEthersSigner;
+  player3: HardhatEthersSigner;
+};
+
+async function deployFixture() {
+  const factory = (await ethers.getContractFactory(
+    "RockPaperScissors"
+  )) as RockPaperScissors__factory;
+  const rps = (await factory.deploy()) as RockPaperScissors;
+  const rpsAddress = await rps.getAddress();
+
+  return { rps, rpsAddress };
+}
+
+/**
+ * Rock-Paper-Scissors Tests
+ *
+ * Tests encrypted move submission and FHE-based winner determination.
+ * Demonstrates commit-reveal pattern without trusted third party.
+ */
+describe("RockPaperScissors", function () {
+  let signers: Signers;
+  let rps: RockPaperScissors;
+  let rpsAddress: string;
+
+  before(async function () {
+    const ethSigners: HardhatEthersSigner[] = await ethers.getSigners();
+    signers = {
+      deployer: ethSigners[0],
+      player1: ethSigners[1],
+      player2: ethSigners[2],
+      player3: ethSigners[3],
+    };
+  });
+
+  beforeEach(async function () {
+    if (!fhevm.isMock) {
+      console.warn("This test suite cannot run on Sepolia Testnet");
+      this.skip();
+    }
+
+    ({ rps, rpsAddress } = await deployFixture());
+  });
+
+  describe("Game Setup", function () {
+    it("should initialize with correct state", async function () {
+      const state = await rps.getGameState();
+      expect(state.p1).to.equal(ethers.ZeroAddress);
+      expect(state.p2).to.equal(ethers.ZeroAddress);
+      expect(state.currentState).to.equal(0); // WaitingForPlayers
+      expect(state.currentWinner).to.equal(ethers.ZeroAddress);
+      expect(state.currentGameId).to.equal(1n);
+    });
+
+    it("should allow first player to join", async function () {
+      // Create encrypted move (Rock = 0)
+      const encryptedMove = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player1.address)
+        .add8(0)
+        .encrypt();
+
+      await rps
+        .connect(signers.player1)
+        .play(encryptedMove.handles[0], encryptedMove.inputProof);
+
+      expect(await rps.player1()).to.equal(signers.player1.address);
+      expect(await rps.state()).to.equal(0); // Still waiting for player 2
+    });
+
+    it("should transition to BothMoved when second player joins", async function () {
+      // Player 1 plays Rock
+      const enc1 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player1.address)
+        .add8(0)
+        .encrypt();
+      await rps.connect(signers.player1).play(enc1.handles[0], enc1.inputProof);
+
+      // Player 2 plays Paper
+      const enc2 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player2.address)
+        .add8(1)
+        .encrypt();
+      await rps.connect(signers.player2).play(enc2.handles[0], enc2.inputProof);
+
+      expect(await rps.player2()).to.equal(signers.player2.address);
+      expect(await rps.state()).to.equal(1); // BothMoved
+    });
+  });
+
+  describe("Move Validation", function () {
+    it("should prevent same player from playing twice", async function () {
+      const enc1 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player1.address)
+        .add8(0)
+        .encrypt();
+      await rps.connect(signers.player1).play(enc1.handles[0], enc1.inputProof);
+
+      const enc2 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player1.address)
+        .add8(1)
+        .encrypt();
+
+      await expect(
+        rps.connect(signers.player1).play(enc2.handles[0], enc2.inputProof)
+      ).to.be.revertedWith("Already in this game");
+    });
+
+    it("should prevent third player from joining after game is full", async function () {
+      // Player 1 plays
+      const enc1 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player1.address)
+        .add8(0)
+        .encrypt();
+      await rps.connect(signers.player1).play(enc1.handles[0], enc1.inputProof);
+
+      // Player 2 plays
+      const enc2 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player2.address)
+        .add8(1)
+        .encrypt();
+      await rps.connect(signers.player2).play(enc2.handles[0], enc2.inputProof);
+
+      // Player 3 tries to play
+      const enc3 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player3.address)
+        .add8(2)
+        .encrypt();
+
+      await expect(
+        rps.connect(signers.player3).play(enc3.handles[0], enc3.inputProof)
+      ).to.be.revertedWith("Game not accepting moves");
+    });
+  });
+
+  describe("Winner Determination", function () {
+    it("should compute winner via FHE after both players move", async function () {
+      // Player 1: Rock (0)
+      const enc1 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player1.address)
+        .add8(0)
+        .encrypt();
+      await rps.connect(signers.player1).play(enc1.handles[0], enc1.inputProof);
+
+      // Player 2: Paper (1) - Paper beats Rock
+      const enc2 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player2.address)
+        .add8(1)
+        .encrypt();
+      await rps.connect(signers.player2).play(enc2.handles[0], enc2.inputProof);
+
+      // Determine winner
+      await expect(rps.determineWinner()).to.emit(rps, "GameResult");
+
+      expect(await rps.state()).to.equal(2); // Revealed
+    });
+
+    it("should prevent determineWinner before both players move", async function () {
+      await expect(rps.determineWinner()).to.be.revertedWith(
+        "Not ready to determine winner"
+      );
+    });
+  });
+
+  describe("Game Reset", function () {
+    it("should allow reset after game is revealed", async function () {
+      // Play a full game
+      const enc1 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player1.address)
+        .add8(0)
+        .encrypt();
+      await rps.connect(signers.player1).play(enc1.handles[0], enc1.inputProof);
+
+      const enc2 = await fhevm
+        .createEncryptedInput(rpsAddress, signers.player2.address)
+        .add8(1)
+        .encrypt();
+      await rps.connect(signers.player2).play(enc2.handles[0], enc2.inputProof);
+
+      await rps.determineWinner();
+
+      // Reset game
+      await rps.resetGame();
+
+      const state = await rps.getGameState();
+      expect(state.p1).to.equal(ethers.ZeroAddress);
+      expect(state.p2).to.equal(ethers.ZeroAddress);
+      expect(state.currentState).to.equal(0); // WaitingForPlayers
+      expect(state.currentGameId).to.equal(2n); // Incremented
+    });
+
+    it("should prevent reset before game is finished", async function () {
+      await expect(rps.resetGame()).to.be.revertedWith(
+        "Current game not finished"
+      );
+    });
+  });
+});

package/test/openzeppelin/ERC7984.ts

@@ -0,0 +1,142 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+
+describe("ERC7984Example", function () {
+  let token: any;
+  let owner: any;
+  let recipient: any;
+  let other: any;
+
+  const INITIAL_AMOUNT = 1000;
+  const TRANSFER_AMOUNT = 100;
+
+  beforeEach(async function () {
+    [owner, recipient, other] = await ethers.getSigners();
+
+    // Deploy ERC7984 contract
+    token = await ethers.deployContract("ERC7984Example", [
+      owner.address,
+      INITIAL_AMOUNT,
+      "Confidential Token",
+      "CTKN",
+      "https://example.com/token",
+    ]);
+  });
+
+  describe("Initialization", function () {
+    it("should set the correct name", async function () {
+      expect(await token.name()).to.equal("Confidential Token");
+    });
+
+    it("should set the correct symbol", async function () {
+      expect(await token.symbol()).to.equal("CTKN");
+    });
+
+    it("should set the correct contract URI", async function () {
+      expect(await token.contractURI()).to.equal("https://example.com/token");
+    });
+
+    it("should mint initial amount to owner", async function () {
+      const balanceHandle = await token.confidentialBalanceOf(owner.address);
+      expect(balanceHandle).to.not.be.undefined;
+    });
+  });
+
+  describe("Transfer Process", function () {
+    it("should transfer tokens from owner to recipient", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(await token.getAddress(), owner.address)
+        .add64(TRANSFER_AMOUNT)
+        .encrypt();
+
+      await expect(
+        token
+          .connect(owner)
+          ["confidentialTransfer(address,bytes32,bytes)"](
+            recipient.address,
+            encryptedInput.handles[0],
+            encryptedInput.inputProof
+          )
+      ).to.not.be.reverted;
+
+      const recipientBalanceHandle = await token.confidentialBalanceOf(
+        recipient.address
+      );
+      const ownerBalanceHandle = await token.confidentialBalanceOf(
+        owner.address
+      );
+      expect(recipientBalanceHandle).to.not.be.undefined;
+      expect(ownerBalanceHandle).to.not.be.undefined;
+    });
+
+    it("should allow recipient to transfer received tokens", async function () {
+      // First transfer from owner to recipient
+      const encryptedInput1 = await fhevm
+        .createEncryptedInput(await token.getAddress(), owner.address)
+        .add64(TRANSFER_AMOUNT)
+        .encrypt();
+
+      await token
+        .connect(owner)
+        ["confidentialTransfer(address,bytes32,bytes)"](
+          recipient.address,
+          encryptedInput1.handles[0],
+          encryptedInput1.inputProof
+        );
+
+      // Second transfer from recipient to other
+      const encryptedInput2 = await fhevm
+        .createEncryptedInput(await token.getAddress(), recipient.address)
+        .add64(50)
+        .encrypt();
+
+      await expect(
+        token
+          .connect(recipient)
+          ["confidentialTransfer(address,bytes32,bytes)"](
+            other.address,
+            encryptedInput2.handles[0],
+            encryptedInput2.inputProof
+          )
+      ).to.not.be.reverted;
+    });
+
+    it("should revert when sender has zero balance", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(await token.getAddress(), recipient.address)
+        .add64(100)
+        .encrypt();
+
+      await expect(
+        token
+          .connect(recipient)
+          ["confidentialTransfer(address,bytes32,bytes)"](
+            other.address,
+            encryptedInput.handles[0],
+            encryptedInput.inputProof
+          )
+      )
+        .to.be.revertedWithCustomError(token, "ERC7984ZeroBalance")
+        .withArgs(recipient.address);
+    });
+
+    it("should revert when transferring to zero address", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(await token.getAddress(), owner.address)
+        .add64(TRANSFER_AMOUNT)
+        .encrypt();
+
+      await expect(
+        token
+          .connect(owner)
+          ["confidentialTransfer(address,bytes32,bytes)"](
+            ethers.ZeroAddress,
+            encryptedInput.handles[0],
+            encryptedInput.inputProof
+          )
+      )
+        .to.be.revertedWithCustomError(token, "ERC7984InvalidReceiver")
+        .withArgs(ethers.ZeroAddress);
+    });
+  });
+});

package/test/openzeppelin/ERC7984ERC20Wrapper.ts

@@ -0,0 +1,71 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+
+describe("ERC7984ERC20Wrapper", function () {
+  let wrapper: any;
+  let erc20Mock: any;
+  let owner: any;
+  let user: any;
+
+  const WRAP_AMOUNT = 1000;
+
+  beforeEach(async function () {
+    [owner, user] = await ethers.getSigners();
+
+    // Deploy mock ERC20
+    erc20Mock = await ethers.deployContract("ERC20Mock", [
+      "Mock USDC",
+      "USDC",
+      6,
+    ]);
+
+    // Mint ERC20 to user
+    await erc20Mock.mint(user.address, WRAP_AMOUNT * 2);
+
+    // Deploy wrapper
+    wrapper = await ethers.deployContract("ERC7984ERC20WrapperExample", [
+      await erc20Mock.getAddress(),
+      "Wrapped USDC",
+      "wUSDC",
+      "https://example.com/wrapped",
+    ]);
+  });
+
+  describe("Initialization", function () {
+    it("should set the correct underlying token", async function () {
+      expect(await wrapper.underlying()).to.equal(await erc20Mock.getAddress());
+    });
+
+    it("should set the correct name and symbol", async function () {
+      expect(await wrapper.name()).to.equal("Wrapped USDC");
+      expect(await wrapper.symbol()).to.equal("wUSDC");
+    });
+  });
+
+  describe("Wrapping", function () {
+    it("should wrap ERC20 tokens", async function () {
+      // Approve wrapper
+      await erc20Mock
+        .connect(user)
+        .approve(await wrapper.getAddress(), WRAP_AMOUNT);
+
+      // Wrap tokens
+      await expect(wrapper.connect(user).wrap(user.address, WRAP_AMOUNT)).to.not
+        .be.reverted;
+
+      // Check ERC20 was transferred
+      expect(await erc20Mock.balanceOf(await wrapper.getAddress())).to.equal(
+        WRAP_AMOUNT
+      );
+
+      // Check confidential balance exists
+      const balanceHandle = await wrapper.confidentialBalanceOf(user.address);
+      expect(balanceHandle).to.not.be.undefined;
+    });
+
+    it("should fail wrapping without approval", async function () {
+      await expect(wrapper.connect(user).wrap(user.address, WRAP_AMOUNT)).to.be
+        .reverted;
+    });
+  });
+});

package/test/openzeppelin/SwapERC7984ToERC20.ts

@@ -0,0 +1,76 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+
+describe("SwapERC7984ToERC20", function () {
+  let swap: any;
+  let erc7984: any;
+  let erc20Mock: any;
+  let owner: any;
+  let user: any;
+
+  const INITIAL_ERC20 = 10000;
+
+  beforeEach(async function () {
+    [owner, user] = await ethers.getSigners();
+
+    // Deploy ERC7984 mock
+    erc7984 = await ethers.deployContract("ERC7984Example", [
+      owner.address,
+      10000,
+      "Confidential Token",
+      "CTKN",
+      "https://example.com/token",
+    ]);
+
+    // Deploy ERC20 mock
+    erc20Mock = await ethers.deployContract("ERC20Mock", [
+      "Mock USDC",
+      "USDC",
+      6,
+    ]);
+
+    // Deploy swap contract
+    swap = await ethers.deployContract("SwapERC7984ToERC20Example", [
+      await erc7984.getAddress(),
+      await erc20Mock.getAddress(),
+    ]);
+
+    // Fund swap contract with ERC20
+    await erc20Mock.mint(await swap.getAddress(), INITIAL_ERC20);
+
+    // Transfer some ERC7984 to user
+    const encryptedInput = await fhevm
+      .createEncryptedInput(await erc7984.getAddress(), owner.address)
+      .add64(1000)
+      .encrypt();
+
+    await erc7984
+      .connect(owner)
+      ["confidentialTransfer(address,bytes32,bytes)"](
+        user.address,
+        encryptedInput.handles[0],
+        encryptedInput.inputProof
+      );
+
+    // Set swap contract as operator for user
+    const maxTimestamp = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
+    await erc7984
+      .connect(user)
+      .setOperator(await swap.getAddress(), maxTimestamp);
+  });
+
+  describe("Swap Initiation", function () {
+    it("should initiate a swap", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(await swap.getAddress(), user.address)
+        .add64(100)
+        .encrypt();
+
+      await expect(
+        swap
+          .connect(user)
+          .initiateSwap(encryptedInput.handles[0], encryptedInput.inputProof)
+      ).to.emit(swap, "SwapInitiated");
+    });
+  });
+});

package/test/openzeppelin/SwapERC7984ToERC7984.ts

@@ -0,0 +1,113 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+
+describe("SwapERC7984ToERC7984", function () {
+  let swap: any;
+  let tokenA: any;
+  let tokenB: any;
+  let owner: any;
+  let user: any;
+
+  beforeEach(async function () {
+    [owner, user] = await ethers.getSigners();
+
+    // Deploy two ERC7984 tokens
+    tokenA = await ethers.deployContract("ERC7984Example", [
+      owner.address,
+      10000,
+      "Token A",
+      "TKA",
+      "https://example.com/a",
+    ]);
+
+    tokenB = await ethers.deployContract("ERC7984Example", [
+      owner.address,
+      10000,
+      "Token B",
+      "TKB",
+      "https://example.com/b",
+    ]);
+
+    // Deploy swap contract
+    swap = await ethers.deployContract("SwapERC7984ToERC7984Example", []);
+
+    // Transfer tokenA to user
+    const encryptedInputA = await fhevm
+      .createEncryptedInput(await tokenA.getAddress(), owner.address)
+      .add64(1000)
+      .encrypt();
+
+    await tokenA
+      .connect(owner)
+      ["confidentialTransfer(address,bytes32,bytes)"](
+        user.address,
+        encryptedInputA.handles[0],
+        encryptedInputA.inputProof
+      );
+
+    // Transfer tokenB to swap contract
+    const encryptedInputB = await fhevm
+      .createEncryptedInput(await tokenB.getAddress(), owner.address)
+      .add64(1000)
+      .encrypt();
+
+    await tokenB
+      .connect(owner)
+      ["confidentialTransfer(address,bytes32,bytes)"](
+        await swap.getAddress(),
+        encryptedInputB.handles[0],
+        encryptedInputB.inputProof
+      );
+
+    // Set swap as operator for user's tokenA
+    const maxTimestamp = Math.floor(Date.now() / 1000) + 3600;
+    await tokenA
+      .connect(user)
+      .setOperator(await swap.getAddress(), maxTimestamp);
+  });
+
+  describe("Swap", function () {
+    it("should swap tokenA for tokenB", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(await swap.getAddress(), user.address)
+        .add64(100)
+        .encrypt();
+
+      await expect(
+        swap
+          .connect(user)
+          .swapConfidentialForConfidential(
+            await tokenA.getAddress(),
+            await tokenB.getAddress(),
+            encryptedInput.handles[0],
+            encryptedInput.inputProof
+          )
+      ).to.not.be.reverted;
+
+      // User should have tokenB balance
+      const balanceB = await tokenB.confidentialBalanceOf(user.address);
+      expect(balanceB).to.not.be.undefined;
+    });
+
+    it("should fail without operator authorization", async function () {
+      // Remove operator
+      await tokenA.connect(user).setOperator(await swap.getAddress(), 0);
+
+      const encryptedInput = await fhevm
+        .createEncryptedInput(await tokenA.getAddress(), user.address)
+        .add64(100)
+        .encrypt();
+
+      await expect(
+        swap
+          .connect(user)
+          .swapConfidentialForConfidential(
+            await tokenA.getAddress(),
+            await tokenB.getAddress(),
+            encryptedInput.handles[0],
+            encryptedInput.inputProof
+          )
+      ).to.be.reverted;
+    });
+  });
+});

package/test/openzeppelin/VestingWallet.ts

@@ -0,0 +1,89 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+import { time } from "@nomicfoundation/hardhat-network-helpers";
+
+describe("VestingWallet", function () {
+  let vestingWallet: any;
+  let token: any;
+  let owner: any;
+  let beneficiary: any;
+
+  const VESTING_AMOUNT = 1000;
+  const VESTING_DURATION = 60 * 60; // 1 hour in seconds
+
+  beforeEach(async function () {
+    [owner, beneficiary] = await ethers.getSigners();
+
+    // Deploy ERC7984 token
+    token = await ethers.deployContract("ERC7984Example", [
+      owner.address,
+      10000,
+      "Vesting Token",
+      "VTK",
+      "https://example.com/vesting",
+    ]);
+
+    // Get current time and set vesting to start in 1 minute
+    const currentTime = await time.latest();
+    const startTime = currentTime + 60;
+
+    // Deploy vesting wallet
+    vestingWallet = await ethers.deployContract("VestingWalletExample", [
+      beneficiary.address,
+      startTime,
+      VESTING_DURATION,
+    ]);
+
+    // Transfer tokens to vesting wallet
+    const encryptedInput = await fhevm
+      .createEncryptedInput(await token.getAddress(), owner.address)
+      .add64(VESTING_AMOUNT)
+      .encrypt();
+
+    await token
+      .connect(owner)
+      ["confidentialTransfer(address,bytes32,bytes)"](
+        await vestingWallet.getAddress(),
+        encryptedInput.handles[0],
+        encryptedInput.inputProof
+      );
+  });
+
+  describe("Initialization", function () {
+    it("should set the correct beneficiary", async function () {
+      expect(await vestingWallet.owner()).to.equal(beneficiary.address);
+    });
+
+    it("should set the correct duration", async function () {
+      expect(await vestingWallet.duration()).to.equal(VESTING_DURATION);
+    });
+  });
+
+  describe("Vesting Schedule", function () {
+    it("should not release tokens before vesting starts", async function () {
+      await expect(
+        vestingWallet.connect(beneficiary).release(await token.getAddress())
+      ).to.not.be.reverted;
+    });
+
+    it("should release after vesting ends", async function () {
+      const endTime = await vestingWallet.end();
+      await time.increaseTo(endTime + BigInt(100));
+
+      await expect(
+        vestingWallet.connect(beneficiary).release(await token.getAddress())
+      ).to.emit(vestingWallet, "VestingWalletConfidentialTokenReleased");
+    });
+
+    it("should release partial tokens at midpoint", async function () {
+      const startTime = await vestingWallet.start();
+      const midpoint = Number(startTime) + VESTING_DURATION / 2;
+
+      await time.increaseTo(midpoint);
+
+      await expect(
+        vestingWallet.connect(beneficiary).release(await token.getAddress())
+      ).to.not.be.reverted;
+    });
+  });
+});

package/dist/scripts/add-mode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add-mode.d.ts","sourceRoot":"","sources":["../../scripts/add-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAkRH;;GAEG;AACH,wBAAsB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8ElE"}

package/dist/scripts/builders.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../scripts/builders.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA0DH;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CA8Cf;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAiEf;AAMD;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAuEf"}