@lfdecentralizedtrust/zeto-contracts 0.2.1 → 0.5.0

package/contracts/zeto_nf_anon.sol

@@ -15,155 +15,80 @@
 // limitations under the License.
 pragma solidity ^0.8.27;
 
-import {IZeto} from "./lib/interfaces/izeto.sol";
-import {Groth16Verifier_NfAnon} from "./verifiers/verifier_nf_anon.sol";
-import {ZetoBase} from "./lib/zeto_base.sol";
-import {Commonlib} from "./lib/common.sol";
-import {IZetoInitializable} from "./lib/interfaces/izeto_initializable.sol";
+import {ZetoNonFungibleBase} from "./lib/zeto_non_fungible_base.sol";
+import {Commonlib} from "./lib/common/common.sol";
+import {IZetoInitializable} from "./lib/interfaces/IZetoInitializable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 
-/// @title A sample implementation of a Zeto based non-fungible token with anonymity and no encryption
+/// @title A sample implementation of a Zeto based non-fungible token with
+///        anonymity (no encryption, no nullifier history masking).
 /// @author Kaleido, Inc.
+/// @notice Decimals: this token uses **4** decimals, inherited from
+///         {ZetoCommon.decimals}. NFT integrators rarely consult
+///         `decimals()` but it is preserved for ABI symmetry with the
+///         fungible siblings.
 /// @dev The proof has the following statements:
-///        - The sender owns the private key whose public key is part of the pre-image of the input UTXOs commitments
-///          (aka the sender is authorized to spend the input UTXOs)
-///        - The input UTXOs and output UTXOs are valid in terms of obeying mass conservation rules
-contract Zeto_NfAnon is IZeto, IZetoInitializable, ZetoBase, UUPSUpgradeable {
-    Groth16Verifier_NfAnon internal _verifier;
+///        - The sender owns the private key whose public key is part of the pre-image of the input UTXO commitment
+///        - The output UTXO commitment is well-formed
+///
+///      Single-input/single-output transfer. The lock lifecycle is
+///      intentionally omitted in this revival; see {ZetoNonFungible}.
+contract Zeto_NfAnon is ZetoNonFungibleBase, UUPSUpgradeable {
+    /// @dev Lock the implementation contract on construction.
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
 
     function initialize(
-        string memory name,
-        string memory symbol,
+        string calldata name,
+        string calldata symbol,
         address initialOwner,
         IZetoInitializable.VerifiersInfo calldata verifiers
     ) public initializer {
-        __ZetoBase_init(name, symbol, initialOwner);
-        _verifier = (Groth16Verifier_NfAnon)(verifiers.verifier);
+        __ZetoNonFungibleBase_init(name, symbol, initialOwner, verifiers);
     }
 
     function _authorizeUpgrade(address) internal override onlyOwner {}
 
-    /**
-     * @dev the main function of the contract.
-     *
-     * @param input The UTXO to be spent by the transaction.
-     * @param output The new UTXO to generate, for future transactions to spend.
-     * @param proof A zero knowledge proof that the submitter is authorized to spend the inputs, and
-     *      that the outputs are valid in terms of obeying mass conservation rules.
-     *
-     * Emits a {UTXOTransfer} event.
-     */
-    function transfer(
-        uint256 input,
-        uint256 output,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public returns (bool) {
-        uint256[] memory inputs = new uint256[](1);
-        inputs[0] = input;
-        uint256[] memory outputs = new uint256[](1);
-        outputs[0] = output;
-        uint256[] memory lockedOutputs;
-        validateTransactionProposal(inputs, outputs, lockedOutputs, false);
-
-        // construct the public inputs
-        uint256[2] memory publicInputs;
-        publicInputs[0] = input;
-        publicInputs[1] = output;
-
-        // Check the proof
-        require(
-            _verifier.verifyProof(proof.pA, proof.pB, proof.pC, publicInputs),
-            "Invalid proof"
-        );
-
-        processInputsAndOutputs(inputs, outputs, lockedOutputs, false);
-
-        emit UTXOTransfer(inputs, outputs, msg.sender, data);
-        return true;
-    }
-
-    /**
-     * @dev the main function of the contract.
-     *
-     * @param input The UTXO to be spent by the transaction.
-     * @param output The new UTXO to generate, for future transactions to spend.
-     * @param proof A zero knowledge proof that the submitter is authorized to spend the inputs, and
-     *      that the outputs are valid in terms of obeying mass conservation rules.
-     *
-     * Emits a {UTXOTransfer} event.
-     */
-    function transferLocked(
-        uint256 input,
-        uint256 output,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public returns (bool) {
-        uint256[] memory inputs = new uint256[](1);
-        inputs[0] = input;
-        uint256[] memory outputs = new uint256[](1);
-        outputs[0] = output;
-        uint256[] memory lockedOutputs;
-        validateTransactionProposal(inputs, outputs, lockedOutputs, true);
-
-        // construct the public inputs
-        uint256[2] memory publicInputs;
-        publicInputs[0] = input;
-        publicInputs[1] = output;
-
-        // Check the proof
-        require(
-            _verifier.verifyProof(proof.pA, proof.pB, proof.pC, publicInputs),
-            "Invalid proof"
+    /// @dev Public-inputs layout: [input, output]. `inputsLocked` is
+    ///      ignored because this token does not implement the lock
+    ///      lifecycle.
+    function constructPublicInputs(
+        uint256[] memory inputs,
+        uint256[] memory outputs,
+        bytes memory proof,
+        bool /* inputsLocked */
+    )
+        internal
+        pure
+        override
+        returns (uint256[] memory, Commonlib.Proof memory)
+    {
+        Commonlib.Proof memory proofStruct = abi.decode(
+            proof,
+            (Commonlib.Proof)
         );
+        uint256[] memory publicInputs = new uint256[](2);
+        publicInputs[0] = inputs[0];
+        publicInputs[1] = outputs[0];
 
-        processInputsAndOutputs(inputs, outputs, lockedOutputs, true);
-
-        emit UTXOTransfer(inputs, outputs, msg.sender, data);
-        return true;
+        return (publicInputs, proofStruct);
     }
+}
 
-    function mint(uint256[] memory utxos, bytes calldata data) public {
-        _mint(utxos, data);
+/// @dev ERC-7201 (`erc7201:zeto.storage.Zeto_NfAnon`).
+library Zeto_NfAnonStorage {
+    struct Layout {
+        uint256 __reserved;
     }
 
-    function lock(
-        uint256 input,
-        uint256 lockedOutput,
-        Commonlib.Proof calldata proof,
-        address delegate,
-        bytes calldata data
-    ) public {
-        uint256[] memory inputs = new uint256[](1);
-        inputs[0] = input;
-        uint256[] memory outputs;
-        uint256[] memory lockedOutputs = new uint256[](1);
-        lockedOutputs[0] = lockedOutput;
-        validateTransactionProposal(inputs, outputs, lockedOutputs, false);
-
-        // construct the public inputs
-        uint256[2] memory publicInputs;
-        publicInputs[0] = input;
-        publicInputs[1] = lockedOutput;
-
-        // Check the proof
-        require(
-            _verifier.verifyProof(proof.pA, proof.pB, proof.pC, publicInputs),
-            "Invalid proof"
-        );
-
-        processInputsAndOutputs(inputs, outputs, lockedOutputs, false);
-
-        // lock the intended outputs
-        _lock(inputs, outputs, lockedOutputs, delegate, data);
-    }
+    bytes32 private constant STORAGE_LOCATION =
+        0xafcd749646d899cf78964151db8f542448d05467330245e10728559327401500;
 
-    function unlock(
-        uint256 input,
-        uint256 output,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public {
-        transferLocked(input, output, proof, data);
+    function layout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_LOCATION
+        }
     }
 }

package/contracts/zeto_nf_anon_nullifier.sol

@@ -15,177 +15,115 @@
 // limitations under the License.
 pragma solidity ^0.8.27;
 
-import {IZeto} from "./lib/interfaces/izeto.sol";
-import {Groth16Verifier_NfAnonNullifierTransfer} from "./verifiers/verifier_nf_anon_nullifier_transfer.sol";
-import {Groth16Verifier_NfAnonNullifierTransferLocked} from "./verifiers/verifier_nf_anon_nullifier_transferLocked.sol";
-import {ZetoNullifier} from "./lib/zeto_nullifier.sol";
-import {Commonlib} from "./lib/common.sol";
-import {IZetoInitializable} from "./lib/interfaces/izeto_initializable.sol";
+import {ZetoNonFungibleNullifier} from "./lib/zeto_non_fungible_nullifier.sol";
+import {Commonlib} from "./lib/common/common.sol";
+import {IZetoInitializable} from "./lib/interfaces/IZetoInitializable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 
-/// @title A sample implementation of a Zeto based non-fungible token with anonymity and history masking
+/// @title A sample implementation of a Zeto based non-fungible token with
+///        anonymity and history masking via nullifiers.
 /// @author Kaleido, Inc.
+/// @notice Decimals: this token uses **4** decimals, inherited from
+///         {ZetoCommon.decimals}. NFT integrators rarely consult
+///         `decimals()` but it is preserved for ABI symmetry with the
+///         fungible siblings.
 /// @dev The proof has the following statements:
-///        - each value in the output commitments must be a positive number in the range 0 ~ (2\*\*40 - 1)
-///        - the sum of the nullified values match the sum of output values
-///        - the hashes in the input and output match the hash(value, salt, owner public key) formula
-///        - the sender possesses the private BabyJubjub key, whose public key is part of the pre-image of the input commitment hashes, which match the corresponding nullifiers
-///        - the nullifiers represent input commitments that are included in a Sparse Merkle Tree represented by the root hash
-contract Zeto_NfAnonNullifier is
-    IZeto,
-    IZetoInitializable,
-    ZetoNullifier,
-    UUPSUpgradeable
-{
-    Groth16Verifier_NfAnonNullifierTransfer _verifier;
-    Groth16Verifier_NfAnonNullifierTransferLocked _lockVerifier;
+///        - The sender owns the private key whose public key is part of the pre-image of the input UTXO commitment
+///          (which corresponds to the nullifier).
+///        - The nullifier represents an input commitment included in a Sparse Merkle Tree represented by the root hash.
+///        - The output UTXO commitment is well-formed.
+///
+///      Two public-inputs layouts are produced depending on whether the
+///      transition is consuming an unlocked input (a nullifier proven
+///      against the unlocked-commitments SMT) or a locked input (a raw
+///      UTXO hash whose locked status is verified by the storage layer
+///      itself):
+///        - unlocked: `[nullifier, root, output]` -> verified by
+///          {Groth16Verifier_NfAnonNullifierTransfer}.
+///        - locked:   `[input, output]`           -> verified by the
+///          simpler {Groth16Verifier_NfAnon}.
+///      This mirrors how {Zeto_AnonNullifier} reuses the non-nullifier
+///      verifier for its lock path. The locked branch does not require
+///      a Merkle inclusion proof because the contract has already
+///      validated the input via {NullifierStorage.validateInputs} (it
+///      defers to {BaseStorage.validateInputs} when `inputsLocked`).
+contract Zeto_NfAnonNullifier is ZetoNonFungibleNullifier, UUPSUpgradeable {
+    /// @dev Lock the implementation contract on construction.
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
 
     function initialize(
-        string memory name,
-        string memory symbol,
+        string calldata name,
+        string calldata symbol,
         address initialOwner,
         IZetoInitializable.VerifiersInfo calldata verifiers
     ) public initializer {
-        __ZetoNullifier_init(name, symbol, initialOwner);
-        _verifier = (Groth16Verifier_NfAnonNullifierTransfer)(
-            verifiers.verifier
-        );
-        _lockVerifier = (Groth16Verifier_NfAnonNullifierTransferLocked)(
-            verifiers.lockVerifier
-        );
+        __ZetoNonFungibleNullifier_init(name, symbol, initialOwner, verifiers);
     }
 
     function _authorizeUpgrade(address) internal override onlyOwner {}
 
-    /**
-     * @dev the main function of the contract.
-     *
-     * @param nullifier A nullifier that are secretly bound to the UTXO to be spent by the transaction.
-     * @param output new UTXO to generate, for future transactions to spend.
-     * @param root The root hash of the Sparse Merkle Tree that contains the nullifier.
-     * @param proof A zero knowledge proof that the submitter is authorized to spend the inputs, and
-     *      that the outputs are valid in terms of obeying mass conservation rules.
-     *
-     * Emits a {UTXOTransfer} event.
-     */
-    function transfer(
-        uint256 nullifier,
-        uint256 output,
-        uint256 root,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public returns (bool) {
-        uint256[] memory nullifiers = new uint256[](1);
-        nullifiers[0] = nullifier;
-        uint256[] memory outputs = new uint256[](1);
-        outputs[0] = output;
-        validateTransactionProposal(nullifiers, outputs, root, false);
-        checkProof(nullifiers, outputs, root, proof);
-        uint256[] memory empty;
-        processInputsAndOutputs(nullifiers, outputs, empty, address(0));
-
-        emit UTXOTransfer(nullifiers, outputs, msg.sender, data);
-        return true;
-    }
-
-    /**
-     * @dev the main function of the contract.
-     *
-     * @param nullifier A nullifier that are secretly bound to the UTXO to be spent by the transaction.
-     * @param output new UTXO to generate, for future transactions to spend.
-     * @param root The root hash of the Sparse Merkle Tree that contains the nullifier.
-     * @param proof A zero knowledge proof that the submitter is authorized to spend the inputs, and
-     *      that the outputs are valid in terms of obeying mass conservation rules.
-     *
-     * Emits a {UTXOTransfer} event.
-     */
-    function transferLocked(
-        uint256 nullifier,
-        uint256 output,
-        uint256 root,
-        Commonlib.Proof calldata proof,
-        bytes calldata data
-    ) public returns (bool) {
-        uint256[] memory nullifiers = new uint256[](1);
-        nullifiers[0] = nullifier;
-        uint256[] memory outputs = new uint256[](1);
-        outputs[0] = output;
-        validateTransactionProposal(nullifiers, outputs, root, true);
-        checkProofLocked(nullifiers, outputs, root, proof);
-        uint256[] memory empty;
-        processInputsAndOutputs(nullifiers, outputs, empty, address(0));
-
-        emit UTXOTransfer(nullifiers, outputs, msg.sender, data);
-        return true;
-    }
-
-    function mint(uint256[] memory utxos, bytes calldata data) public {
-        _mint(utxos, data);
-    }
-
-    function lock(
-        uint256 nullifier,
-        uint256 lockedOutput,
-        uint256 root,
-        Commonlib.Proof calldata proof,
-        address delegate,
-        bytes calldata data
-    ) public {
-        uint256[] memory nullifiers = new uint256[](1);
-        nullifiers[0] = nullifier;
-        uint256[] memory lockedOutputs = new uint256[](1);
-        lockedOutputs[0] = lockedOutput;
-        validateTransactionProposal(nullifiers, lockedOutputs, root, false);
-        checkProof(nullifiers, lockedOutputs, root, proof);
-
-        processNullifiers(nullifiers);
-
-        // lock the intended outputs
-        uint256[] memory outputs;
-        _lock(nullifiers, outputs, lockedOutputs, delegate, data);
-    }
-
-    function checkProof(
-        uint256[] memory nullifiers,
+    /// @dev Public-inputs layout depends on `inputsLocked`:
+    ///        - !inputsLocked: `[nullifier, root, output]` paired with the
+    ///          `nf_anon_nullifier_transfer` circuit. The proof carries
+    ///          `(uint256 root, Commonlib.Proof)`; the root is decoded
+    ///          and validated here so that `validateTransactionProposal`
+    ///          does not need to pre-decode the proof.
+    ///        - inputsLocked:  `[input, output]` paired with the simpler
+    ///          `nf_anon` circuit. No root: the storage layer has
+    ///          already verified the input is in `_lockedUtxos`, so we
+    ///          do not re-prove inclusion in a locked-SMT. The proof
+    ///          payload is just `Commonlib.Proof`.
+    function constructPublicInputs(
+        uint256[] memory inputs,
         uint256[] memory outputs,
-        uint256 root,
-        Commonlib.Proof calldata proof
-    ) internal view {
-        // construct the public inputs
-        uint256[3] memory publicInputs;
-        publicInputs[0] = nullifiers[0];
+        bytes memory proof,
+        bool inputsLocked
+    )
+        internal
+        view
+        override
+        returns (uint256[] memory, Commonlib.Proof memory)
+    {
+        if (inputsLocked) {
+            Commonlib.Proof memory proofStruct = abi.decode(
+                proof,
+                (Commonlib.Proof)
+            );
+            uint256[] memory publicInputs = new uint256[](2);
+            publicInputs[0] = inputs[0];
+            publicInputs[1] = outputs[0];
+            return (publicInputs, proofStruct);
+        }
+
+        (uint256 root, Commonlib.Proof memory proofStruct) = abi.decode(
+            proof,
+            (uint256, Commonlib.Proof)
+        );
+        validateRoot(root);
+
+        uint256[] memory publicInputs = new uint256[](3);
+        publicInputs[0] = inputs[0];
         publicInputs[1] = root;
         publicInputs[2] = outputs[0];
+        return (publicInputs, proofStruct);
+    }
+}
 
-        // Check the proof
-        require(
-            _verifier.verifyProof(proof.pA, proof.pB, proof.pC, publicInputs),
-            "Invalid proof"
-        );
+/// @dev ERC-7201 (`erc7201:zeto.storage.Zeto_NfAnonNullifier`).
+library Zeto_NfAnonNullifierStorage {
+    struct Layout {
+        uint256 __reserved;
     }
 
-    function checkProofLocked(
-        uint256[] memory nullifiers,
-        uint256[] memory outputs,
-        uint256 root,
-        Commonlib.Proof calldata proof
-    ) internal view {
-        // construct the public inputs
-        uint256[4] memory publicInputs;
-        publicInputs[0] = nullifiers[0];
-        publicInputs[1] = uint256(uint160(msg.sender));
-        publicInputs[2] = root;
-        publicInputs[3] = outputs[0];
+    bytes32 private constant STORAGE_LOCATION =
+        0xb42e743e63c75bf1f2c05ab181e1371afad8f4114706ec6cfc12171a24893700;
 
-        // Check the proof
-        require(
-            _lockVerifier.verifyProof(
-                proof.pA,
-                proof.pB,
-                proof.pC,
-                publicInputs
-            ),
-            "Invalid proof"
-        );
+    function layout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_LOCATION
+        }
     }
 }

package/hardhat.config.ts

@@ -20,8 +20,8 @@ import "@openzeppelin/hardhat-upgrades";
 import crypto from "crypto";
 
 const keys = [
-  crypto.randomBytes(32).toString("hex"),
-  crypto.randomBytes(32).toString("hex"),
+  process.env.ETH_PRIVATE_KEY_1 || crypto.randomBytes(32).toString("hex"),
+  process.env.ETH_PRIVATE_KEY_2 || crypto.randomBytes(32).toString("hex"),
   crypto.randomBytes(32).toString("hex"),
   crypto.randomBytes(32).toString("hex"),
   crypto.randomBytes(32).toString("hex"),
@@ -41,14 +41,20 @@ const config: HardhatUserConfig = {
     settings: {
       optimizer: {
         enabled: true,
-        runs: 1000,
+        runs: 25,
       },
+      viaIR: true,
     },
   },
   paths: {
     sources: "contracts"
   },
   networks: {
+    hardhat: {
+      // a small number of verifiers are bigger than the default 24576 bytes
+      // so we need to allow unlimited contract size to avoid test errors
+      allowUnlimitedContractSize: true,
+    },
     besu: {
       url: "http://localhost:8545",
       accounts: keys,

package/ignition/modules/lib/deps.ts

@@ -23,12 +23,7 @@ export const SmtLibModule = buildModule("SmtLib", (m) => {
   const poseidon3 = m.library("Poseidon3", PoseidonArtifact(3));
   const poseidon5 = m.library("Poseidon5", PoseidonArtifact(5));
   const poseidon6 = m.library("Poseidon6", PoseidonArtifact(6));
-  const smtLib = m.contract("SmtLib", [], {
-    libraries: {
-      PoseidonUnit2L: poseidon2,
-      PoseidonUnit3L: poseidon3,
-    },
-  });
+  const smtLib = m.contract("SmtLib", []);
   return { smtLib, poseidon2, poseidon3, poseidon5, poseidon6 };
 });
 
@@ -40,6 +35,14 @@ export const DepositVerifierModule = buildModule(
   },
 );
 
+export const DepositKycVerifierModule = buildModule(
+  "Groth16Verifier_DepositKyc",
+  (m) => {
+    const verifier = m.contract("Groth16Verifier_DepositKyc", []);
+    return { verifier };
+  },
+);
+
 export const WithdrawNullifierVerifierModule = buildModule(
   "Groth16Verifier_WithdrawNullifier",
   (m) => {

package/ignition/modules/zeto_anon_burnable.ts

@@ -36,10 +36,13 @@ const BurnVerifierModule = buildModule("Groth16Verifier_Burn", (m) => {
   return { verifier };
 });
 
-const BatchBurnVerifierModule = buildModule("Groth16Verifier_BurnBatch", (m) => {
-  const verifier = m.contract("Groth16Verifier_BurnBatch", []);
-  return { verifier };
-});
+const BatchBurnVerifierModule = buildModule(
+  "Groth16Verifier_BurnBatch",
+  (m) => {
+    const verifier = m.contract("Groth16Verifier_BurnBatch", []);
+    return { verifier };
+  },
+);
 
 export default buildModule("Zeto_AnonBurnable", (m) => {
   const { verifier } = m.useModule(VerifierModule);
@@ -50,9 +53,7 @@ export default buildModule("Zeto_AnonBurnable", (m) => {
     BatchWithdrawVerifierModule,
   );
   const { verifier: burnVerifier } = m.useModule(BurnVerifierModule);
-  const { verifier: batchBurnVerifier } = m.useModule(
-    BatchBurnVerifierModule,
-  );
+  const { verifier: batchBurnVerifier } = m.useModule(BatchBurnVerifierModule);
   return {
     depositVerifier,
     withdrawVerifier,

package/ignition/modules/zeto_anon_enc_nullifier.ts

@@ -35,10 +35,39 @@ 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 { 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);
+  const { verifier: batchLockVerifier } = m.useModule(BatchLockVerifierModule);
   const { verifier: depositVerifier } = m.useModule(DepositVerifierModule);
   const { verifier: withdrawVerifier } = m.useModule(
     WithdrawNullifierVerifierModule,
@@ -51,9 +80,12 @@ export default buildModule("Zeto_AnonEncNullifier", (m) => {
     depositVerifier,
     withdrawVerifier,
     verifier,
+    lockVerifier,
     batchVerifier,
+    batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   };
 });

package/ignition/modules/zeto_anon_enc_nullifier_kyc.ts

@@ -17,7 +17,7 @@
 import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
 import {
   SmtLibModule,
-  DepositVerifierModule,
+  DepositKycVerifierModule,
   WithdrawNullifierVerifierModule,
   BatchWithdrawNullifierVerifierModule,
 } from "./lib/deps";
@@ -42,7 +42,7 @@ export default buildModule("Zeto_AnonEncNullifierKyc", (m) => {
   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,
   );

package/ignition/modules/zeto_anon_enc_nullifier_non_repudiation.ts

@@ -45,7 +45,7 @@ const BatchVerifierModule = buildModule(
 );
 
 export default buildModule("Zeto_AnonEncNullifierNonRepudiation", (m) => {
-  const { smtLib, poseidon3 } = m.useModule(SmtLibModule);
+  const { smtLib, poseidon2, poseidon3 } = m.useModule(SmtLibModule);
   const { verifier } = m.useModule(VerifierModule);
   const { verifier: batchVerifier } = m.useModule(BatchVerifierModule);
   const { verifier: depositVerifier } = m.useModule(DepositVerifierModule);
@@ -62,6 +62,7 @@ export default buildModule("Zeto_AnonEncNullifierNonRepudiation", (m) => {
     batchVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   };
 });