@0xflydev/labz 1.0.23 → 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.23",
+  "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

@@ -0,0 +1,39 @@
+import hre from "hardhat";
+
+async function main() {
+  console.log("Deploying {{CONTRACT_NAME}}...");
+
+  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()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

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

@@ -0,0 +1,39 @@
+import hre from "hardhat";
+
+async function main() {
+  console.log("Deploying {{CONTRACT_NAME}}...");
+
+  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()
+  .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/deploy/deploy.ts.tmpl

@@ -0,0 +1,39 @@
+import hre from "hardhat";
+
+async function main() {
+  console.log("Deploying {{CONTRACT_NAME}}...");
+
+  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()
+  .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}}
+});