@0xflydev/labz 1.0.22 → 1.0.24

package/dist/index.js

@@ -1538,7 +1538,7 @@ Base: ${import_chalk7.default.cyan(base.name)} - ${base.description}`));
   const spinner = (0, import_ora5.default)("Generating project...").start();
   try {
     const result = (0, import_composer.merge)(base, modules, {
-      projectName: finalProjectName,
+      projectName: path4.basename(finalProjectName),
       typeParams: options.type ? { COUNTER_TYPE: options.type, EXTERNAL_TYPE: `external${options.type.charAt(0).toUpperCase()}${options.type.slice(1)}` } : void 0
     });
     if (!result.success) {
@@ -1651,8 +1651,11 @@ function copyDirSync(src, dest) {
     }
   }
 }
+function toPascalCase(name) {
+  return name.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
 function generateBuildReadme(projectName, base, result) {
-  const contractName = result.stats.baseTemplate.charAt(0).toUpperCase() + result.stats.baseTemplate.slice(1);
+  const contractName = toPascalCase(result.stats.baseTemplate);
   const modules = result.stats.modulesApplied || [];
   const lines = [];
   lines.push(`# ${projectName}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xflydev/labz",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "Lab-Z CLI - Generate composable FHEVM smart contracts",
   "author": "0xflydev",
   "license": "MIT",

package/templates/buildable/projects/auction/deploy/deploy.ts.tmpl

@@ -1,38 +1,39 @@
-import { ethers } from "hardhat";
+import hre from "hardhat";
 
 async function main() {
-  const itemDescription = "Rare Digital Collectible";
-  const durationSeconds = 86400; // 1 day
-
   console.log("Deploying {{CONTRACT_NAME}}...");
-  console.log("  Item:", itemDescription);
-  console.log("  Duration:", durationSeconds / 3600, "hours");
-
-  const AuctionFactory = await ethers.getContractFactory("{{CONTRACT_NAME}}");
-  const auction = await AuctionFactory.deploy(itemDescription, durationSeconds);
-
-  await auction.waitForDeployment();
-
-  const address = await auction.getAddress();
-  console.log("\n{{CONTRACT_NAME}} deployed to:", address);
-
-  console.log("\nAuction Lifecycle:");
-  console.log("  1. Bid: bid(encryptedAmount, inputProof)");
-  console.log("     - Bids are encrypted and sealed");
-  console.log("     - No one can see competitors' bids");
-  console.log("  2. Wait: Auction runs until endTime");
-  console.log("  3. Request Reveal: requestWinnerReveal()");
-  console.log("     - Marks winner for decryption");
-  console.log("  4. Finalize: finalizeWinner(winnerAddress, winningBid, proof)");
-  console.log("     - Verifies decryption proof");
-  console.log("     - Announces winner");
-  console.log("\nPrivacy Guarantees:");
-  console.log("  - Bids encrypted until reveal");
-  console.log("  - Losing bids never disclosed");
-  console.log("  - Fair competition guaranteed");
+
+  const Factory = await hre.ethers.getContractFactory("{{CONTRACT_NAME}}");
+  const contract = await Factory.deploy();
+
+  await contract.waitForDeployment();
+
+  const address = await contract.getAddress();
+  console.log(`{{CONTRACT_NAME}} deployed to: ${address}`);
+
+  // Verify on explorer if not local
+  if (hre.network.name !== "hardhat" && hre.network.name !== "localhost") {
+    console.log("Waiting for block confirmations...");
+    await contract.deploymentTransaction()?.wait(5);
+
+    console.log("Verifying contract...");
+    try {
+      await hre.run("verify:verify", {
+        address: address,
+        constructorArguments: [],
+      });
+      console.log("Contract verified!");
+    } catch (error) {
+      console.log("Verification failed:", error);
+    }
+  }
+
+  return address;
 }
 
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

package/templates/buildable/projects/counter/test/Counter.test.ts.tmpl

@@ -1,71 +1,65 @@
 import { expect } from "chai";
-import hre from "hardhat";
-import { createInstance, type FhevmInstance } from "@fhevm/sdk";
+import { ethers, fhevm } from "hardhat";
+import { FhevmType } from "@fhevm/hardhat-plugin";
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
 
 describe("{{CONTRACT_NAME}}", function () {
   let contract: any;
   let contractAddress: string;
-  let fhevm: FhevmInstance;
-  let signers: any[];
+  let signers: HardhatEthersSigner[];
 
   before(async function () {
-    // Get signers
-    signers = await hre.ethers.getSigners();
+    signers = await ethers.getSigners();
+  });
 
-    // Deploy contract
-    const Factory = await hre.ethers.getContractFactory("{{CONTRACT_NAME}}");
+  beforeEach(async function () {
+    const Factory = await ethers.getContractFactory("{{CONTRACT_NAME}}");
     contract = await Factory.deploy();
     await contract.waitForDeployment();
     contractAddress = await contract.getAddress();
-
-    // Create FHEVM instance
-    fhevm = await createInstance({
-      networkUrl: hre.network.config.url || "http://localhost:8545",
-      gatewayUrl: "http://localhost:7077",
-    });
   });
 
   describe("Increment", function () {
     it("should increment the counter with encrypted value", async function () {
       const [signer] = signers;
-
-      // Encrypt the value to add
       const valueToAdd = 5;
-      const encrypted = await fhevm.encrypt32(valueToAdd);
 
-      // Call increment
-      const tx = await contract.connect(signer).increment(
-        encrypted.handles[0],
-        encrypted.inputProof
-      );
+      // Create encrypted input using hardhat plugin
+      const encryptedInput = await fhevm
+        .createEncryptedInput(contractAddress, signer.address)
+        .add32(valueToAdd)
+        .encrypt();
+
+      // Call increment with encrypted value and proof
+      const tx = await contract
+        .connect(signer)
+        .increment(encryptedInput.handles[0], encryptedInput.inputProof);
       await tx.wait();
 
       // Get the encrypted count
       const encryptedCount = await contract.getCount();
-
-      // Request decryption (in real scenario, would use gateway)
-      expect(encryptedCount).to.not.equal(0n);
+      expect(encryptedCount).to.not.equal(ethers.ZeroHash);
     });
 
     it("should allow multiple increments", async function () {
       const [signer] = signers;
 
       // First increment
-      const encrypted1 = await fhevm.encrypt32(10);
-      await contract.connect(signer).increment(
-        encrypted1.handles[0],
-        encrypted1.inputProof
-      );
+      const encrypted1 = await fhevm
+        .createEncryptedInput(contractAddress, signer.address)
+        .add32(10)
+        .encrypt();
+      await contract.connect(signer).increment(encrypted1.handles[0], encrypted1.inputProof);
 
       // Second increment
-      const encrypted2 = await fhevm.encrypt32(20);
-      await contract.connect(signer).increment(
-        encrypted2.handles[0],
-        encrypted2.inputProof
-      );
+      const encrypted2 = await fhevm
+        .createEncryptedInput(contractAddress, signer.address)
+        .add32(20)
+        .encrypt();
+      await contract.connect(signer).increment(encrypted2.handles[0], encrypted2.inputProof);
 
       const encryptedCount = await contract.getCount();
-      expect(encryptedCount).to.not.equal(0n);
+      expect(encryptedCount).to.not.equal(ethers.ZeroHash);
     });
   });
 
@@ -74,21 +68,21 @@ describe("{{CONTRACT_NAME}}", function () {
       const [signer] = signers;
 
       // First add some value
-      const addValue = await fhevm.encrypt32(100);
-      await contract.connect(signer).increment(
-        addValue.handles[0],
-        addValue.inputProof
-      );
+      const addValue = await fhevm
+        .createEncryptedInput(contractAddress, signer.address)
+        .add32(100)
+        .encrypt();
+      await contract.connect(signer).increment(addValue.handles[0], addValue.inputProof);
 
       // Then decrement
-      const subValue = await fhevm.encrypt32(30);
-      await contract.connect(signer).decrement(
-        subValue.handles[0],
-        subValue.inputProof
-      );
+      const subValue = await fhevm
+        .createEncryptedInput(contractAddress, signer.address)
+        .add32(30)
+        .encrypt();
+      await contract.connect(signer).decrement(subValue.handles[0], subValue.inputProof);
 
       const encryptedCount = await contract.getCount();
-      expect(encryptedCount).to.not.equal(0n);
+      expect(encryptedCount).to.not.equal(ethers.ZeroHash);
     });
   });
 
@@ -96,15 +90,15 @@ describe("{{CONTRACT_NAME}}", function () {
     it("should grant access to caller after increment", async function () {
       const [signer] = signers;
 
-      const encrypted = await fhevm.encrypt32(1);
-      await contract.connect(signer).increment(
-        encrypted.handles[0],
-        encrypted.inputProof
-      );
+      const encrypted = await fhevm
+        .createEncryptedInput(contractAddress, signer.address)
+        .add32(1)
+        .encrypt();
+      await contract.connect(signer).increment(encrypted.handles[0], encrypted.inputProof);
 
       // Caller should be able to get the count
       const count = await contract.connect(signer).getCount();
-      expect(count).to.not.equal(0n);
+      expect(count).to.not.equal(ethers.ZeroHash);
     });
   });
 

package/templates/buildable/projects/prediction-market/test/PredictionMarket.test.ts.tmpl

@@ -1,5 +1,6 @@
 import { expect } from "chai";
 import { ethers } from "hardhat";
+import { time } from "@nomicfoundation/hardhat-network-helpers";
 import { {{CONTRACT_NAME}} } from "../typechain-types";
 import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
 
@@ -72,13 +73,15 @@ describe("{{CONTRACT_NAME}}", function () {
     let deadline: number;
 
     beforeEach(async function () {
-      deadline = Math.floor(Date.now() / 1000) + 1; // 1 second from now
+      // Get current block timestamp and add 60 seconds
+      const block = await ethers.provider.getBlock("latest");
+      deadline = block!.timestamp + 60;
       const tx = await market.createMarket("Test question?", deadline);
       await tx.wait();
       marketId = 0;
 
-      // Wait for deadline to pass
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      // Advance blockchain time past deadline
+      await time.increaseTo(deadline + 1);
     });
 
     it("Should allow oracle to resolve market", async function () {
@@ -140,11 +143,12 @@ describe("{{CONTRACT_NAME}}", function () {
     it("Should handle complete market lifecycle", async function () {
       // 1. Create market
       const question = "Will BTC hit $100k?";
-      const deadline = Math.floor(Date.now() / 1000) + 1;
+      const block = await ethers.provider.getBlock("latest");
+      const deadline = block!.timestamp + 60;
       await market.createMarket(question, deadline);
 
-      // 2. Wait for deadline
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      // 2. Advance time past deadline
+      await time.increaseTo(deadline + 1);
 
       // 3. Resolve market
       await market.resolveMarket(0, true);

package/templates/buildable/projects/token/deploy/deploy.ts.tmpl

@@ -1,32 +1,39 @@
-import { ethers } from "hardhat";
+import hre from "hardhat";
 
 async function main() {
-  const tokenName = "Confidential Token";
-  const tokenSymbol = "CFHE";
-
   console.log("Deploying {{CONTRACT_NAME}}...");
-  console.log("  Name:", tokenName);
-  console.log("  Symbol:", tokenSymbol);
 
-  const TokenFactory = await ethers.getContractFactory("{{CONTRACT_NAME}}");
-  const token = await TokenFactory.deploy(tokenName, tokenSymbol);
+  const Factory = await hre.ethers.getContractFactory("{{CONTRACT_NAME}}");
+  const contract = await Factory.deploy();
+
+  await contract.waitForDeployment();
+
+  const address = await contract.getAddress();
+  console.log(`{{CONTRACT_NAME}} deployed to: ${address}`);
 
-  await token.waitForDeployment();
+  // Verify on explorer if not local
+  if (hre.network.name !== "hardhat" && hre.network.name !== "localhost") {
+    console.log("Waiting for block confirmations...");
+    await contract.deploymentTransaction()?.wait(5);
 
-  const address = await token.getAddress();
-  console.log("\n{{CONTRACT_NAME}} deployed to:", address);
+    console.log("Verifying contract...");
+    try {
+      await hre.run("verify:verify", {
+        address: address,
+        constructorArguments: [],
+      });
+      console.log("Contract verified!");
+    } catch (error) {
+      console.log("Verification failed:", error);
+    }
+  }
 
-  console.log("\nToken Operations:");
-  console.log("  - mint(to, encryptedAmount): Mint tokens (owner only)");
-  console.log("  - transfer(to, encryptedAmount): Transfer tokens");
-  console.log("  - balanceOf(account): Get encrypted balance handle");
-  console.log("\nPrivacy Guarantees:");
-  console.log("  - Balances are encrypted");
-  console.log("  - Transfer amounts are private");
-  console.log("  - Only balance owner can decrypt");
+  return address;
 }
 
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

package/templates/buildable/projects/token/test/Token.test.ts.tmpl

@@ -0,0 +1,187 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+import { FhevmType } from "@fhevm/hardhat-plugin";
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+
+describe("{{CONTRACT_NAME}}", function () {
+  let contract: any;
+  let contractAddress: string;
+  let signers: { alice: HardhatEthersSigner; bob: HardhatEthersSigner };
+
+  before(async function () {
+    const [alice, bob] = await ethers.getSigners();
+    signers = { alice, bob };
+  });
+
+  beforeEach(async function () {
+    const Factory = await ethers.getContractFactory("{{CONTRACT_NAME}}");
+    contract = await Factory.deploy("TestToken", "TTK");
+    await contract.waitForDeployment();
+    contractAddress = await contract.getAddress();
+  });
+
+  describe("Metadata", function () {
+    it("should return correct name", async function () {
+      expect(await contract.name()).to.eq("TestToken");
+    });
+
+    it("should return correct symbol", async function () {
+      expect(await contract.symbol()).to.eq("TTK");
+    });
+  });
+
+  describe("Mint", function () {
+    it("should mint tokens to alice", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add64(1000)
+        .encrypt();
+
+      const tx = await contract.mint(
+        signers.alice.address,
+        encryptedInput.handles[0],
+        encryptedInput.inputProof
+      );
+      await tx.wait();
+
+      // Get alice's encrypted balance
+      const encryptedBalance = await contract.balanceOf(signers.alice.address);
+
+      // Decrypt and verify
+      const clearBalance = await fhevm.userDecryptEuint(
+        FhevmType.euint64,
+        encryptedBalance,
+        contractAddress,
+        signers.alice
+      );
+
+      expect(clearBalance).to.eq(1000);
+    });
+
+    it("should mint more tokens and update balance", async function () {
+      // First mint
+      const input1 = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add64(1000)
+        .encrypt();
+
+      await contract.mint(
+        signers.alice.address,
+        input1.handles[0],
+        input1.inputProof
+      );
+
+      // Mint 500 more tokens
+      const input2 = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add64(500)
+        .encrypt();
+
+      await contract.mint(
+        signers.alice.address,
+        input2.handles[0],
+        input2.inputProof
+      );
+
+      // Get alice's encrypted balance (should be 1500)
+      const encryptedBalance = await contract.balanceOf(signers.alice.address);
+
+      const clearBalance = await fhevm.userDecryptEuint(
+        FhevmType.euint64,
+        encryptedBalance,
+        contractAddress,
+        signers.alice
+      );
+
+      expect(clearBalance).to.eq(1500);
+    });
+  });
+
+  describe("Transfer", function () {
+    it("should transfer tokens from alice to bob", async function () {
+      // First mint tokens to alice
+      const mintInput = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add64(1000)
+        .encrypt();
+
+      await contract.mint(
+        signers.alice.address,
+        mintInput.handles[0],
+        mintInput.inputProof
+      );
+
+      // Alice transfers 300 tokens to bob
+      const transferInput = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add64(300)
+        .encrypt();
+
+      const tx = await contract.connect(signers.alice).transfer(
+        signers.bob.address,
+        transferInput.handles[0],
+        transferInput.inputProof
+      );
+      await tx.wait();
+
+      // Check alice's balance (should be 1000 - 300 = 700)
+      const aliceEncryptedBalance = await contract.balanceOf(signers.alice.address);
+      const aliceClearBalance = await fhevm.userDecryptEuint(
+        FhevmType.euint64,
+        aliceEncryptedBalance,
+        contractAddress,
+        signers.alice
+      );
+      expect(aliceClearBalance).to.eq(700);
+
+      // Check bob's balance (should be 300)
+      const bobEncryptedBalance = await contract.balanceOf(signers.bob.address);
+      const bobClearBalance = await fhevm.userDecryptEuint(
+        FhevmType.euint64,
+        bobEncryptedBalance,
+        contractAddress,
+        signers.bob
+      );
+      expect(bobClearBalance).to.eq(300);
+    });
+
+    it("should handle transfer exceeding balance (no transfer occurs)", async function () {
+      // Mint 300 tokens to bob
+      const mintInput = await fhevm
+        .createEncryptedInput(contractAddress, signers.bob.address)
+        .add64(300)
+        .encrypt();
+
+      await contract.mint(
+        signers.bob.address,
+        mintInput.handles[0],
+        mintInput.inputProof
+      );
+
+      // Bob tries to transfer 500 tokens (only has 300)
+      const transferInput = await fhevm
+        .createEncryptedInput(contractAddress, signers.bob.address)
+        .add64(500)
+        .encrypt();
+
+      const tx = await contract.connect(signers.bob).transfer(
+        signers.alice.address,
+        transferInput.handles[0],
+        transferInput.inputProof
+      );
+      await tx.wait();
+
+      // Bob's balance should still be 300 (transfer didn't happen)
+      const bobEncryptedBalance = await contract.balanceOf(signers.bob.address);
+      const bobClearBalance = await fhevm.userDecryptEuint(
+        FhevmType.euint64,
+        bobEncryptedBalance,
+        contractAddress,
+        signers.bob
+      );
+      expect(bobClearBalance).to.eq(300);
+    });
+  });
+
+  {{TEST_EXTENSIONS}}
+});

package/templates/buildable/projects/voting/contracts/Voting.sol.tmpl

@@ -80,8 +80,8 @@ contract {{CONTRACT_NAME}} is {{INHERITS}} {
         Proposal storage proposal = _proposals[proposalId];
         proposal.description = description;
         proposal.endTime = block.timestamp + durationSeconds;
-        proposal.yesVotes = FHE.asEuint64(0);
-        proposal.noVotes = FHE.asEuint64(0);
+        proposal.yesVotes = FHE.asEuint32(0);
+        proposal.noVotes = FHE.asEuint32(0);
         proposal.exists = true;
 
         // Set ACL for vote counts
@@ -118,13 +118,13 @@ contract {{CONTRACT_NAME}} is {{INHERITS}} {
         [[VOTE_TYPE]] eVote = FHE.fromExternal(encryptedVote, inputProof);
 
         // Encrypted vote: if vote > 0, it's a yes vote
-        ebool isYes = FHE.gt(eVote, FHE.asEuint64(0));
+        ebool isYes = FHE.gt(eVote, FHE.asEuint32(0));
 
         // Homomorphic conditional addition
         // yesVotes += isYes ? 1 : 0
         // noVotes += isYes ? 0 : 1
-        [[VOTE_TYPE]] one = FHE.asEuint64(1);
-        [[VOTE_TYPE]] zero = FHE.asEuint64(0);
+        [[VOTE_TYPE]] one = FHE.asEuint32(1);
+        [[VOTE_TYPE]] zero = FHE.asEuint32(0);
 
         proposal.yesVotes = FHE.add(proposal.yesVotes, FHE.select(isYes, one, zero));
         proposal.noVotes = FHE.add(proposal.noVotes, FHE.select(isYes, zero, one));

package/templates/buildable/projects/voting/deploy/deploy.ts.tmpl

@@ -1,28 +1,39 @@
-import { ethers } from "hardhat";
+import hre from "hardhat";
 
 async function main() {
   console.log("Deploying {{CONTRACT_NAME}}...");
 
-  const VotingFactory = await ethers.getContractFactory("{{CONTRACT_NAME}}");
-  const voting = await VotingFactory.deploy();
+  const Factory = await hre.ethers.getContractFactory("{{CONTRACT_NAME}}");
+  const contract = await Factory.deploy();
 
-  await voting.waitForDeployment();
+  await contract.waitForDeployment();
 
-  const address = await voting.getAddress();
-  console.log("\n{{CONTRACT_NAME}} deployed to:", address);
+  const address = await contract.getAddress();
+  console.log(`{{CONTRACT_NAME}} deployed to: ${address}`);
 
-  console.log("\nVoting Operations:");
-  console.log("  - createProposal(title, description, duration): Create proposal");
-  console.log("  - vote(proposalId, encryptedVote): Cast encrypted vote");
-  console.log("  - requestTally(proposalId): Request vote count reveal");
-  console.log("  - finalizeTally(proposalId, yesVotes, noVotes, proof): Finalize");
-  console.log("\nPrivacy Guarantees:");
-  console.log("  - Individual votes are encrypted");
-  console.log("  - Only final tally is revealed");
-  console.log("  - No one knows how you voted");
+  // Verify on explorer if not local
+  if (hre.network.name !== "hardhat" && hre.network.name !== "localhost") {
+    console.log("Waiting for block confirmations...");
+    await contract.deploymentTransaction()?.wait(5);
+
+    console.log("Verifying contract...");
+    try {
+      await hre.run("verify:verify", {
+        address: address,
+        constructorArguments: [],
+      });
+      console.log("Contract verified!");
+    } catch (error) {
+      console.log("Verification failed:", error);
+    }
+  }
+
+  return address;
 }
 
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

package/templates/buildable/projects/voting/test/Voting.test.ts.tmpl

@@ -0,0 +1,135 @@
+import { expect } from "chai";
+import { ethers, fhevm } from "hardhat";
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+
+describe("{{CONTRACT_NAME}}", function () {
+  let contract: any;
+  let contractAddress: string;
+  let signers: { alice: HardhatEthersSigner; bob: HardhatEthersSigner; charlie: HardhatEthersSigner };
+
+  before(async function () {
+    const [alice, bob, charlie] = await ethers.getSigners();
+    signers = { alice, bob, charlie };
+  });
+
+  beforeEach(async function () {
+    const Factory = await ethers.getContractFactory("{{CONTRACT_NAME}}");
+    contract = await Factory.deploy();
+    await contract.waitForDeployment();
+    contractAddress = await contract.getAddress();
+  });
+
+  describe("Proposal Creation", function () {
+    it("should create a proposal", async function () {
+      const tx = await contract.createProposal("Should we upgrade?", 3600); // 1 hour duration
+      await tx.wait();
+
+      const [description, endTime, exists, finalized] = await contract.getProposal(1);
+
+      expect(description).to.eq("Should we upgrade?");
+      expect(exists).to.be.true;
+      expect(finalized).to.be.false;
+    });
+
+    it("should increment proposal ID", async function () {
+      await contract.createProposal("Proposal 1", 3600);
+      expect(await contract.nextProposalId()).to.eq(2);
+    });
+  });
+
+  describe("Voting", function () {
+    beforeEach(async function () {
+      // Create a proposal for voting tests
+      await contract.createProposal("Test Proposal", 3600);
+    });
+
+    it("should allow alice to vote YES (vote = 1)", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add32(1) // YES vote
+        .encrypt();
+
+      const tx = await contract.connect(signers.alice).vote(
+        1, // proposalId
+        encryptedInput.handles[0],
+        encryptedInput.inputProof
+      );
+      await tx.wait();
+
+      expect(await contract.hasVoted(1, signers.alice.address)).to.be.true;
+    });
+
+    it("should allow bob to vote NO (vote = 0)", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(contractAddress, signers.bob.address)
+        .add32(0) // NO vote
+        .encrypt();
+
+      const tx = await contract.connect(signers.bob).vote(
+        1,
+        encryptedInput.handles[0],
+        encryptedInput.inputProof
+      );
+      await tx.wait();
+
+      expect(await contract.hasVoted(1, signers.bob.address)).to.be.true;
+    });
+
+    it("should allow charlie to vote YES", async function () {
+      const encryptedInput = await fhevm
+        .createEncryptedInput(contractAddress, signers.charlie.address)
+        .add32(5) // Any value > 0 is YES
+        .encrypt();
+
+      const tx = await contract.connect(signers.charlie).vote(
+        1,
+        encryptedInput.handles[0],
+        encryptedInput.inputProof
+      );
+      await tx.wait();
+
+      expect(await contract.hasVoted(1, signers.charlie.address)).to.be.true;
+    });
+
+    it("should prevent double voting", async function () {
+      // First vote
+      const input1 = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add32(1)
+        .encrypt();
+      await contract.connect(signers.alice).vote(1, input1.handles[0], input1.inputProof);
+
+      // Try to vote again
+      const input2 = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add32(1)
+        .encrypt();
+
+      await expect(
+        contract.connect(signers.alice).vote(1, input2.handles[0], input2.inputProof)
+      ).to.be.revertedWithCustomError(contract, "AlreadyVoted");
+    });
+  });
+
+  describe("Vote Counts", function () {
+    it("should return encrypted vote counts (private by design)", async function () {
+      // Create proposal and cast votes
+      await contract.createProposal("Test Proposal", 3600);
+
+      const input1 = await fhevm
+        .createEncryptedInput(contractAddress, signers.alice.address)
+        .add32(1)
+        .encrypt();
+      await contract.connect(signers.alice).vote(1, input1.handles[0], input1.inputProof);
+
+      // Vote counts are intentionally private
+      const [yesVotes, noVotes] = await contract.getVoteCounts(1);
+
+      // Verify handles are returned (non-zero bytes32)
+      expect(yesVotes).to.not.eq(ethers.ZeroHash);
+      expect(noVotes).to.not.eq(ethers.ZeroHash);
+    });
+  });
+
+  {{TEST_EXTENSIONS}}
+});