@lfdecentralizedtrust/zeto-contracts 0.2.1 → 0.2.2

package/contracts/factory_upgradeable.sol

@@ -0,0 +1,156 @@
+// Copyright © 2026 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.
+pragma solidity ^0.8.27;
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
+import {IZetoInitializable} from "./lib/interfaces/izeto_initializable.sol";
+
+contract ZetoTokenFactoryUpgradeable is Initializable, OwnableUpgradeable, UUPSUpgradeable {
+    // all the addresses needed by the factory to
+    // clone a Zeto token and initialize it. The
+    // "implementation" is used to clone the token,
+    // the rest of the addresses are used to initialize
+    struct ImplementationInfo {
+        address implementation;
+        IZetoInitializable.VerifiersInfo verifiers;
+    }
+
+    /// @custom:storage-location erc7201:zeto.storage.ZetoTokenFactory
+    struct ZetoTokenFactoryStorage {
+        mapping(string => ImplementationInfo) implementations;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("zeto.storage.ZetoTokenFactory")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant ZETO_TOKEN_FACTORY_STORAGE_LOCATION =
+        0xea00970f7a43a8afae26fee4308a7f177a9692a756b610fca8a1c058954e4800;
+
+    event ZetoTokenDeployed(address indexed zetoToken);
+
+    function _getZetoTokenFactoryStorage()
+        private
+        pure
+        returns (ZetoTokenFactoryStorage storage $)
+    {
+        assembly {
+            $.slot := ZETO_TOKEN_FACTORY_STORAGE_LOCATION
+        }
+    }
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize() public virtual initializer {
+        __Ownable_init(_msgSender());
+        __UUPSUpgradeable_init();
+    }
+
+    function registerImplementation(
+        string memory name,
+        ImplementationInfo memory implementation
+    ) public onlyOwner {
+        require(
+            implementation.implementation != address(0),
+            "Factory: implementation address is required"
+        );
+        require(
+            implementation.verifiers.verifier != address(0),
+            "Factory: verifier address is required"
+        );
+        // the depositVerifier and withdrawVerifier are optional
+        // for the non-fungible token implementations
+        ZetoTokenFactoryStorage storage $ = _getZetoTokenFactoryStorage();
+        $.implementations[name] = implementation;
+    }
+
+    function deployZetoFungibleToken(
+        string memory name,
+        string memory symbol,
+        string memory tokenImplementation,
+        address initialOwner
+    ) public returns (address) {
+        ZetoTokenFactoryStorage storage $ = _getZetoTokenFactoryStorage();
+        ImplementationInfo memory args = $.implementations[tokenImplementation];
+        require(
+            args.implementation != address(0),
+            "Factory: failed to find implementation"
+        );
+        // check that the registered implementation is for a fungible token
+        // and has the required verifier addresses
+        require(
+            args.verifiers.depositVerifier != address(0),
+            "Factory: depositVerifier address is required"
+        );
+        require(
+            args.verifiers.withdrawVerifier != address(0),
+            "Factory: withdrawVerifier address is required"
+        );
+        require(
+            args.verifiers.batchVerifier != address(0),
+            "Factory: batchVerifier address is required"
+        );
+        require(
+            args.verifiers.batchWithdrawVerifier != address(0),
+            "Factory: batchWithdrawVerifier address is required"
+        );
+        address instance = Clones.clone(args.implementation);
+        require(
+            instance != address(0),
+            "Factory: failed to clone implementation"
+        );
+        (IZetoInitializable(instance)).initialize(
+            name,
+            symbol,
+            initialOwner,
+            args.verifiers
+        );
+        emit ZetoTokenDeployed(instance);
+        return instance;
+    }
+
+    function deployZetoNonFungibleToken(
+        string memory name,
+        string memory symbol,
+        string memory tokenImplementation,
+        address initialOwner
+    ) public returns (address) {
+        ZetoTokenFactoryStorage storage $ = _getZetoTokenFactoryStorage();
+        ImplementationInfo memory args = $.implementations[tokenImplementation];
+        require(
+            args.implementation != address(0),
+            "Factory: failed to find implementation"
+        );
+        address instance = Clones.clone(args.implementation);
+        require(
+            instance != address(0),
+            "Factory: failed to clone implementation"
+        );
+        (IZetoInitializable(instance)).initialize(
+            name,
+            symbol,
+            initialOwner,
+            args.verifiers
+        );
+        emit ZetoTokenDeployed(instance);
+        return instance;
+    }
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+}

package/contracts/lib/registry.sol

@@ -16,8 +16,9 @@
 pragma solidity ^0.8.27;
 
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import {SmtLib} from "@iden3/contracts/lib/SmtLib.sol";
-import {PoseidonUnit2L, PoseidonUnit3L} from "@iden3/contracts/lib/Poseidon.sol";
+import {SmtLib} from "@iden3/contracts/contracts/lib/SmtLib.sol";
+import {PoseidonHasher} from "@iden3/contracts/contracts/lib/hash/PoseidonHasher.sol";
+import {PoseidonUnit2L, PoseidonUnit3L} from "@iden3/contracts/contracts/lib/Poseidon.sol";
 import {Commonlib} from "./common.sol";
 import {IZeto} from "./interfaces/izeto.sol";
 import {IZetoKyc} from "./interfaces/izeto_kyc.sol";
@@ -38,6 +39,7 @@ abstract contract Registry is OwnableUpgradeable, IZetoKyc {
 
     function __Registry_init() internal onlyInitializing {
         _publicKeysTree.initialize(MAX_SMT_DEPTH);
+        _publicKeysTree.setHasher(new PoseidonHasher());
     }
 
     function register(

package/contracts/lib/zeto_nullifier.sol

@@ -20,8 +20,10 @@ import {IZeto} from "./interfaces/izeto.sol";
 import {MAX_SMT_DEPTH} from "./interfaces/izeto.sol";
 import {IZetoLockable} from "./interfaces/izeto_lockable.sol";
 import {ZetoCommon} from "./zeto_common.sol";
-import {SmtLib} from "@iden3/contracts/lib/SmtLib.sol";
-import {PoseidonUnit3L} from "@iden3/contracts/lib/Poseidon.sol";
+import {SmtLib} from "@iden3/contracts/contracts/lib/SmtLib.sol";
+import {PoseidonHasher} from "@iden3/contracts/contracts/lib/hash/PoseidonHasher.sol";
+import {IHasher} from "@iden3/contracts/contracts/interfaces/IHasher.sol";
+import {PoseidonUnit3L} from "@iden3/contracts/contracts/lib/Poseidon.sol";
 import {console} from "hardhat/console.sol";
 
 /// @title A sample base implementation of a Zeto based token contract with nullifiers
@@ -38,6 +40,7 @@ abstract contract ZetoNullifier is IZeto, IZetoLockable, ZetoCommon {
     SmtLib.Data internal _lockedCommitmentsTree;
     using SmtLib for SmtLib.Data;
     mapping(uint256 => bool) private _nullifiers;
+    IHasher private _hasher;
 
     error UTXORootNotFound(uint256 root);
 
@@ -49,6 +52,9 @@ abstract contract ZetoNullifier is IZeto, IZetoLockable, ZetoCommon {
         __ZetoCommon_init(name_, symbol_, initialOwner);
         _commitmentsTree.initialize(MAX_SMT_DEPTH);
         _lockedCommitmentsTree.initialize(MAX_SMT_DEPTH);
+        _hasher = new PoseidonHasher();
+        _commitmentsTree.setHasher(_hasher);
+        _lockedCommitmentsTree.setHasher(_hasher);
     }
 
     function validateTransactionProposal(

package/contracts/test/smt.sol

@@ -15,8 +15,8 @@
 // limitations under the License.
 pragma solidity ^0.8.27;
 
-import {SmtLib} from "@iden3/contracts/lib/SmtLib.sol";
-import {PoseidonUnit3L} from "@iden3/contracts/lib/Poseidon.sol";
+import {SmtLib} from "@iden3/contracts/contracts/lib/SmtLib.sol";
+import {PoseidonUnit3L} from "@iden3/contracts/contracts/lib/Poseidon.sol";
 
 // test ground for better understanding of the SmtLib library implementation
 contract TestSmt {

package/contracts/zeto_anon_nullifier_qurrency.sol

@@ -15,7 +15,7 @@
 // limitations under the License.
 pragma solidity ^0.8.27;
 
-import {PoseidonUnit5L} from "@iden3/contracts/lib/Poseidon.sol";
+import {PoseidonUnit5L} from "@iden3/contracts/contracts/lib/Poseidon.sol";
 import {IZeto} from "./lib/interfaces/izeto.sol";
 import {MAX_BATCH} from "./lib/interfaces/izeto.sol";
 import {Groth16Verifier_Deposit} from "./verifiers/verifier_deposit.sol";
@@ -35,6 +35,7 @@ import {console} from "hardhat/console.sol";
 uint256 constant INPUT_SIZE = 9;
 // uint256 constant INPUT_SIZE_LOCKED = 8;
 uint256 constant BATCH_INPUT_SIZE = 33;
+
 // uint256 constant BATCH_INPUT_SIZE_LOCKED = 32;
 
 /// @title A sample implementation of a Zeto based fungible token with anonymity and history masking
@@ -54,6 +55,7 @@ contract Zeto_AnonNullifierQurrency is
 {
     Groth16Verifier_AnonNullifierQurrencyTransfer internal _verifier;
     Groth16Verifier_AnonNullifierQurrencyTransferBatch internal _batchVerifier;
+
     // Groth16Verifier_AnonNullifierTransferLocked internal _lockVerifier;
     // Groth16Verifier_AnonNullifierTransferLockedBatch
     //     internal _batchLockVerifier;

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 };
 });
 

package/ignition/modules/zeto_anon_enc_nullifier.ts

@@ -36,7 +36,7 @@ const BatchVerifierModule = buildModule(
 );
 
 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: batchVerifier } = m.useModule(BatchVerifierModule);
   const { verifier: depositVerifier } = m.useModule(DepositVerifierModule);
@@ -54,6 +54,7 @@ export default buildModule("Zeto_AnonEncNullifier", (m) => {
     batchVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   };
 });

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,
   };
 });

package/ignition/modules/zeto_anon_nullifier.ts

@@ -64,7 +64,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 +86,7 @@ export default buildModule("Zeto_AnonNullifier", (m) => {
     batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   };
 });

package/ignition/modules/zeto_anon_nullifier_burnable.ts

@@ -68,7 +68,7 @@ const BatchBurnNullifierVerifierModule = buildModule("Groth16Verifier_BurnNullif
 });
 
 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);
@@ -98,6 +98,7 @@ export default buildModule("Zeto_AnonNullifier", (m) => {
     burnVerifier,
     batchBurnVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   };
 });

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

@@ -37,9 +37,9 @@ const LockVerifierModule = buildModule(
 );
 
 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.2.2",
   "description": "Zero knowledge proof based UTXO tokens toolkit for fungible or non-fungible assets",
   "main": "index.js",
   "scripts": {
@@ -27,7 +27,7 @@
     "zeto-js": "file:../zkp/js"
   },
   "dependencies": {
-    "@iden3/contracts": "^2.5.0",
+    "@iden3/contracts": "git+https://github.com/kaleido-io/contracts.git#keccak256",
     "@openzeppelin/contracts": "^5.1.0",
     "@openzeppelin/contracts-upgradeable": "^5.0.2",
     "@openzeppelin/hardhat-upgrades": "^3.2.1",

package/scripts/tokens/Zeto_AnonEncNullifier.ts

@@ -27,6 +27,7 @@ export async function deployDependencies() {
     batchVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
   } = await ignition.deploy(zetoModule);
   return {
@@ -49,6 +50,7 @@ export async function deployDependencies() {
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.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 {
@@ -49,6 +50,7 @@ export async function deployDependencies() {
     ],
     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 {
@@ -51,6 +52,7 @@ export async function deployDependencies() {
     ],
     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 {
@@ -53,6 +54,7 @@ export async function deployDependencies() {
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
     },
   };

package/scripts/tokens/Zeto_AnonNullifierQurrency.ts

@@ -29,6 +29,7 @@ export async function deployDependencies() {
     // batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
+    poseidon2,
     poseidon3,
     poseidon5,
     poseidon6,
@@ -53,6 +54,7 @@ export async function deployDependencies() {
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
       PoseidonUnit5L: poseidon5.target,
       PoseidonUnit6L: poseidon6.target,

package/scripts/tokens/Zeto_NfAnonNullifier.ts

@@ -20,7 +20,7 @@ import zetoModule from "../../ignition/modules/zeto_nf_anon_nullifier";
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
 
-  const { verifier, lockVerifier, smtLib, poseidon3 } =
+  const { verifier, lockVerifier, smtLib, poseidon2, poseidon3 } =
     await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -42,6 +42,7 @@ export async function deployDependencies() {
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
     },
   };

package/test/factory_upgradeable.ts

@@ -0,0 +1,311 @@
+// Copyright © 2026 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.
+
+import { ethers, network, upgrades } from "hardhat";
+import { Signer } from "ethers";
+import { expect } from "chai";
+
+describe("(factory upgradeable) Zeto based fungible token with anonymity without encryption or nullifier", function () {
+  let deployer: Signer;
+  let nonOwner: Signer;
+
+  before(async function () {
+    if (network.name !== "hardhat") {
+      // accommodate for longer block times on public networks
+      this.timeout(120000);
+    }
+    [deployer, nonOwner] = await ethers.getSigners();
+  });
+
+  async function deployFactory() {
+    const Factory = await ethers.getContractFactory(
+      "ZetoTokenFactoryUpgradeable",
+    );
+    const proxy = await upgrades.deployProxy(Factory, [], {
+      kind: "uups",
+      initializer: "initialize",
+    });
+    await proxy.waitForDeployment();
+    return await ethers.getContractAt(
+      "ZetoTokenFactoryUpgradeable",
+      await proxy.getAddress(),
+    );
+  }
+
+  it("attempting to register an implementation as a non-owner should fail", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      verifiers: {
+        verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        depositVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        withdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchWithdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        lockVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchLockVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        burnVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchBurnVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      },
+    };
+    await expect(
+      factory.connect(nonOwner).registerImplementation("test", implInfo as any),
+    ).rejectedWith(`reverted with custom error 'OwnableUnauthorizedAccount(`);
+  });
+
+  it("attempting to initialize twice should fail", async function () {
+    const factory = await deployFactory();
+
+    await expect(factory.initialize()).rejectedWith("InvalidInitialization");
+  });
+
+  it("attempting to register an implementation without the required implementation value should fail", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0x0000000000000000000000000000000000000000",
+      verifiers: {
+        verifier: "0x0000000000000000000000000000000000000000",
+        batchVerifier: "0x0000000000000000000000000000000000000000",
+        depositVerifier: "0x0000000000000000000000000000000000000000",
+        withdrawVerifier: "0x0000000000000000000000000000000000000000",
+        batchWithdrawVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: "0x0000000000000000000000000000000000000000",
+        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        burnVerifier: "0x0000000000000000000000000000000000000000",
+        batchBurnVerifier: "0x0000000000000000000000000000000000000000",
+      },
+    };
+    await expect(
+      factory.connect(deployer).registerImplementation("test", implInfo as any),
+    ).rejectedWith("Factory: implementation address is required");
+  });
+
+  it("attempting to register an implementation without the required verifier value should fail", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      verifiers: {
+        verifier: "0x0000000000000000000000000000000000000000",
+        batchVerifier: "0x0000000000000000000000000000000000000000",
+        depositVerifier: "0x0000000000000000000000000000000000000000",
+        withdrawVerifier: "0x0000000000000000000000000000000000000000",
+        batchWithdrawVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: "0x0000000000000000000000000000000000000000",
+        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        burnVerifier: "0x0000000000000000000000000000000000000000",
+        batchBurnVerifier: "0x0000000000000000000000000000000000000000",
+      },
+    };
+    await expect(
+      factory.connect(deployer).registerImplementation("test", implInfo as any),
+    ).rejectedWith("Factory: verifier address is required");
+  });
+
+  it("attempting to register an implementation with the required values should succeed", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      verifiers: {
+        verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchVerifier: "0x0000000000000000000000000000000000000000",
+        depositVerifier: "0x0000000000000000000000000000000000000000",
+        withdrawVerifier: "0x0000000000000000000000000000000000000000",
+        batchWithdrawVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: "0x0000000000000000000000000000000000000000",
+        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        burnVerifier: "0x0000000000000000000000000000000000000000",
+        batchBurnVerifier: "0x0000000000000000000000000000000000000000",
+      },
+    };
+    await expect(
+      factory.connect(deployer).registerImplementation("test", implInfo as any),
+    ).fulfilled;
+  });
+
+  it("attempting to deploy a fungible token but with a registered implementation that misses required batchVerifier should fail", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      verifiers: {
+        verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchVerifier: "0x0000000000000000000000000000000000000000",
+        depositVerifier: "0x0000000000000000000000000000000000000000",
+        withdrawVerifier: "0x0000000000000000000000000000000000000000",
+        batchWithdrawVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: "0x0000000000000000000000000000000000000000",
+        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        burnVerifier: "0x0000000000000000000000000000000000000000",
+        batchBurnVerifier: "0x0000000000000000000000000000000000000000",
+      },
+    };
+    const tx1 = await factory
+      .connect(deployer)
+      .registerImplementation("test", implInfo as any);
+    await tx1.wait();
+
+    await expect(
+      factory
+        .connect(deployer)
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
+    ).rejectedWith("Factory: depositVerifier address is required");
+  });
+
+  it("attempting to deploy a fungible token but with a registered implementation that misses required depositVerifier should fail", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      verifiers: {
+        verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        depositVerifier: "0x0000000000000000000000000000000000000000",
+        withdrawVerifier: "0x0000000000000000000000000000000000000000",
+        batchWithdrawVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: "0x0000000000000000000000000000000000000000",
+        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        burnVerifier: "0x0000000000000000000000000000000000000000",
+        batchBurnVerifier: "0x0000000000000000000000000000000000000000",
+      },
+    };
+    const tx1 = await factory
+      .connect(deployer)
+      .registerImplementation("test", implInfo as any);
+    await tx1.wait();
+
+    await expect(
+      factory
+        .connect(deployer)
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
+    ).rejectedWith("Factory: depositVerifier address is required");
+  });
+
+  it("attempting to deploy a fungible token but with a registered implementation that misses required withdrawVerifier should fail", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      verifiers: {
+        verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        depositVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        withdrawVerifier: "0x0000000000000000000000000000000000000000",
+        batchWithdrawVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: "0x0000000000000000000000000000000000000000",
+        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        burnVerifier: "0x0000000000000000000000000000000000000000",
+        batchBurnVerifier: "0x0000000000000000000000000000000000000000",
+      },
+    };
+    const tx1 = await factory
+      .connect(deployer)
+      .registerImplementation("test", implInfo as any);
+    await tx1.wait();
+
+    await expect(
+      factory
+        .connect(deployer)
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
+    ).rejectedWith("Factory: withdrawVerifier address is required");
+  });
+
+  it("attempting to deploy a fungible token but with a registered implementation that misses required batchWithdrawVerifier should fail", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      verifiers: {
+        verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        depositVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        withdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchWithdrawVerifier: "0x0000000000000000000000000000000000000000",
+        lockVerifier: "0x0000000000000000000000000000000000000000",
+        batchLockVerifier: "0x0000000000000000000000000000000000000000",
+        burnVerifier: "0x0000000000000000000000000000000000000000",
+        batchBurnVerifier: "0x0000000000000000000000000000000000000000",
+      },
+    };
+    const tx1 = await factory
+      .connect(deployer)
+      .registerImplementation("test", implInfo as any);
+    await tx1.wait();
+
+    await expect(
+      factory
+        .connect(deployer)
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
+    ).rejectedWith("Factory: batchWithdrawVerifier address is required");
+  });
+
+  it("attempting to deploy a fungible token with a properly registered implementation should succeed", async function () {
+    const factory = await deployFactory();
+
+    const implInfo = {
+      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      verifiers: {
+        verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        depositVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        withdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchWithdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        lockVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchLockVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        burnVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+        batchBurnVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      },
+    };
+    const tx1 = await factory
+      .connect(deployer)
+      .registerImplementation("test", implInfo as any);
+    await tx1.wait();
+
+    await expect(
+      factory
+        .connect(deployer)
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
+    ).fulfilled;
+  });
+});