@lfdecentralizedtrust/zeto-contracts 0.2.1 → 0.5.0

package/ignition/modules/zeto_anon_nullifier.ts

@@ -30,11 +30,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 +72,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,7 +88,7 @@ const BatchLockVerifierModule = buildModule(
 );
 
 export default buildModule("Zeto_AnonNullifier", (m) => {
-  const { smtLib, poseidon3 } = m.useModule(SmtLibModule);
+  const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
   const { verifier: batchVerifier } = m.useModule(BatchVerifierModule);
@@ -86,6 +110,7 @@ export default buildModule("Zeto_AnonNullifier", (m) => {
     batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   };
 });

package/ignition/modules/zeto_anon_nullifier_burnable.ts

@@ -30,11 +30,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,31 +64,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 { smtLib, poseidon3 } = m.useModule(SmtLibModule);
+  const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
   const { verifier: batchVerifier } = m.useModule(BatchVerifierModule);
@@ -80,9 +116,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,
   );
@@ -98,6 +132,7 @@ export default buildModule("Zeto_AnonNullifier", (m) => {
     burnVerifier,
     batchBurnVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   };
 });

package/ignition/modules/zeto_anon_nullifier_kyc.ts

@@ -17,33 +17,48 @@
 import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
 import {
   SmtLibModule,
-  DepositVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
+  DepositKycVerifierModule,
 } 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 };
   },
 );
@@ -54,7 +69,7 @@ export default buildModule("Zeto_AnonNullifierKyc", (m) => {
   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,
   );

package/ignition/modules/zeto_anon_nullifier_qurrency.ts

@@ -64,7 +64,7 @@ const BatchVerifierModule = buildModule(
 // );
 
 export default buildModule("Zeto_AnonNullifierQurrency", (m) => {
-  const { smtLib, poseidon3, poseidon5, poseidon6 } = m.useModule(SmtLibModule);
+  const { smtLib, poseidon2, poseidon3, poseidon5, poseidon6 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   // const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
   const { verifier: batchVerifier } = m.useModule(BatchVerifierModule);
@@ -86,6 +86,7 @@ export default buildModule("Zeto_AnonNullifierQurrency", (m) => {
     // batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
     poseidon5,
     poseidon6,

package/ignition/modules/zeto_nf_anon_nullifier.ts

@@ -25,21 +25,25 @@ 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 { smtLib, poseidon3 } = m.useModule(SmtLibModule);
+  const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: lockVerifier } = m.useModule(LockVerifierModule);
 
-  return { verifier, lockVerifier, smtLib, poseidon3 };
+  return { verifier, lockVerifier, smtLib, poseidon2, poseidon3 };
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lfdecentralizedtrust/zeto-contracts",
-  "version": "0.2.1",
+  "version": "0.5.0",
   "description": "Zero knowledge proof based UTXO tokens toolkit for fungible or non-fungible assets",
   "main": "index.js",
   "scripts": {
@@ -22,12 +22,14 @@
     "@nomicfoundation/hardhat-toolbox": "^5.0.0",
     "circomlibjs": "^0.1.7",
     "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": "^2.5.0",
+    "@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/tokens/Zeto_Anon.ts

@@ -39,11 +39,11 @@ export async function deployDependencies() {
         withdrawVerifier: withdrawVerifier.target,
         batchVerifier: batchVerifier.target,
         batchWithdrawVerifier: batchWithdrawVerifier.target,
-        lockVerifier: "0x0000000000000000000000000000000000000000",
-        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: verifier.target, // for this token, the lock verifier is the same as the regular verifier
+        batchLockVerifier: batchVerifier.target,
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
   };
 }

package/scripts/tokens/Zeto_AnonBurnable.ts

@@ -45,7 +45,7 @@ export async function deployDependencies() {
         batchBurnVerifier: batchBurnVerifier.target,
         lockVerifier: "0x0000000000000000000000000000000000000000",
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
   };
 }

package/scripts/tokens/Zeto_AnonEnc.ts

@@ -39,11 +39,20 @@ export async function deployDependencies() {
         withdrawVerifier: withdrawVerifier.target,
         batchVerifier: batchVerifier.target,
         batchWithdrawVerifier: batchWithdrawVerifier.target,
-        lockVerifier: "0x0000000000000000000000000000000000000000",
-        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        // Same rationale as `Zeto_Anon`: the encryption-aware
+        // {Zeto_AnonEnc.constructPublicInputs} ignores `inputsLocked`
+        // and emits an identical public-input layout (ecdhPublicKey ++
+        // encryptedValues ++ inputs ++ outputs ++ encryptionNonce) for
+        // both the regular `transfer` flow and the locked-input flow
+        // driven by `spendLock`/`cancelLock`. We therefore wire the
+        // lockVerifier slots to the same Groth16 verifier as the
+        // unlocked path so {ZetoCommon.verifyProof} routes locked-input
+        // proofs to the encryption circuit's verifier.
+        lockVerifier: verifier.target,
+        batchLockVerifier: batchVerifier.target,
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
   };
 }

package/scripts/tokens/Zeto_AnonEncNullifier.ts

@@ -24,9 +24,12 @@ export async function deployDependencies() {
     depositVerifier,
     withdrawVerifier,
     verifier,
+    lockVerifier,
     batchVerifier,
+    batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   } = await ignition.deploy(zetoModule);
   return {
@@ -41,14 +44,15 @@ export async function deployDependencies() {
         withdrawVerifier: withdrawVerifier.target,
         batchVerifier: batchVerifier.target,
         batchWithdrawVerifier: batchWithdrawVerifier.target,
-        lockVerifier: "0x0000000000000000000000000000000000000000",
-        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: lockVerifier.target,
+        batchLockVerifier: batchLockVerifier.target,
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
     },
   };

package/scripts/tokens/Zeto_AnonEncNullifierKyc.ts

@@ -46,7 +46,7 @@ export async function deployDependencies() {
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
     libraries: {
       SmtLib: smtLib.target,

package/scripts/tokens/Zeto_AnonEncNullifierNonRepudiation.ts

@@ -27,6 +27,7 @@ export async function deployDependencies() {
     batchVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   } = await ignition.deploy(zetoModule);
   return {
@@ -45,10 +46,11 @@ export async function deployDependencies() {
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
     },
   };

package/scripts/tokens/Zeto_AnonNullifier.ts

@@ -29,6 +29,7 @@ export async function deployDependencies() {
     batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   } = await ignition.deploy(zetoModule);
   return {
@@ -47,10 +48,11 @@ export async function deployDependencies() {
         batchLockVerifier: batchLockVerifier.target,
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
     },
   };

package/scripts/tokens/Zeto_AnonNullifierBurnable.ts

@@ -31,6 +31,7 @@ export async function deployDependencies() {
     burnVerifier,
     batchBurnVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   } = await ignition.deploy(zetoModule);
   return {
@@ -49,10 +50,11 @@ export async function deployDependencies() {
         batchLockVerifier: batchLockVerifier.target,
         burnVerifier: burnVerifier.target,
         batchBurnVerifier: batchBurnVerifier.target,
-      }
+      },
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
     },
   };

package/scripts/tokens/Zeto_AnonNullifierKyc.ts

@@ -48,7 +48,7 @@ export async function deployDependencies() {
         batchLockVerifier: batchLockVerifier.target,
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
     libraries: {
       SmtLib: smtLib.target,

package/scripts/tokens/Zeto_AnonNullifierQurrency.ts

@@ -29,6 +29,7 @@ export async function deployDependencies() {
     // batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
     poseidon5,
     poseidon6,
@@ -49,10 +50,11 @@ export async function deployDependencies() {
         batchLockVerifier: "0x0000000000000000000000000000000000000000", //batchLockVerifier.target,
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
       PoseidonUnit5L: poseidon5.target,
       PoseidonUnit6L: poseidon6.target,

package/scripts/tokens/Zeto_NfAnon.ts

@@ -33,11 +33,11 @@ export async function deployDependencies() {
         withdrawVerifier: "0x0000000000000000000000000000000000000000",
         batchVerifier: "0x0000000000000000000000000000000000000000",
         batchWithdrawVerifier: "0x0000000000000000000000000000000000000000",
-        lockVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: verifier.target, // for this token, the lock verifier is the same as the regular verifier
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
   };
 }