@0xflydev/labz 1.0.21 → 1.0.23

package/dist/index.js

@@ -1616,8 +1616,11 @@ async function writeProject(outputDir, result, base, templatesDir) {
   if (fs4.existsSync(pkgPath)) {
     const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
     pkg.name = path4.basename(outputDir);
+    pkg.description = base.description || "FHEVM Smart Contract";
     fs4.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2), "utf-8");
   }
+  const readmeContent = generateBuildReadme(path4.basename(outputDir), base, result);
+  fs4.writeFileSync(path4.join(outputDir, "README.md"), readmeContent, "utf-8");
   cleanupGitkeep(outputDir);
 }
 function cleanupGitkeep(dir) {
@@ -1648,6 +1651,75 @@ function copyDirSync(src, dest) {
     }
   }
 }
+function generateBuildReadme(projectName, base, result) {
+  const contractName = result.stats.baseTemplate.charAt(0).toUpperCase() + result.stats.baseTemplate.slice(1);
+  const modules = result.stats.modulesApplied || [];
+  const lines = [];
+  lines.push(`# ${projectName}`);
+  lines.push("");
+  lines.push(`${base.description}`);
+  lines.push("");
+  lines.push("## Overview");
+  lines.push("");
+  lines.push(`Base template: **${base.name}**`);
+  if (modules.length > 0) {
+    lines.push("");
+    lines.push("### Modules Applied");
+    lines.push("");
+    for (const mod of modules) {
+      lines.push(`- ${mod}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Quick Start");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("# Install dependencies");
+  lines.push("npm install");
+  lines.push("");
+  lines.push("# Compile contracts");
+  lines.push("npx hardhat compile");
+  lines.push("");
+  lines.push("# Run tests");
+  lines.push("npx hardhat test");
+  lines.push("");
+  lines.push("# Deploy (local)");
+  lines.push("npx hardhat run deploy/deploy.ts");
+  lines.push("```");
+  lines.push("");
+  lines.push("## Project Structure");
+  lines.push("");
+  lines.push("```");
+  lines.push(`${projectName}/`);
+  lines.push("  contracts/");
+  lines.push(`    ${contractName}.sol`);
+  lines.push("  test/");
+  lines.push(`    ${contractName}.test.ts`);
+  lines.push("  deploy/");
+  lines.push("    deploy.ts");
+  lines.push("  hardhat.config.ts");
+  lines.push("  package.json");
+  lines.push("```");
+  lines.push("");
+  lines.push("## FHE Operations");
+  lines.push("");
+  lines.push("This contract uses encrypted data types from FHEVM:");
+  lines.push("- `euint64`, `euint32`, `ebool` - Encrypted integers and booleans");
+  lines.push("- `FHE.add`, `FHE.sub`, `FHE.mul` - Encrypted arithmetic");
+  lines.push("- `FHE.lt`, `FHE.gt`, `FHE.eq` - Encrypted comparisons");
+  lines.push("- `FHE.select` - Encrypted conditional selection");
+  lines.push("");
+  lines.push("## Resources");
+  lines.push("");
+  lines.push("- [FHEVM Documentation](https://docs.zama.ai/fhevm)");
+  lines.push("- [Lab-Z CLI](https://github.com/Farukest/Lab-Z)");
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("Generated with [Lab-Z](https://github.com/Farukest/Lab-Z)");
+  lines.push("");
+  return lines.join("\n");
+}
 
 // src/commands/doctor.ts
 var import_commander7 = require("commander");

package/package.json

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

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/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/auction/deploy/deploy.ts.tmpl

@@ -1,38 +0,0 @@
-import { ethers } 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");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

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

@@ -1,32 +0,0 @@
-import { ethers } 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);
-
-  await token.waitForDeployment();
-
-  const address = await token.getAddress();
-  console.log("\n{{CONTRACT_NAME}} deployed to:", address);
-
-  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");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

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

@@ -1,28 +0,0 @@
-import { ethers } from "hardhat";
-
-async function main() {
-  console.log("Deploying {{CONTRACT_NAME}}...");
-
-  const VotingFactory = await ethers.getContractFactory("{{CONTRACT_NAME}}");
-  const voting = await VotingFactory.deploy();
-
-  await voting.waitForDeployment();
-
-  const address = await voting.getAddress();
-  console.log("\n{{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");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});