@lfdecentralizedtrust/zeto-contracts 0.2.2 → 0.5.1

package/ignition/modules/zeto_anon_enc_nullifier.ts

@@ -20,6 +20,7 @@ import {
   DepositVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
+  ZetoLockableLibModule,
 } from "./lib/deps";
 
 const VerifierModule = buildModule("Groth16Verifier_AnonEncNullifier", (m) => {
@@ -35,10 +36,40 @@ const BatchVerifierModule = buildModule(
   },
 );
 
+// Locked-input transfers reuse the plain {Groth16Verifier_AnonEnc} verifier
+// (the same one the non-nullifier {Zeto_AnonEnc} token uses for its
+// regular transfers), NOT a nullifier-aware verifier.
+//
+// Rationale: under the new ILockableCapability storage, locked UTXOs are
+// kept in a flat per-lock mapping keyed by lockId — there is no SMT for
+// locked UTXOs and the locked-input proof has no nullifier history to
+// bind against. {Zeto_AnonEncNullifier.constructPublicInputs(...,
+// inputsLocked = true)} reflects this by emitting public inputs as
+// `[ecdhPublicKey, encryptedValues, inputCommitments, outputCommitments,
+// encryptionNonce]` — exactly what `Groth16Verifier_AnonEnc` expects.
+// The encryption witness (ECDH key + encrypted blob) still applies because
+// the receiver still needs data availability for the post-spend outputs.
+const LockVerifierModule = buildModule("Groth16Verifier_AnonEnc", (m) => {
+  const verifier = m.contract("Groth16Verifier_AnonEnc", []);
+  return { verifier };
+});
+
+// Batched (10-in / 10-out) twin of {LockVerifierModule}. Same rationale.
+const BatchLockVerifierModule = buildModule(
+  "Groth16Verifier_AnonEncBatch",
+  (m) => {
+    const verifier = m.contract("Groth16Verifier_AnonEncBatch", []);
+    return { verifier };
+  },
+);
+
 export default buildModule("Zeto_AnonEncNullifier", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
+  const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
   const { verifier: batchVerifier } = m.useModule(BatchVerifierModule);
+  const { verifier: batchLockVerifier } = m.useModule(BatchLockVerifierModule);
   const { verifier: depositVerifier } = m.useModule(DepositVerifierModule);
   const { verifier: withdrawVerifier } = m.useModule(
     WithdrawNullifierVerifierModule,
@@ -51,10 +82,13 @@ export default buildModule("Zeto_AnonEncNullifier", (m) => {
     depositVerifier,
     withdrawVerifier,
     verifier,
+    lockVerifier,
     batchVerifier,
+    batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   };
 });

package/ignition/modules/zeto_anon_enc_nullifier_kyc.ts

@@ -17,9 +17,10 @@
 import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
 import {
   SmtLibModule,
-  DepositVerifierModule,
+  DepositKycVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
+  ZetoLockableLibModule,
 } from "./lib/deps";
 
 const VerifierModule = buildModule(
@@ -39,10 +40,11 @@ const BatchVerifierModule = buildModule(
 );
 
 export default buildModule("Zeto_AnonEncNullifierKyc", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: batchVerifier } = m.useModule(BatchVerifierModule);
-  const { verifier: depositVerifier } = m.useModule(DepositVerifierModule);
+  const { verifier: depositVerifier } = m.useModule(DepositKycVerifierModule);
   const { verifier: withdrawVerifier } = m.useModule(
     WithdrawNullifierVerifierModule,
   );
@@ -59,5 +61,6 @@ export default buildModule("Zeto_AnonEncNullifierKyc", (m) => {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   };
 });

package/ignition/modules/zeto_anon_enc_nullifier_non_repudiation.ts

@@ -20,6 +20,7 @@ import {
   DepositVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
+  ZetoLockableLibModule,
 } from "./lib/deps";
 
 const VerifierModule = buildModule(
@@ -45,6 +46,7 @@ const BatchVerifierModule = buildModule(
 );
 
 export default buildModule("Zeto_AnonEncNullifierNonRepudiation", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: batchVerifier } = m.useModule(BatchVerifierModule);
@@ -64,5 +66,6 @@ export default buildModule("Zeto_AnonEncNullifierNonRepudiation", (m) => {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   };
 });

package/ignition/modules/zeto_anon_nullifier.ts

@@ -20,6 +20,7 @@ import {
   DepositVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
+  ZetoLockableLibModule,
 } from "./lib/deps";
 
 const VerifierModule = buildModule(
@@ -30,11 +31,31 @@ const VerifierModule = buildModule(
   },
 );
 
+// Locked-input transfers reuse the plain {Groth16Verifier_Anon} verifier
+// (the same one the non-nullifier {Zeto_Anon} token uses for its regular
+// transfers), NOT a nullifier-aware verifier.
+//
+// Rationale: under the new ILockableCapability storage, locked UTXOs are
+// kept in a flat per-lock mapping keyed by lockId. Previously they were
+// shadowed in a dedicated locked-state Sparse Merkle Tree (separate from
+// the unlocked-UTXO SMT) so that the locked-input proof could assert
+// SMT membership against a locked-state root; that secondary tree has
+// been removed. As a result, settling a lock now consumes the locked
+// UTXOs by their raw commitment hashes (the on-chain mapping enforces
+// single-spend semantics — a lock can only be cleared once), so the
+// proof has no nullifiers and no SMT membership to bind against. That
+// matches exactly what the simpler `anon` circuit asserts: hash + sum +
+// owner-key derivation over input/output commitments.
+//
+// The corresponding contract code path is
+// {Zeto_AnonNullifier.constructPublicInputs(..., inputsLocked = true)},
+// which emits public inputs as `[inputCommitments, outputCommitments]`
+// — exactly the layout `Groth16Verifier_Anon` expects.
 const LockVerifierModule = buildModule(
-  "Groth16Verifier_AnonNullifierTransferLocked",
+  "Groth16Verifier_Anon",
   (m) => {
     const verifier = m.contract(
-      "Groth16Verifier_AnonNullifierTransferLocked",
+      "Groth16Verifier_Anon",
       [],
     );
     return { verifier };
@@ -52,11 +73,15 @@ const BatchVerifierModule = buildModule(
   },
 );
 
+// Batched (10-in / 10-out) twin of {LockVerifierModule}. Same rationale:
+// locked-input settlements consume raw UTXO commitments — not nullifiers
+// — so the lock-side verifier is the plain `anon_batch` one, not the
+// nullifier-aware `anon_nullifier_transfer_batch`.
 const BatchLockVerifierModule = buildModule(
-  "Groth16Verifier_AnonNullifierTransferLockedBatch",
+  "Groth16Verifier_AnonBatch",
   (m) => {
     const verifier = m.contract(
-      "Groth16Verifier_AnonNullifierTransferLockedBatch",
+      "Groth16Verifier_AnonBatch",
       [],
     );
     return { verifier };
@@ -64,6 +89,7 @@ const BatchLockVerifierModule = buildModule(
 );
 
 export default buildModule("Zeto_AnonNullifier", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
@@ -88,5 +114,6 @@ export default buildModule("Zeto_AnonNullifier", (m) => {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   };
 });

package/ignition/modules/zeto_anon_nullifier_burnable.ts

@@ -20,6 +20,7 @@ import {
   DepositVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
+  ZetoLockableLibModule,
 } from "./lib/deps";
 
 const VerifierModule = buildModule(
@@ -30,11 +31,31 @@ const VerifierModule = buildModule(
   },
 );
 
+// Locked-input transfers reuse the plain {Groth16Verifier_Anon} verifier
+// (the same one the non-nullifier {Zeto_Anon} token uses for its regular
+// transfers), NOT a nullifier-aware verifier.
+//
+// Rationale: under the new ILockableCapability storage, locked UTXOs are
+// kept in a flat per-lock mapping keyed by lockId. Previously they were
+// shadowed in a dedicated locked-state Sparse Merkle Tree (separate from
+// the unlocked-UTXO SMT) so that the locked-input proof could assert
+// SMT membership against a locked-state root; that secondary tree has
+// been removed. As a result, settling a lock now consumes the locked
+// UTXOs by their raw commitment hashes (the on-chain mapping enforces
+// single-spend semantics — a lock can only be cleared once), so the
+// proof has no nullifiers and no SMT membership to bind against. That
+// matches exactly what the simpler `anon` circuit asserts: hash + sum +
+// owner-key derivation over input/output commitments.
+//
+// The corresponding contract code path is
+// {Zeto_AnonNullifier.constructPublicInputs(..., inputsLocked = true)},
+// which emits public inputs as `[inputCommitments, outputCommitments]`
+// — exactly the layout `Groth16Verifier_Anon` expects.
 const LockVerifierModule = buildModule(
-  "Groth16Verifier_AnonNullifierTransferLocked",
+  "Groth16Verifier_Anon",
   (m) => {
     const verifier = m.contract(
-      "Groth16Verifier_AnonNullifierTransferLocked",
+      "Groth16Verifier_Anon",
       [],
     );
     return { verifier };
@@ -44,30 +65,47 @@ const LockVerifierModule = buildModule(
 const BatchVerifierModule = buildModule(
   "Groth16Verifier_AnonNullifierTransferBatch",
   (m) => {
-    const verifier = m.contract("Groth16Verifier_AnonNullifierTransferBatch", []);
+    const verifier = m.contract(
+      "Groth16Verifier_AnonNullifierTransferBatch",
+      [],
+    );
     return { verifier };
   },
 );
 
+// Batched (10-in / 10-out) twin of {LockVerifierModule}. Same rationale:
+// locked-input settlements consume raw UTXO commitments — not nullifiers
+// — so the lock-side verifier is the plain `anon_batch` one, not the
+// nullifier-aware `anon_nullifier_transfer_batch`.
 const BatchLockVerifierModule = buildModule(
-  "Groth16Verifier_AnonNullifierTransferLockedBatch",
+  "Groth16Verifier_AnonBatch",
   (m) => {
-    const verifier = m.contract("Groth16Verifier_AnonNullifierTransferLockedBatch", []);
+    const verifier = m.contract(
+      "Groth16Verifier_AnonBatch",
+      [],
+    );
     return { verifier };
   },
 );
 
-const BurnNullifierVerifierModule = buildModule("Groth16Verifier_BurnNullifier", (m) => {
-  const verifier = m.contract("Groth16Verifier_BurnNullifier", []);
-  return { verifier };
-});
+const BurnNullifierVerifierModule = buildModule(
+  "Groth16Verifier_BurnNullifier",
+  (m) => {
+    const verifier = m.contract("Groth16Verifier_BurnNullifier", []);
+    return { verifier };
+  },
+);
 
-const BatchBurnNullifierVerifierModule = buildModule("Groth16Verifier_BurnNullifierBatch", (m) => {
-  const verifier = m.contract("Groth16Verifier_BurnNullifierBatch", []);
-  return { verifier };
-});
+const BatchBurnNullifierVerifierModule = buildModule(
+  "Groth16Verifier_BurnNullifierBatch",
+  (m) => {
+    const verifier = m.contract("Groth16Verifier_BurnNullifierBatch", []);
+    return { verifier };
+  },
+);
 
 export default buildModule("Zeto_AnonNullifier", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
@@ -80,9 +118,7 @@ export default buildModule("Zeto_AnonNullifier", (m) => {
   const { verifier: batchWithdrawVerifier } = m.useModule(
     BatchWithdrawNullifierVerifierModule,
   );
-  const { verifier: burnVerifier } = m.useModule(
-    BurnNullifierVerifierModule,
-  );
+  const { verifier: burnVerifier } = m.useModule(BurnNullifierVerifierModule);
   const { verifier: batchBurnVerifier } = m.useModule(
     BatchBurnNullifierVerifierModule,
   );
@@ -100,5 +136,6 @@ export default buildModule("Zeto_AnonNullifier", (m) => {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   };
 });

package/ignition/modules/zeto_anon_nullifier_kyc.ts

@@ -17,44 +17,61 @@
 import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
 import {
   SmtLibModule,
-  DepositVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
+  DepositKycVerifierModule,
+  ZetoLockableLibModule,
 } from "./lib/deps";
 
-const VerifierModule = buildModule("Groth16Verifier_AnonNullifierKycTransfer", (m) => {
-  const verifier = m.contract("Groth16Verifier_AnonNullifierKycTransfer", []);
-  return { verifier };
-});
+const VerifierModule = buildModule(
+  "Groth16Verifier_AnonNullifierKycTransfer",
+  (m) => {
+    const verifier = m.contract("Groth16Verifier_AnonNullifierKycTransfer", []);
+    return { verifier };
+  },
+);
 
 const BatchVerifierModule = buildModule(
   "Groth16Verifier_AnonNullifierKycTransferBatch",
   (m) => {
-    const verifier = m.contract("Groth16Verifier_AnonNullifierKycTransferBatch", []);
+    const verifier = m.contract(
+      "Groth16Verifier_AnonNullifierKycTransferBatch",
+      [],
+    );
     return { verifier };
   },
 );
 
-const LockVerifierModule = buildModule("Groth16Verifier_AnonNullifierKycTransferLocked", (m) => {
-  const verifier = m.contract("Groth16Verifier_AnonNullifierKycTransferLocked", []);
-  return { verifier };
-});
+const LockVerifierModule = buildModule(
+  "Groth16Verifier_AnonNullifierKycTransferLocked",
+  (m) => {
+    const verifier = m.contract(
+      "Groth16Verifier_AnonNullifierKycTransferLocked",
+      [],
+    );
+    return { verifier };
+  },
+);
 
 const BatchLockVerifierModule = buildModule(
   "Groth16Verifier_AnonNullifierKycTransferLockedBatch",
   (m) => {
-    const verifier = m.contract("Groth16Verifier_AnonNullifierKycTransferLockedBatch", []);
+    const verifier = m.contract(
+      "Groth16Verifier_AnonNullifierKycTransferLockedBatch",
+      [],
+    );
     return { verifier };
   },
 );
 
 export default buildModule("Zeto_AnonNullifierKyc", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: batchVerifier } = m.useModule(BatchVerifierModule);
   const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
   const { verifier: batchLockVerifier } = m.useModule(BatchLockVerifierModule);
-  const { verifier: depositVerifier } = m.useModule(DepositVerifierModule);
+  const { verifier: depositVerifier } = m.useModule(DepositKycVerifierModule);
   const { verifier: withdrawVerifier } = m.useModule(
     WithdrawNullifierVerifierModule,
   );
@@ -73,5 +90,6 @@ export default buildModule("Zeto_AnonNullifierKyc", (m) => {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   };
 });

package/ignition/modules/zeto_anon_nullifier_qurrency.ts

@@ -20,6 +20,7 @@ import {
   DepositVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
+  ZetoLockableLibModule,
 } from "./lib/deps";
 
 const VerifierModule = buildModule(
@@ -64,6 +65,7 @@ const BatchVerifierModule = buildModule(
 // );
 
 export default buildModule("Zeto_AnonNullifierQurrency", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { smtLib, poseidon2, poseidon3, poseidon5, poseidon6 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   // const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
@@ -90,5 +92,6 @@ export default buildModule("Zeto_AnonNullifierQurrency", (m) => {
     poseidon3,
     poseidon5,
     poseidon6,
+    zetoLockableLib,
   };
 });

package/ignition/modules/zeto_nf_anon.ts

@@ -15,13 +15,15 @@
 // limitations under the License.
 
 import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
+import { ZetoLockableLibModule } from "./lib/deps";
 const VerifierModule = buildModule("Groth16Verifier_NfAnon", (m) => {
   const verifier = m.contract("Groth16Verifier_NfAnon", []);
   return { verifier };
 });
 
 export default buildModule("Zeto_NfAnon", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { verifier } = m.useModule(VerifierModule);
 
-  return { verifier };
+  return { verifier, zetoLockableLib };
 });

package/ignition/modules/zeto_nf_anon_nullifier.ts

@@ -15,7 +15,7 @@
 // limitations under the License.
 
 import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
-import { SmtLibModule } from "./lib/deps";
+import { SmtLibModule, ZetoLockableLibModule } from "./lib/deps";
 
 const VerifierModule = buildModule(
   "Groth16Verifier_NfAnonNullifierTransfer",
@@ -25,21 +25,26 @@ const VerifierModule = buildModule(
   },
 );
 
-const LockVerifierModule = buildModule(
-  "Groth16Verifier_NfAnonNullifierTransferLocked",
-  (m) => {
-    const verifier = m.contract(
-      "Groth16Verifier_NfAnonNullifierTransferLocked",
-      [],
-    );
-    return { verifier };
-  },
-);
+// Locked-input transition for the NF nullifier token reuses the simple
+// {Groth16Verifier_NfAnon} verifier, mirroring how Zeto_AnonNullifier
+// reuses {Groth16Verifier_Anon} for its lock path. In the new
+// {ILockableCapability} architecture the locked-UTXO ledger is a flat
+// mapping (no Merkle tree, no per-UTXO delegate SMT), so the proof for
+// a locked-input spend collapses to the same `[input, output]` shape as
+// the non-nullifier NF transfer. The historical
+// `Groth16Verifier_NfAnonNullifierTransferLocked` (which baked the
+// locked-SMT inclusion + delegate-binding into the proof) is no longer
+// needed and intentionally not deployed.
+const LockVerifierModule = buildModule("Groth16Verifier_NfAnon", (m) => {
+  const verifier = m.contract("Groth16Verifier_NfAnon", []);
+  return { verifier };
+});
 
 export default buildModule("Zeto_NfAnonNullifier", (m) => {
+  const { zetoLockableLib } = m.useModule(ZetoLockableLibModule);
   const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
 
-  return { verifier, lockVerifier, smtLib, poseidon2, poseidon3 };
+  return { verifier, lockVerifier, smtLib, poseidon2, poseidon3, zetoLockableLib };
 });

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@lfdecentralizedtrust/zeto-contracts",
-  "version": "0.2.2",
+  "version": "0.5.1",
   "description": "Zero knowledge proof based UTXO tokens toolkit for fungible or non-fungible assets",
   "main": "index.js",
   "scripts": {
     "prettier": "npx prettier contracts scripts ignition test --check",
     "prettier:fix": "npm run prettier -- --write",
     "pretest": "npm run prettier:fix",
-    "test": "npx hardhat test"
+    "test": "npx hardhat test",
+    "size": "npx hardhat size-contracts"
   },
   "keywords": [],
   "repository": {
@@ -21,13 +22,16 @@
     "@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
     "@nomicfoundation/hardhat-toolbox": "^5.0.0",
     "circomlibjs": "^0.1.7",
+    "hardhat-contract-sizer": "^2.10.1",
     "maci-crypto": "1.1.1",
+    "mlkem": "^2.3.1",
     "prettier": "^3.3.3",
     "snarkjs": "0.7.5",
+    "tslog": "^4.10.2",
     "zeto-js": "file:../zkp/js"
   },
   "dependencies": {
-    "@iden3/contracts": "git+https://github.com/kaleido-io/contracts.git#keccak256",
+    "@iden3/contracts": "file:../../contracts",
     "@openzeppelin/contracts": "^5.1.0",
     "@openzeppelin/contracts-upgradeable": "^5.0.2",
     "@openzeppelin/hardhat-upgrades": "^3.2.1",

package/scripts/deploy_cloneable.ts

@@ -1,4 +1,11 @@
 import { ethers, ignition } from "hardhat";
+import { Logger, ILogObj } from "tslog";
+const logLevel = process.env.LOG_LEVEL || "3";
+export const logger: Logger<ILogObj> = new Logger({
+  name: "deploy_cloneable",
+  minLevel: parseInt(logLevel),
+});
+
 import erc20Module from "../ignition/modules/erc20";
 import { getLinkedContractFactory, deploy } from "./lib/common";
 
@@ -17,14 +24,15 @@ export async function deployFungible(tokenName: string) {
 
   const zetoImpl: any = await zetoFactory.deploy();
   await zetoImpl.waitForDeployment();
-  // console.log(args);
-  await zetoImpl.connect(deployer).initialize(...args);
-
-  const tx3 = await zetoImpl.connect(deployer).setERC20(erc20.target);
-  await tx3.wait();
+  // Do not call {initialize} or {setERC20} on the implementation. Leaf Zeto
+  // contracts lock the impl with {_disableInitializers} in the constructor,
+  // so {initialize} here would always revert with {InvalidInitialization}.
+  // Factory tests ({ZetoTokenFactory}) deploy ERC1967 proxies whose constructor
+  // delegates {initialize} into fresh proxy storage; {deployZeto} then binds
+  // ERC20 on each proxy via {setERC20}.
 
-  console.log(`ERC20 deployed:     ${erc20.target}`);
-  console.log(`ZetoToken deployed: ${zetoImpl.target}`);
+  logger.debug(`ERC20 deployed:     ${erc20.target}`);
+  logger.debug(`ZetoToken impl deployed: ${zetoImpl.target}`);
 
   return { deployer, zetoImpl, erc20, args };
 }
@@ -42,9 +50,10 @@ export async function deployNonFungible(tokenName: string) {
   }
   const zetoImpl: any = await zetoFactory.deploy();
   await zetoImpl.waitForDeployment();
-  await zetoImpl.connect(deployer).initialize(...args);
+  // Same rationale as {deployFungible}: impl stays uninitialized; proxies
+  // created by the factory run {initialize} via ERC1967Proxy constructor data.
 
-  console.log(`ZetoToken deployed: ${zetoImpl.target}`);
+  logger.debug(`ZetoToken impl deployed: ${zetoImpl.target}`);
 
   return { deployer, zetoImpl, args };
 }
@@ -57,6 +66,6 @@ deploy(deployFungible, deployNonFungible)
     process.exit(0);
   })
   .catch((error) => {
-    console.error(error);
+    logger.error(error);
     process.exit(1);
   });

package/scripts/deploy_upgradeable.ts

@@ -1,4 +1,8 @@
 import { ethers, ignition, upgrades } from "hardhat";
+import { Logger, ILogObj } from "tslog";
+const logLevel = process.env.LOG_LEVEL || "3";
+export const logger: Logger<ILogObj> = new Logger({ name: "deploy_upgradeable", minLevel: parseInt(logLevel) });
+
 import erc20Module from "../ignition/modules/erc20";
 import { getLinkedContractFactory, deploy } from "./lib/common";
 
@@ -6,13 +10,13 @@ export async function deployFungible(tokenName: string, erc20Address?: string) {
   let erc20: any;
   if (!erc20Address) {
     ({ erc20 } = await ignition.deploy(erc20Module));
-    console.log(`ERC20 deployed:     ${erc20.target}`);
+    logger.debug(`ERC20 deployed:     ${erc20.target}`);
   } else {
     erc20 = await ethers.getContractAt("SampleERC20", erc20Address);
     if (!erc20) {
       throw new Error(`ERC20 contract not found at address: ${erc20Address}`);
     }
-    console.log(`Using existing ERC20 contract at: ${erc20.target}`);
+    logger.debug(`Using existing ERC20 contract at: ${erc20.target}`);
   }
   const verifiersDeployer = require(`./tokens/${tokenName}`);
   const { deployer, args, libraries } =
@@ -39,7 +43,7 @@ export async function deployFungible(tokenName: string, erc20Address?: string) {
   const tx3 = await zeto.connect(deployer).setERC20(erc20.target);
   await tx3.wait();
 
-  console.log(`ZetoToken deployed: ${zeto.target}`);
+  logger.debug(`ZetoToken deployed: ${zeto.target}`);
 
   return { deployer, zeto, erc20 };
 }
@@ -67,7 +71,7 @@ export async function deployNonFungible(tokenName: string) {
   const zetoAddress = await proxy.getAddress();
   const zeto: any = await ethers.getContractAt(tokenName, zetoAddress);
 
-  console.log(`ZetoToken deployed: ${zeto.target}`);
+  logger.debug(`ZetoToken deployed: ${zeto.target}`);
 
   return { deployer, zeto };
 }
@@ -80,6 +84,6 @@ deploy(deployFungible, deployNonFungible)
     process.exit(0);
   })
   .catch((error) => {
-    console.error(error);
+    logger.error(error);
     process.exit(1);
   });

package/scripts/lib/zeto_libraries.ts

@@ -0,0 +1,47 @@
+// Copyright © 2025 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/** Hardhat library link map for Zeto token implementations. */
+export function withZetoLockableLib(
+  zetoLockableLib: { target: string },
+  extra: Record<string, string> = {},
+): Record<string, string> {
+  return {
+    ZetoLockableLib: zetoLockableLib.target,
+    ...extra,
+  };
+}
+
+export function smtLibraries(deps: {
+  smtLib: { target: string };
+  poseidon2: { target: string };
+  poseidon3: { target: string };
+  poseidon5?: { target: string };
+  poseidon6?: { target: string };
+}): Record<string, string> {
+  const libs: Record<string, string> = {
+    SmtLib: deps.smtLib.target,
+    PoseidonUnit2L: deps.poseidon2.target,
+    PoseidonUnit3L: deps.poseidon3.target,
+  };
+  if (deps.poseidon5) {
+    libs.PoseidonUnit5L = deps.poseidon5.target;
+  }
+  if (deps.poseidon6) {
+    libs.PoseidonUnit6L = deps.poseidon6.target;
+  }
+  return libs;
+}