@lfdecentralizedtrust/zeto-contracts 0.2.2 → 0.5.1

package/scripts/tokens/Zeto_Anon.ts

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon";
+import { withZetoLockableLib } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -26,9 +27,11 @@ export async function deployDependencies() {
     verifier,
     batchVerifier,
     batchWithdrawVerifier,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
+    libraries: withZetoLockableLib(zetoLockableLib),
     args: [
       "Zeto Anon",
       "ZA",
@@ -39,11 +42,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

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_burnable";
+import { withZetoLockableLib } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -28,9 +29,11 @@ export async function deployDependencies() {
     batchVerifier,
     batchWithdrawVerifier,
     batchBurnVerifier,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
+    libraries: withZetoLockableLib(zetoLockableLib),
     args: [
       "Zeto Anon Burnable",
       "ZAB",
@@ -45,7 +48,7 @@ export async function deployDependencies() {
         batchBurnVerifier: batchBurnVerifier.target,
         lockVerifier: "0x0000000000000000000000000000000000000000",
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
   };
 }

package/scripts/tokens/Zeto_AnonEnc.ts

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_enc";
+import { withZetoLockableLib } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -26,9 +27,11 @@ export async function deployDependencies() {
     verifier,
     batchVerifier,
     batchWithdrawVerifier,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
+    libraries: withZetoLockableLib(zetoLockableLib),
     args: [
       "Zeto Anon Enc",
       "ZAE",
@@ -39,11 +42,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

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_enc_nullifier";
+import { withZetoLockableLib, smtLibraries } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -24,11 +25,14 @@ export async function deployDependencies() {
     depositVerifier,
     withdrawVerifier,
     verifier,
+    lockVerifier,
     batchVerifier,
+    batchLockVerifier,
     batchWithdrawVerifier,
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -42,16 +46,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,
-    },
+    libraries: withZetoLockableLib(
+      zetoLockableLib,
+      smtLibraries({ smtLib, poseidon2, poseidon3 }),
+    ),
   };
 }

package/scripts/tokens/Zeto_AnonEncNullifierKyc.ts

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_enc_nullifier_kyc";
+import { withZetoLockableLib, smtLibraries } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -29,6 +30,7 @@ export async function deployDependencies() {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -46,12 +48,11 @@ export async function deployDependencies() {
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
-    libraries: {
-      SmtLib: smtLib.target,
-      PoseidonUnit2L: poseidon2.target,
-      PoseidonUnit3L: poseidon3.target,
-    },
+    libraries: withZetoLockableLib(
+      zetoLockableLib,
+      smtLibraries({ smtLib, poseidon2, poseidon3 }),
+    ),
   };
 }

package/scripts/tokens/Zeto_AnonEncNullifierNonRepudiation.ts

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_enc_nullifier_non_repudiation";
+import { withZetoLockableLib, smtLibraries } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -29,6 +30,7 @@ export async function deployDependencies() {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -46,12 +48,11 @@ export async function deployDependencies() {
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
-    libraries: {
-      SmtLib: smtLib.target,
-      PoseidonUnit2L: poseidon2.target,
-      PoseidonUnit3L: poseidon3.target,
-    },
+    libraries: withZetoLockableLib(
+      zetoLockableLib,
+      smtLibraries({ smtLib, poseidon2, poseidon3 }),
+    ),
   };
 }

package/scripts/tokens/Zeto_AnonNullifier.ts

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_nullifier";
+import { withZetoLockableLib, smtLibraries } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -31,6 +32,7 @@ export async function deployDependencies() {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -48,12 +50,11 @@ export async function deployDependencies() {
         batchLockVerifier: batchLockVerifier.target,
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
-    libraries: {
-      SmtLib: smtLib.target,
-      PoseidonUnit2L: poseidon2.target,
-      PoseidonUnit3L: poseidon3.target,
-    },
+    libraries: withZetoLockableLib(
+      zetoLockableLib,
+      smtLibraries({ smtLib, poseidon2, poseidon3 }),
+    ),
   };
 }

package/scripts/tokens/Zeto_AnonNullifierBurnable.ts

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_nullifier_burnable";
+import { withZetoLockableLib, smtLibraries } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -33,6 +34,7 @@ export async function deployDependencies() {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -50,12 +52,11 @@ export async function deployDependencies() {
         batchLockVerifier: batchLockVerifier.target,
         burnVerifier: burnVerifier.target,
         batchBurnVerifier: batchBurnVerifier.target,
-      }
+      },
     ],
-    libraries: {
-      SmtLib: smtLib.target,
-      PoseidonUnit2L: poseidon2.target,
-      PoseidonUnit3L: poseidon3.target,
-    },
+    libraries: withZetoLockableLib(
+      zetoLockableLib,
+      smtLibraries({ smtLib, poseidon2, poseidon3 }),
+    ),
   };
 }

package/scripts/tokens/Zeto_AnonNullifierKyc.ts

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_nullifier_kyc";
+import { withZetoLockableLib, smtLibraries } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -31,6 +32,7 @@ export async function deployDependencies() {
     smtLib,
     poseidon2,
     poseidon3,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -48,12 +50,11 @@ export async function deployDependencies() {
         batchLockVerifier: batchLockVerifier.target,
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
-    libraries: {
-      SmtLib: smtLib.target,
-      PoseidonUnit2L: poseidon2.target,
-      PoseidonUnit3L: poseidon3.target,
-    },
+    libraries: withZetoLockableLib(
+      zetoLockableLib,
+      smtLibraries({ smtLib, poseidon2, poseidon3 }),
+    ),
   };
 }

package/scripts/tokens/Zeto_AnonNullifierQurrency.ts

@@ -16,6 +16,7 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_anon_nullifier_qurrency";
+import { withZetoLockableLib, smtLibraries } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
@@ -33,6 +34,7 @@ export async function deployDependencies() {
     poseidon3,
     poseidon5,
     poseidon6,
+    zetoLockableLib,
   } = await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -50,14 +52,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,
-    },
+    libraries: withZetoLockableLib(
+      zetoLockableLib,
+      smtLibraries({ smtLib, poseidon2, poseidon3, poseidon5, poseidon6 }),
+    ),
   };
 }

package/scripts/tokens/Zeto_NfAnon.ts

@@ -16,13 +16,15 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_nf_anon";
+import { withZetoLockableLib } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
 
-  const { verifier } = await ignition.deploy(zetoModule);
+  const { verifier, zetoLockableLib } = await ignition.deploy(zetoModule);
   return {
     deployer,
+    libraries: withZetoLockableLib(zetoLockableLib),
     args: [
       "Zeto NF Anon",
       "ZNFA",
@@ -33,11 +35,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",
-      }
+      },
     ],
   };
 }

package/scripts/tokens/Zeto_NfAnonNullifier.ts

@@ -16,11 +16,12 @@
 
 import { ethers, ignition } from "hardhat";
 import zetoModule from "../../ignition/modules/zeto_nf_anon_nullifier";
+import { withZetoLockableLib, smtLibraries } from "../lib/zeto_libraries";
 
 export async function deployDependencies() {
   const [deployer] = await ethers.getSigners();
 
-  const { verifier, lockVerifier, smtLib, poseidon2, poseidon3 } =
+  const { verifier, lockVerifier, smtLib, poseidon2, poseidon3, zetoLockableLib } =
     await ignition.deploy(zetoModule);
   return {
     deployer,
@@ -38,12 +39,11 @@ export async function deployDependencies() {
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
-    libraries: {
-      SmtLib: smtLib.target,
-      PoseidonUnit2L: poseidon2.target,
-      PoseidonUnit3L: poseidon3.target,
-    },
+    libraries: withZetoLockableLib(
+      zetoLockableLib,
+      smtLibraries({ smtLib, poseidon2, poseidon3 }),
+    ),
   };
 }

package/test/factory.ts

@@ -17,6 +17,8 @@
 import { ethers, network } from "hardhat";
 import { Signer } from "ethers";
 import { expect } from "chai";
+import { getLinkedContractFactory } from "../scripts/lib/common";
+import { withZetoLockableLib } from "../scripts/lib/zeto_libraries";
 
 describe("(factory) Zeto based fungible token with anonymity without encryption or nullifier", function () {
   let deployer: Signer;
@@ -47,7 +49,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
         burnVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
         batchBurnVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-      }
+      },
     };
     await expect(
       factory.connect(nonOwner).registerImplementation("test", implInfo as any),
@@ -73,7 +75,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     };
     await expect(
       factory.connect(deployer).registerImplementation("test", implInfo as any),
@@ -99,7 +101,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     };
     await expect(
       factory.connect(deployer).registerImplementation("test", implInfo as any),
@@ -125,7 +127,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     };
     await expect(
       factory.connect(deployer).registerImplementation("test", implInfo as any),
@@ -151,7 +153,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     };
     const tx1 = await factory
       .connect(deployer)
@@ -161,7 +163,12 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
     await expect(
       factory
         .connect(deployer)
-        .deployZetoFungibleToken("name", "symbol", "test", await deployer.getAddress()),
+        .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 () {
@@ -183,7 +190,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     };
     const tx1 = await factory
       .connect(deployer)
@@ -193,7 +200,12 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
     await expect(
       factory
         .connect(deployer)
-        .deployZetoFungibleToken("name", "symbol", "test", await deployer.getAddress()),
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
     ).rejectedWith("Factory: depositVerifier address is required");
   });
 
@@ -216,7 +228,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     };
     const tx1 = await factory
       .connect(deployer)
@@ -226,7 +238,12 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
     await expect(
       factory
         .connect(deployer)
-        .deployZetoFungibleToken("name", "symbol", "test", await deployer.getAddress()),
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
     ).rejectedWith("Factory: withdrawVerifier address is required");
   });
 
@@ -249,7 +266,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     };
     const tx1 = await factory
       .connect(deployer)
@@ -259,68 +276,15 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
     await expect(
       factory
         .connect(deployer)
-        .deployZetoFungibleToken("name", "symbol", "test", await deployer.getAddress()),
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
     ).rejectedWith("Factory: batchWithdrawVerifier address is required");
   });
 
-  // it("attempting to deploy a fungible token but with a registered implementation that misses required lockVerifier should fail", async function () {
-  //   // we want to test the effectiveness of the factory contract
-  //   // to create clones of the Zeto implementation contract
-  //   const Factory = await ethers.getContractFactory("ZetoTokenFactory");
-  //   const factory = await Factory.deploy();
-  //   await factory.waitForDeployment();
-
-  //   const implInfo = {
-  //     implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     depositVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     withdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     batchWithdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     lockVerifier: "0x0000000000000000000000000000000000000000",
-  //     batchLockVerifier: "0x0000000000000000000000000000000000000000",
-  //   };
-  //   const tx1 = await factory
-  //     .connect(deployer)
-  //     .registerImplementation("test", implInfo as any);
-  //   await tx1.wait();
-
-  //   await expect(
-  //     factory
-  //       .connect(deployer)
-  //       .deployZetoFungibleToken("test", await deployer.getAddress()),
-  //   ).rejectedWith("Factory: lockVerifier address is required");
-  // });
-
-  // it("attempting to deploy a fungible token but with a registered implementation that misses required batchLockVerifier should fail", async function () {
-  //   // we want to test the effectiveness of the factory contract
-  //   // to create clones of the Zeto implementation contract
-  //   const Factory = await ethers.getContractFactory("ZetoTokenFactory");
-  //   const factory = await Factory.deploy();
-  //   await factory.waitForDeployment();
-
-  //   const implInfo = {
-  //     implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     depositVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     withdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     batchWithdrawVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     lockVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-  //     batchLockVerifier: "0x0000000000000000000000000000000000000000",
-  //   };
-  //   const tx1 = await factory
-  //     .connect(deployer)
-  //     .registerImplementation("test", implInfo as any);
-  //   await tx1.wait();
-
-  //   await expect(
-  //     factory
-  //       .connect(deployer)
-  //       .deployZetoFungibleToken("test", await deployer.getAddress()),
-  //   ).rejectedWith("Factory: batchLockVerifier address is required");
-  // });
-
   it("attempting to deploy a fungible token with a properly registered implementation should succeed", async function () {
     // we want to test the effectiveness of the factory contract
     // to create clones of the Zeto implementation contract
@@ -328,8 +292,21 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
     const factory = await Factory.deploy();
     await factory.waitForDeployment();
 
+    // deploy a real Zeto token so that the "implementation" contract can
+    // pass the code length check in the ERC1967Proxy contract
+    const ZetoLockableLib = await ethers.getContractFactory("ZetoLockableLib");
+    const zetoLockableLib = await ZetoLockableLib.deploy();
+    await zetoLockableLib.waitForDeployment();
+
+    const Zeto = await getLinkedContractFactory(
+      "Zeto_Anon",
+      withZetoLockableLib(zetoLockableLib),
+    );
+    const zeto = await Zeto.deploy();
+    await zeto.waitForDeployment();
+
     const implInfo = {
-      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      implementation: zeto.target,
       verifiers: {
         verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
         batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
@@ -340,7 +317,7 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
         batchLockVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
         burnVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
         batchBurnVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
-      }
+      },
     };
     const tx1 = await factory
       .connect(deployer)
@@ -350,7 +327,12 @@ describe("(factory) Zeto based fungible token with anonymity without encryption
     await expect(
       factory
         .connect(deployer)
-        .deployZetoFungibleToken("name", "symbol", "test", await deployer.getAddress()),
+        .deployZetoFungibleToken(
+          "name",
+          "symbol",
+          "test",
+          await deployer.getAddress(),
+        ),
     ).fulfilled;
   });
 });