@lfdecentralizedtrust/zeto-contracts 0.2.1 → 0.5.0

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,
@@ -38,10 +38,11 @@ export async function deployDependencies() {
         batchLockVerifier: "0x0000000000000000000000000000000000000000",
         burnVerifier: "0x0000000000000000000000000000000000000000",
         batchBurnVerifier: "0x0000000000000000000000000000000000000000",
-      }
+      },
     ],
     libraries: {
       SmtLib: smtLib.target,
+      PoseidonUnit2L: poseidon2.target,
       PoseidonUnit3L: poseidon3.target,
     },
   };

package/test/factory.ts

@@ -47,7 +47,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 +73,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 +99,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 +125,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 +151,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 +161,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 +188,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 +198,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 +226,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 +236,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 +264,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 +274,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 +290,14 @@ 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 Zeto = await ethers.getContractFactory("Zeto_Anon");
+    const zeto = await Zeto.deploy();
+    await zeto.waitForDeployment();
+
     const implInfo = {
-      implementation: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
+      implementation: zeto.target,
       verifiers: {
         verifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
         batchVerifier: "0xae92d5aD7583AD66E49A0c67BAd18F6ba52dDDc1",
@@ -340,7 +308,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 +318,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;
   });
 });

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

package/test/lib/anon_nullifier_helpers.ts

@@ -0,0 +1,89 @@
+// Copyright © 2024 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ZK helpers for the `anon_nullifier_transfer` circuit family ({Zeto_AnonNullifier}
+// unlocked-input transfers and createLock). Extracted so escrow and other suites
+// can use them without importing the full `zeto_anon_nullifier.ts` Hardhat module.
+
+import { AbiCoder, BigNumberish, ethers } from "ethers";
+import { encodeProof } from "zeto-js";
+import { groth16 } from "snarkjs";
+import { User, UTXO, logger } from "./utils";
+
+/**
+ * Build a Groth16 proof for an unlocked-input nullifier transfer (merkle-backed).
+ */
+export async function prepareProof(
+  circuit: any,
+  provingKey: any,
+  signer: User,
+  inputs: UTXO[],
+  _nullifiers: UTXO[],
+  outputs: UTXO[],
+  root: BigInt,
+  merkleProof: BigInt[][],
+  owners: User[],
+  lockDelegate?: string,
+) {
+  const nullifiers = _nullifiers.map((nullifier) => nullifier.hash) as [
+    BigNumberish,
+    BigNumberish,
+  ];
+  const inputCommitments: BigNumberish[] = inputs.map(
+    (input) => input.hash,
+  ) as BigNumberish[];
+  const inputValues = inputs.map((input) => BigInt(input.value || 0n));
+  const inputSalts = inputs.map((input) => input.salt || 0n);
+  const outputCommitments: BigNumberish[] = outputs.map(
+    (output) => output.hash,
+  ) as BigNumberish[];
+  const outputValues = outputs.map((output) => BigInt(output.value || 0n));
+  const outputOwnerPublicKeys: BigNumberish[][] = owners.map(
+    (owner) => owner.babyJubPublicKey,
+  ) as BigNumberish[][];
+
+  const startWitnessCalculation = Date.now();
+  const inputObj: Record<string, unknown> = {
+    nullifiers,
+    inputCommitments,
+    inputValues,
+    inputSalts,
+    inputOwnerPrivateKey: signer.formattedPrivateKey,
+    root,
+    enabled: nullifiers.map((n) => (n !== 0n ? 1 : 0)),
+    merkleProof,
+    outputCommitments,
+    outputValues,
+    outputSalts: outputs.map((output) => output.salt || 0n),
+    outputOwnerPublicKeys,
+  };
+  if (lockDelegate) {
+    inputObj["lockDelegate"] = ethers.toBigInt(lockDelegate);
+  }
+
+  const witness = await circuit.calculateWTNSBin(inputObj, true);
+  const timeWithnessCalculation = Date.now() - startWitnessCalculation;
+
+  const startProofGeneration = Date.now();
+  const { proof } = (await groth16.prove(provingKey, witness)) as {
+    proof: BigNumberish[];
+    publicSignals: BigNumberish[];
+  };
+  const timeProofGeneration = Date.now() - startProofGeneration;
+
+  logger.debug(
+    `Witness calculation time: ${timeWithnessCalculation}ms. Proof generation time: ${timeProofGeneration}ms.`,
+  );
+
+  const encodedProof = encodeProof(proof);
+  return encodedProof;
+}
+
+/** ABI encoding for nullifier transfer proofs: root prefix + Groth16 tuple. */
+export function encodeToBytes(root: any, proof: any) {
+  return new AbiCoder().encode(
+    ["uint256 root", "tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)"],
+    [root, proof],
+  );
+}