create-fhevm-example 1.3.1 → 1.4.0

package/test/advanced/BlindAuction.ts

@@ -0,0 +1,246 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+import * as hre from "hardhat";
+
+describe("BlindAuction", function () {
+  let auction: any;
+  let owner: any;
+  let bidder1: any;
+  let bidder2: any;
+  let bidder3: any;
+
+  const MINIMUM_BID = 100n;
+
+  async function deployAuction(durationSeconds: number = 60) {
+    // Get blockchain timestamp instead of Date.now()
+    const latestBlock = await ethers.provider.getBlock("latest");
+    const endTime =
+      (latestBlock?.timestamp || Math.floor(Date.now() / 1000)) +
+      durationSeconds;
+    const auctionContract = await ethers.deployContract("BlindAuction", [
+      endTime,
+      MINIMUM_BID,
+    ]);
+    return { auction: auctionContract, endTime };
+  }
+
+  beforeEach(async function () {
+    [owner, bidder1, bidder2, bidder3] = await ethers.getSigners();
+  });
+
+  describe("Auction Creation", function () {
+    it("should create auction with correct parameters", async function () {
+      const { auction: auc } = await deployAuction(120);
+
+      expect(await auc.auctionState()).to.equal(0); // Open
+      expect(await auc.minimumBid()).to.equal(MINIMUM_BID);
+      expect(await auc.getBidderCount()).to.equal(0);
+    });
+
+    it("should revert if end time is in the past", async function () {
+      const pastTime = Math.floor(Date.now() / 1000) - 100;
+      await expect(
+        ethers.deployContract("BlindAuction", [pastTime, MINIMUM_BID])
+      ).to.be.revertedWith("End time must be in future");
+    });
+  });
+
+  describe("Bidding", function () {
+    beforeEach(async function () {
+      const deployment = await deployAuction(3600); // 1 hour
+      auction = deployment.auction;
+    });
+
+    it("should accept encrypted bid", async function () {
+      const encryptedBid = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder1.address)
+        .add64(500)
+        .encrypt();
+
+      await expect(
+        auction
+          .connect(bidder1)
+          .bid(encryptedBid.handles[0], encryptedBid.inputProof)
+      ).to.not.be.reverted;
+
+      expect(await auction.hasBid(bidder1.address)).to.be.true;
+      expect(await auction.getBidderCount()).to.equal(1);
+    });
+
+    it("should reject second bid from same address", async function () {
+      const encryptedBid1 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder1.address)
+        .add64(500)
+        .encrypt();
+
+      await auction
+        .connect(bidder1)
+        .bid(encryptedBid1.handles[0], encryptedBid1.inputProof);
+
+      const encryptedBid2 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder1.address)
+        .add64(600)
+        .encrypt();
+
+      await expect(
+        auction
+          .connect(bidder1)
+          .bid(encryptedBid2.handles[0], encryptedBid2.inputProof)
+      ).to.be.revertedWith("Already placed a bid");
+    });
+
+    it("should accept bids from multiple bidders", async function () {
+      // Bidder 1
+      const enc1 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder1.address)
+        .add64(200)
+        .encrypt();
+      await auction.connect(bidder1).bid(enc1.handles[0], enc1.inputProof);
+
+      // Bidder 2
+      const enc2 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder2.address)
+        .add64(300)
+        .encrypt();
+      await auction.connect(bidder2).bid(enc2.handles[0], enc2.inputProof);
+
+      // Bidder 3
+      const enc3 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder3.address)
+        .add64(150)
+        .encrypt();
+      await auction.connect(bidder3).bid(enc3.handles[0], enc3.inputProof);
+
+      expect(await auction.getBidderCount()).to.equal(3);
+    });
+  });
+
+  describe("End Auction", function () {
+    beforeEach(async function () {
+      // Deploy with 1 hour duration to avoid timing issues from evm_increaseTime in other tests
+      const deployment = await deployAuction(3600);
+      auction = deployment.auction;
+
+      // Place bids before it ends
+      const enc1 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder1.address)
+        .add64(200)
+        .encrypt();
+      await auction.connect(bidder1).bid(enc1.handles[0], enc1.inputProof);
+
+      const enc2 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder2.address)
+        .add64(500)
+        .encrypt();
+      await auction.connect(bidder2).bid(enc2.handles[0], enc2.inputProof);
+
+      const enc3 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder3.address)
+        .add64(300)
+        .encrypt();
+      await auction.connect(bidder3).bid(enc3.handles[0], enc3.inputProof);
+    });
+
+    it("should not allow ending before time", async function () {
+      await expect(auction.connect(owner).endAuction()).to.be.revertedWith(
+        "Auction not yet ended"
+      );
+    });
+
+    it("should allow owner to end after time passes", async function () {
+      // Fast forward time past auction end
+      await hre.network.provider.send("evm_increaseTime", [3601]);
+      await hre.network.provider.send("evm_mine");
+
+      await expect(auction.connect(owner).endAuction()).to.not.be.reverted;
+      expect(await auction.auctionState()).to.equal(1); // Closed
+    });
+
+    it("should not allow non-owner to end auction", async function () {
+      await hre.network.provider.send("evm_increaseTime", [3601]);
+      await hre.network.provider.send("evm_mine");
+
+      await expect(auction.connect(bidder1).endAuction()).to.be.revertedWith(
+        "Only owner can call"
+      );
+    });
+  });
+
+  describe("Full Auction Flow", function () {
+    it("should correctly identify highest bidder", async function () {
+      // Check if running in mock mode
+      if (!hre.fhevm.isMock) {
+        console.log("Skipping: Test requires mock environment");
+        this.skip();
+      }
+
+      // Deploy with short duration - use blockchain timestamp
+      const latestBlock = await ethers.provider.getBlock("latest");
+      const endTime = (latestBlock?.timestamp || 0) + 60; // 60 seconds from now
+      auction = await ethers.deployContract("BlindAuction", [
+        endTime,
+        MINIMUM_BID,
+      ]);
+
+      // Place bids: bidder2 has highest (500)
+      const enc1 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder1.address)
+        .add64(200)
+        .encrypt();
+      await auction.connect(bidder1).bid(enc1.handles[0], enc1.inputProof);
+
+      const enc2 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder2.address)
+        .add64(500) // 🏆 Highest bid
+        .encrypt();
+      await auction.connect(bidder2).bid(enc2.handles[0], enc2.inputProof);
+
+      const enc3 = await fhevm
+        .createEncryptedInput(await auction.getAddress(), bidder3.address)
+        .add64(300)
+        .encrypt();
+      await auction.connect(bidder3).bid(enc3.handles[0], enc3.inputProof);
+
+      // Fast forward time using evm commands
+      await hre.network.provider.send("evm_increaseTime", [65]); // 65 seconds
+      await hre.network.provider.send("evm_mine");
+
+      const endTx = await auction.connect(owner).endAuction();
+      const endReceipt = await endTx.wait();
+
+      // Parse AuctionEnded event to get encrypted handles
+      const auctionEndedEvent = endReceipt.logs.find((log: any) => {
+        try {
+          const parsed = auction.interface.parseLog(log);
+          return parsed?.name === "AuctionEnded";
+        } catch {
+          return false;
+        }
+      });
+
+      expect(auctionEndedEvent).to.not.be.undefined;
+
+      // Get encrypted handles from contract
+      const encWinningBid = await auction.getEncryptedWinningBid();
+      const encWinnerIndex = await auction.getEncryptedWinnerIndex();
+
+      // Request public decryption
+      const handles = [encWinningBid, encWinnerIndex];
+      const decryptResults = await fhevm.publicDecrypt(handles);
+
+      // Reveal winner
+      await auction.revealWinner(
+        decryptResults.abiEncodedClearValues,
+        decryptResults.decryptionProof
+      );
+
+      // Verify results
+      expect(await auction.auctionState()).to.equal(2); // Revealed
+      expect(await auction.winner()).to.equal(bidder2.address);
+      expect(await auction.winningAmount()).to.equal(500n);
+
+      console.log(`🏆 Winner: ${await auction.winner()}`);
+      console.log(`💰 Winning Amount: ${await auction.winningAmount()}`);
+    });
+  });
+});

package/test/advanced/EncryptedEscrow.ts

@@ -0,0 +1,295 @@
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { ethers, fhevm } from "hardhat";
+import { EncryptedEscrow, EncryptedEscrow__factory } from "../types";
+import { expect } from "chai";
+
+type Signers = {
+  buyer: HardhatEthersSigner;
+  seller: HardhatEthersSigner;
+  arbiter: HardhatEthersSigner;
+};
+
+const ARBITER_FEE = 1; // 1%
+const DEADLINE_OFFSET = 86400; // 1 day
+
+async function deployFixture() {
+  const factory = (await ethers.getContractFactory(
+    "EncryptedEscrow"
+  )) as EncryptedEscrow__factory;
+  const escrow = (await factory.deploy(ARBITER_FEE)) as EncryptedEscrow;
+  const escrowAddress = await escrow.getAddress();
+
+  return { escrow, escrowAddress };
+}
+
+/**
+ * Encrypted Escrow Tests
+ *
+ * Tests secure escrow with encrypted amounts and dispute resolution.
+ */
+describe("EncryptedEscrow", function () {
+  let signers: Signers;
+  let escrow: EncryptedEscrow;
+  let escrowAddress: string;
+
+  before(async function () {
+    const ethSigners: HardhatEthersSigner[] = await ethers.getSigners();
+    signers = {
+      buyer: ethSigners[0],
+      seller: ethSigners[1],
+      arbiter: ethSigners[2],
+    };
+  });
+
+  beforeEach(async function () {
+    if (!fhevm.isMock) {
+      console.warn("This test suite cannot run on Sepolia Testnet");
+      this.skip();
+    }
+
+    ({ escrow, escrowAddress } = await deployFixture());
+  });
+
+  describe("Initialization", function () {
+    it("should initialize with correct parameters", async function () {
+      expect(await escrow.owner()).to.equal(signers.buyer.address);
+      expect(await escrow.arbiterFeePercent()).to.equal(BigInt(ARBITER_FEE));
+      expect(await escrow.escrowCount()).to.equal(0n);
+    });
+
+    it("should reject fee percentage above 10%", async function () {
+      const factory = await ethers.getContractFactory("EncryptedEscrow");
+      await expect(factory.deploy(15)).to.be.revertedWith("Fee too high");
+    });
+  });
+
+  describe("Escrow Creation", function () {
+    it("should create escrow with encrypted amount", async function () {
+      const amount = ethers.parseEther("1");
+      const block = await ethers.provider.getBlock("latest");
+      const deadline = (block?.timestamp || 0) + DEADLINE_OFFSET;
+
+      const encryptedAmount = await fhevm
+        .createEncryptedInput(escrowAddress, signers.buyer.address)
+        .add64(amount)
+        .encrypt();
+
+      await expect(
+        escrow.createEscrow(
+          signers.seller.address,
+          signers.arbiter.address,
+          encryptedAmount.handles[0],
+          encryptedAmount.inputProof,
+          deadline
+        )
+      ).to.emit(escrow, "EscrowCreated");
+
+      expect(await escrow.escrowCount()).to.equal(1n);
+    });
+
+    it("should reject invalid seller address", async function () {
+      const block = await ethers.provider.getBlock("latest");
+      const deadline = (block?.timestamp || 0) + DEADLINE_OFFSET;
+
+      const enc = await fhevm
+        .createEncryptedInput(escrowAddress, signers.buyer.address)
+        .add64(1000n)
+        .encrypt();
+
+      await expect(
+        escrow.createEscrow(
+          ethers.ZeroAddress,
+          signers.arbiter.address,
+          enc.handles[0],
+          enc.inputProof,
+          deadline
+        )
+      ).to.be.revertedWith("Invalid seller");
+    });
+
+    it("should reject buyer as seller", async function () {
+      const block = await ethers.provider.getBlock("latest");
+      const deadline = (block?.timestamp || 0) + DEADLINE_OFFSET;
+
+      const enc = await fhevm
+        .createEncryptedInput(escrowAddress, signers.buyer.address)
+        .add64(1000n)
+        .encrypt();
+
+      await expect(
+        escrow.createEscrow(
+          signers.buyer.address,
+          signers.arbiter.address,
+          enc.handles[0],
+          enc.inputProof,
+          deadline
+        )
+      ).to.be.revertedWith("Buyer cannot be seller");
+    });
+  });
+
+  describe("Funding", function () {
+    let escrowId: bigint;
+
+    beforeEach(async function () {
+      const block = await ethers.provider.getBlock("latest");
+      const deadline = (block?.timestamp || 0) + DEADLINE_OFFSET;
+
+      const enc = await fhevm
+        .createEncryptedInput(escrowAddress, signers.buyer.address)
+        .add64(ethers.parseEther("1"))
+        .encrypt();
+
+      await escrow.createEscrow(
+        signers.seller.address,
+        signers.arbiter.address,
+        enc.handles[0],
+        enc.inputProof,
+        deadline
+      );
+      escrowId = 1n;
+    });
+
+    it("should allow buyer to fund escrow", async function () {
+      const amount = ethers.parseEther("1");
+
+      await expect(escrow.fundEscrow(escrowId, { value: amount }))
+        .to.emit(escrow, "EscrowFunded")
+        .withArgs(escrowId, amount);
+
+      const info = await escrow.getEscrow(escrowId);
+      expect(info.depositedAmount).to.equal(amount);
+      expect(info.state).to.equal(1); // Funded
+    });
+
+    it("should prevent non-buyer from funding", async function () {
+      await expect(
+        escrow
+          .connect(signers.seller)
+          .fundEscrow(escrowId, { value: ethers.parseEther("1") })
+      ).to.be.revertedWith("Only buyer can fund");
+    });
+  });
+
+  describe("Release and Refund", function () {
+    let escrowId: bigint;
+    const DEPOSIT = ethers.parseEther("1");
+
+    beforeEach(async function () {
+      const block = await ethers.provider.getBlock("latest");
+      const deadline = (block?.timestamp || 0) + DEADLINE_OFFSET;
+
+      const enc = await fhevm
+        .createEncryptedInput(escrowAddress, signers.buyer.address)
+        .add64(DEPOSIT)
+        .encrypt();
+
+      await escrow.createEscrow(
+        signers.seller.address,
+        signers.arbiter.address,
+        enc.handles[0],
+        enc.inputProof,
+        deadline
+      );
+      escrowId = 1n;
+      await escrow.fundEscrow(escrowId, { value: DEPOSIT });
+    });
+
+    it("should allow buyer to release funds", async function () {
+      const sellerBalanceBefore = await ethers.provider.getBalance(
+        signers.seller.address
+      );
+
+      await expect(escrow.release(escrowId))
+        .to.emit(escrow, "FundsReleased")
+        .withArgs(escrowId, signers.seller.address);
+
+      const sellerBalanceAfter = await ethers.provider.getBalance(
+        signers.seller.address
+      );
+      expect(sellerBalanceAfter - sellerBalanceBefore).to.equal(DEPOSIT);
+    });
+
+    it("should prevent non-buyer from releasing", async function () {
+      await expect(
+        escrow.connect(signers.seller).release(escrowId)
+      ).to.be.revertedWith("Only buyer can release");
+    });
+
+    it("should prevent refund before deadline", async function () {
+      await expect(escrow.requestRefund(escrowId)).to.be.revertedWith(
+        "Deadline not passed"
+      );
+    });
+  });
+
+  describe("Dispute Resolution", function () {
+    let escrowId: bigint;
+    const DEPOSIT = ethers.parseEther("1");
+
+    beforeEach(async function () {
+      const block = await ethers.provider.getBlock("latest");
+      const deadline = (block?.timestamp || 0) + DEADLINE_OFFSET;
+
+      const enc = await fhevm
+        .createEncryptedInput(escrowAddress, signers.buyer.address)
+        .add64(DEPOSIT)
+        .encrypt();
+
+      await escrow.createEscrow(
+        signers.seller.address,
+        signers.arbiter.address,
+        enc.handles[0],
+        enc.inputProof,
+        deadline
+      );
+      escrowId = 1n;
+      await escrow.fundEscrow(escrowId, { value: DEPOSIT });
+    });
+
+    it("should allow buyer to raise dispute", async function () {
+      await expect(escrow.raiseDispute(escrowId))
+        .to.emit(escrow, "DisputeRaised")
+        .withArgs(escrowId, signers.buyer.address);
+
+      const info = await escrow.getEscrow(escrowId);
+      expect(info.state).to.equal(4); // Disputed
+    });
+
+    it("should allow arbiter to resolve in favor of buyer", async function () {
+      await escrow.raiseDispute(escrowId);
+
+      const buyerBalanceBefore = await ethers.provider.getBalance(
+        signers.buyer.address
+      );
+
+      await expect(
+        escrow.connect(signers.arbiter).resolveDispute(escrowId, true)
+      )
+        .to.emit(escrow, "DisputeResolved")
+        .withArgs(escrowId, signers.buyer.address);
+
+      const buyerBalanceAfter = await ethers.provider.getBalance(
+        signers.buyer.address
+      );
+      // Buyer receives 99% (1% arbiter fee)
+      const expected = DEPOSIT - DEPOSIT / 100n;
+      expect(buyerBalanceAfter - buyerBalanceBefore).to.equal(expected);
+    });
+
+    it("should prevent non-arbiter from resolving", async function () {
+      await escrow.raiseDispute(escrowId);
+
+      await expect(escrow.resolveDispute(escrowId, true)).to.be.revertedWith(
+        "Only arbiter"
+      );
+    });
+  });
+
+  describe("View Functions", function () {
+    it("should check deadline status", async function () {
+      // Non-existent escrow with deadline = 0 means timestamp > 0 is always true
+      expect(await escrow.isDeadlinePassed(999)).to.be.true;
+    });
+  });
+});