@lfdecentralizedtrust/zeto-contracts 0.2.2 → 0.5.0

package/test/test/escrow2.ts

@@ -15,12 +15,24 @@
 // limitations under the License.
 
 import { ethers, ignition, network } from "hardhat";
-import { Signer, encodeBytes32String, ZeroHash, lock } from "ethers";
+import {
+  Signer,
+  AbiCoder,
+  BigNumberish,
+  ContractTransactionReceipt,
+} from "ethers";
 import { expect } from "chai";
-import { loadCircuit, getProofHash } from "zeto-js";
+import { loadCircuit } from "zeto-js";
 import { Merkletree, InMemoryDB, str2Bytes } from "@iden3/js-merkletree";
 import zkEscrowModule from "../../ignition/modules/test/escrow2";
-import zetoAnonNullifierTests from "../zeto_anon_nullifier";
+import { prepareProof as prepareNullifierUnlockedProof } from "../lib/anon_nullifier_helpers";
+// The locked-input transition for Zeto_AnonNullifier reuses the simple
+// `anon` circuit (the lockVerifier in the ignition module is wired to
+// {Groth16Verifier_Anon}, mirroring what the production ZK proof path
+// expects from {ZetoFungible._transferLocked}). So the spend proof for
+// the escrow flow is built with `prepareProof` from {anon_zeto_helpers}
+// (same circuit helper as in `zeto_anon.ts`), not from the nullifier suite.
+import { prepareProof as prepareProofAnonCircuit } from "../lib/anon_zeto_helpers";
 import {
   UTXO,
   User,
@@ -29,11 +41,35 @@ import {
   newNullifier,
   doMint,
   ZERO_UTXO,
-  parseUTXOEvents,
+  logger,
 } from "../lib/utils";
 import { loadProvingKeys } from "../utils";
 import { deployZeto } from "../lib/deploy";
 
+// ABI fragments mirror the canonical ZetoLockableCapability *Args
+// payloads used uniformly across all Zeto tokens.
+const CREATE_ARGS_ABI =
+  "tuple(bytes32 txId, uint256[] inputs, uint256[] outputs, uint256[] lockedOutputs, bytes proof)";
+const DELEGATE_ARGS_ABI = "tuple(bytes32 txId)";
+
+function encodeCreateArgs(args: {
+  txId: string;
+  inputs: BigNumberish[];
+  outputs: BigNumberish[];
+  lockedOutputs: BigNumberish[];
+  proof: string;
+}) {
+  return new AbiCoder().encode([CREATE_ARGS_ABI], [args]);
+}
+
+function encodeDelegateArgs(txId: string) {
+  return new AbiCoder().encode([DELEGATE_ARGS_ABI], [{ txId }]);
+}
+
+function randomBytes32(): string {
+  return ethers.hexlify(ethers.randomBytes(32));
+}
+
 describe("Escrow flow for payment with Zeto_AnonNullifier", function () {
   let Alice: User;
   let Bob: User;
@@ -49,20 +85,22 @@ describe("Escrow flow for payment with Zeto_AnonNullifier", function () {
 
   // UTXOs involved in the escrow flow
   let lockedPayment1: UTXO;
-  let nullifier1: UTXO;
   let paymentToBob: UTXO;
+  let lockId: string;
 
   // other variables
   let deployer: Signer;
-  let circuit: any, circuitLocked: any;
-  let provingKey: string, provingKeyLocked: string;
+  // unlocked-input transfer circuit (nullifier + merkle proof)
+  let circuit: any;
+  let provingKey: string;
+  // locked-input transfer circuit (simpler `anon`, no nullifier or root)
+  let circuitLocked: any;
+  let provingKeyLocked: string;
   let paymentId: any;
-  let smtAlice: Merkletree, smtAliceLocked: Merkletree;
-  let smtBob: Merkletree;
+  let smtAlice: Merkletree;
 
   before(async function () {
     if (network.name !== "hardhat") {
-      // accommodate for longer block times on public networks
       this.timeout(120000);
     }
     let [d, a, b, c] = await ethers.getSigners();
@@ -75,19 +113,14 @@ describe("Escrow flow for payment with Zeto_AnonNullifier", function () {
     ({ provingKeyFile: provingKey } = loadProvingKeys(
       "anon_nullifier_transfer",
     ));
-    circuitLocked = await loadCircuit("anon_nullifier_transferLocked");
-    ({ provingKeyFile: provingKeyLocked } = loadProvingKeys(
-      "anon_nullifier_transferLocked",
-    ));
+    circuitLocked = await loadCircuit("anon");
+    ({ provingKeyFile: provingKeyLocked } = loadProvingKeys("anon"));
 
     const storage1 = new InMemoryDB(str2Bytes(""));
     smtAlice = new Merkletree(storage1, true, 64);
 
-    const storage2 = new InMemoryDB(str2Bytes(""));
-    smtAliceLocked = new Merkletree(storage2, true, 64);
-
     ({ deployer, zeto: zkPayment } = await deployZeto("Zeto_AnonNullifier"));
-    console.log(`ZK Payment contract deployed at ${zkPayment.target}`);
+    logger.debug(`ZK Payment contract deployed at ${zkPayment.target}`);
     ({ zkEscrow } = await ignition.deploy(zkEscrowModule, {
       parameters: {
         zkEscrow2: {
@@ -102,136 +135,196 @@ describe("Escrow flow for payment with Zeto_AnonNullifier", function () {
     payment2 = newUTXO(20, Alice);
     const result = await doMint(zkPayment, deployer, [payment1, payment2]);
 
-    // simulate Alice and Bob listening to minting events and updating his local merkle tree
     for (const log of result.logs) {
       const event = zkPayment.interface.parseLog(log as any);
       expect(event.args.outputs.length).to.equal(2);
     }
 
+    // Mirror the on-chain unlocked-commitments SMT off-chain so we can
+    // build merkle proofs for the unlocked-input transition that
+    // creates the lock.
     await smtAlice.add(payment1.hash, payment1.hash);
     await smtAlice.add(payment2.hash, payment2.hash);
   });
 
-  it("Alice locks some payment tokens and designates the escrow as the delegate", async function () {
-    // Alice generates the nullifiers for the UTXOs to be spent
+  it("Alice locks payment1 by calling createLock on the Zeto token", async function () {
+    // Alice generates the nullifier for payment1 and a merkle inclusion
+    // proof in the unlocked-commitments SMT.
     const nullifier1 = newNullifier(payment1, Alice);
-
-    // Alice generates inclusion proofs for the UTXOs to be spent
-    let root = await smtAlice.root();
-    const proof1 = await smtAlice.generateCircomVerifierProof(
-      payment1.hash,
-      root,
-    );
-    const proof2 = await smtAlice.generateCircomVerifierProof(0n, root);
+    const root = await smtAlice.root();
+    const p1 = await smtAlice.generateCircomVerifierProof(payment1.hash, root);
+    const p2 = await smtAlice.generateCircomVerifierProof(0n, root);
     const merkleProofs = [
-      proof1.siblings.map((s) => s.bigInt()),
-      proof2.siblings.map((s) => s.bigInt()),
+      p1.siblings.map((s) => s.bigInt()),
+      p2.siblings.map((s) => s.bigInt()),
     ];
 
     lockedPayment1 = newUTXO(payment1.value!, Alice);
-    const { inputCommitments, outputCommitments, encodedProof } =
-      await zetoAnonNullifierTests.prepareProof(
-        circuit,
-        provingKey,
-        Alice,
-        [payment1, ZERO_UTXO],
-        [nullifier1, ZERO_UTXO],
-        [lockedPayment1, ZERO_UTXO],
-        root.bigInt(),
-        merkleProofs,
-        [Alice, Alice],
-      );
+    const encodedZkProof = await prepareNullifierUnlockedProof(
+      circuit,
+      provingKey,
+      Alice,
+      [payment1, ZERO_UTXO],
+      [nullifier1, ZERO_UTXO],
+      [lockedPayment1, ZERO_UTXO],
+      root.bigInt(),
+      merkleProofs,
+      [Alice, Alice],
+    );
+
+    const createArgs = encodeCreateArgs({
+      txId: randomBytes32(),
+      inputs: [nullifier1.hash],
+      // For Zeto_AnonNullifier createLock, lockedOutputs holds the
+      // freshly-locked UTXO and outputs is empty; payment1's full value
+      // moves into the lock.
+      outputs: [],
+      lockedOutputs: [lockedPayment1.hash],
+      proof: encodeUnlockedProof(root.bigInt(), encodedZkProof),
+    });
+
+    lockId = await zkPayment.connect(Alice.signer).computeLockId(createArgs);
+
     const tx = await zkPayment
       .connect(Alice.signer)
-      .lock(
-        [nullifier1.hash],
-        [],
-        outputCommitments,
-        root.bigInt(),
-        encodedProof,
+      .createLock(createArgs, ethers.ZeroHash, ethers.ZeroHash, "0x");
+    const result = await tx.wait();
+    logger.debug(`createLock() complete. Gas used: ${result?.gasUsed}`);
+
+    const info = await zkPayment.getLock(lockId);
+    expect(info.owner).to.equal(Alice.ethAddress);
+    expect(info.spender).to.equal(Alice.ethAddress);
+    expect(await zkPayment.locked(lockedPayment1.hash)).to.deep.equal([
+      true,
+      Alice.ethAddress,
+    ]);
+  }).timeout(120000);
+
+  it("Alice delegates the lock to the escrow contract", async function () {
+    const tx = await zkPayment
+      .connect(Alice.signer)
+      .delegateLock(
+        lockId,
+        encodeDelegateArgs(randomBytes32()),
         zkEscrow.target,
         "0x",
       );
-    const result = await tx.wait();
-    const events = parseUTXOEvents(zkPayment, result);
-
-    // simulate Alice's tradinig partner listening to the locking events and verifying the committed (locked) value
-    const lockedUTXO = events[0].lockedOutputs[0];
-    const lockDelegate = events[0].delegate;
-    // Alice's trading partner is sent the secrets for the locked UTXO (which is still owned by Alice)
-    // in an off-chain message. so they can be used to verify the locked UTXO, and the lock delegate
-    const check = newUTXO(lockedPayment1.value!, Alice, lockedPayment1.salt);
-    expect(lockedUTXO).to.equal(check.hash);
-    expect(lockDelegate).to.equal(zkEscrow.target);
-
-    await smtAliceLocked.add(
-      lockedPayment1.hash,
-      ethers.toBigInt(zkEscrow.target),
-    );
+    await tx.wait();
+
+    const info = await zkPayment.getLock(lockId);
+    expect(info.spender).to.equal(zkEscrow.target);
+    expect(await zkPayment.locked(lockedPayment1.hash)).to.deep.equal([
+      true,
+      zkEscrow.target,
+    ]);
   });
 
   it("Alice initiates a payment transaction to Bob through the escrow", async function () {
-    nullifier1 = newNullifier(lockedPayment1, Alice);
     paymentToBob = newUTXO(lockedPayment1.value!, Bob);
     const tx = await zkEscrow
       .connect(Alice.signer)
-      .initiatePayment([nullifier1.hash], [paymentToBob.hash], "0x");
+      .initiatePayment(lockId, [paymentToBob.hash], "0x");
     const result = await tx.wait();
-    const events = parseUTXOEvents(zkEscrow, result);
-    // simulate Bob listening to the payment events and verifying the proposed payment
-    const proposedPayment = events[0].outputs[0];
-    expect(proposedPayment).to.equal(paymentToBob.hash);
-    paymentId = events[0].paymentId;
+    const initiated = parseEscrowEvent(zkEscrow, result, "PaymentInitiated");
+    expect(initiated, "PaymentInitiated event not emitted").to.not.be.undefined;
+    expect(initiated!.outputs[0]).to.equal(paymentToBob.hash);
+    expect(initiated!.lockId).to.equal(lockId);
+    paymentId = initiated!.paymentId;
   });
 
-  it("Alice approves the payment by submitting a valid proof that can successfully verify the proposed payment", async function () {
-    let root = await smtAliceLocked.root();
-    const proof1 = await smtAliceLocked.generateCircomVerifierProof(
-      lockedPayment1.hash,
-      root,
-    );
-    const proof2 = await smtAliceLocked.generateCircomVerifierProof(0n, root);
-    const merkleProofs = [
-      proof1.siblings.map((s) => s.bigInt()),
-      proof2.siblings.map((s) => s.bigInt()),
-    ];
-    const { encodedProof } = await zetoAnonNullifierTests.prepareProof(
+  it("Alice approves the payment by submitting a valid locked-input proof", async function () {
+    // The locked-input transition uses the simple `anon` circuit and
+    // operates on the raw UTXO hash (lockedPayment1.hash), not on a
+    // nullifier. The Zeto storage layer has already validated the
+    // input is in the locked-UTXO ledger.
+    const encodedZkProof = await prepareProofAnonCircuit(
       circuitLocked,
       provingKeyLocked,
       Alice,
       [lockedPayment1, ZERO_UTXO],
-      [nullifier1, ZERO_UTXO],
       [paymentToBob, ZERO_UTXO],
-      root.bigInt(),
-      merkleProofs,
-      [Bob, Bob],
-      zkEscrow.target,
+      [Bob, {}],
     );
     const tx = await zkEscrow
       .connect(Alice.signer)
-      .approvePayment(paymentId, root.bigInt(), encodedProof, "0x");
+      .approvePayment(paymentId, encodeLockedProof(encodedZkProof), "0x");
     const result = await tx.wait();
-    // simulate Bob listening to the escrow events and verifying the payment has been approved.
-    // the escrow contract guaratees that the proof is valid
-    const events = parseUTXOEvents(zkEscrow, result);
-    const approvedPayment = events[0].paymentId;
-    expect(approvedPayment).to.equal(paymentId);
-  });
 
-  it("Bob, or anyone, can call the escrow to finalize the payment and receive the locked UTXO", async function () {
+    const approved = parseEscrowEvent(zkEscrow, result, "PaymentApproved");
+    expect(approved, "PaymentApproved event not emitted").to.not.be.undefined;
+    expect(approved!.paymentId).to.equal(paymentId);
+  }).timeout(120000);
+
+  it("Bob, or anyone, can call the escrow to finalize the payment and receive the unlocked UTXO", async function () {
     const tx = await zkEscrow
       .connect(Bob.signer)
       .completePayment(paymentId, "0x");
     const result = await tx.wait();
-    // simulate Bob listening to the payment events and verifying
-    // the expected UTXO has been transferred to him
-    let events = parseUTXOEvents(zkPayment, result);
-    const transferredPayment = events[0].outputs[0];
-    const check = newUTXO(paymentToBob.value!, Bob, paymentToBob.salt);
-    expect(transferredPayment).to.equal(check.hash);
-    // simulate Bob listening to the escrow events and verifying the payment has been completed
-    events = parseUTXOEvents(zkEscrow, result);
-    const completedPayment = events[1].paymentId;
-    expect(completedPayment).to.equal(paymentId);
+
+    // The Zeto token emits ZetoLockSpent containing the new unlocked
+    // outputs.
+    const lockSpent = result!.logs
+      .map((l) => {
+        try {
+          return zkPayment.interface.parseLog(l as any);
+        } catch (_e) {
+          return null;
+        }
+      })
+      .find((p: any) => p && p.name === "ZetoLockSpent");
+    expect(lockSpent, "ZetoLockSpent event not emitted").to.not.be.undefined;
+    expect(lockSpent!.args.outputs[0]).to.equal(paymentToBob.hash);
+
+    expect(await zkPayment.isLockActive(lockId)).to.equal(false);
+    expect((await zkPayment.locked(lockedPayment1.hash))[0]).to.be.false;
+
+    const completed = parseEscrowEvent(zkEscrow, result, "PaymentCompleted");
+    expect(completed, "PaymentCompleted event not emitted").to.not.be.undefined;
+    expect(completed!.paymentId).to.equal(paymentId);
   });
 });
+
+// encodeUnlockedProof matches the wire format consumed by
+// {Zeto_AnonNullifier.constructPublicInputs} on the unlocked branch:
+// `(uint256 root, Commonlib.Proof)`. Used for the createLock proof.
+function encodeUnlockedProof(root: any, proof: any) {
+  return new AbiCoder().encode(
+    ["uint256 root", "tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)"],
+    [root, proof],
+  );
+}
+
+// encodeLockedProof matches the wire format consumed on the locked
+// branch: just `Commonlib.Proof`, no root prefix (the locked input is
+// already vouched for by the storage layer, no merkle inclusion proof
+// is needed). Used for the spendLock / approvePayment proof.
+function encodeLockedProof(proof: any) {
+  return new AbiCoder().encode(
+    ["tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)"],
+    [proof],
+  );
+}
+
+// parseEscrowEvent extracts the first event of a given name from a
+// transaction receipt by parsing logs through the escrow contract's
+// own ABI. Unlike the Zeto-token-specific `parseUTXOEvents`, this
+// helper handles the escrow's custom Payment* events.
+function parseEscrowEvent(
+  escrowContract: any,
+  receipt: ContractTransactionReceipt | null,
+  name: string,
+): any | undefined {
+  if (!receipt) return undefined;
+  for (const log of receipt.logs || []) {
+    let parsed;
+    try {
+      parsed = escrowContract.interface.parseLog(log as any);
+    } catch (_e) {
+      continue;
+    }
+    if (parsed && parsed.name === name) {
+      return parsed.args;
+    }
+  }
+  return undefined;
+}

package/test/test/qurrency.ts

@@ -15,10 +15,16 @@
 // limitations under the License.
 
 import { ethers, ignition, network } from "hardhat";
-import { Signer, BigNumberish, ContractTransactionReceipt } from "ethers";
+import { BigNumberish, ContractTransactionReceipt } from "ethers";
+import crypto from "crypto";
 import { groth16 } from "snarkjs";
 import { Merkletree, InMemoryDB, str2Bytes } from "@iden3/js-merkletree";
-import { loadCircuit, encodeProof } from "zeto-js";
+import {
+  loadCircuit,
+  encodeProof,
+  newEncryptionNonce,
+  bytesToBits,
+} from "zeto-js";
 import qurrencyModule from "../../ignition/modules/test/qurrency";
 import { User, newUser, newUTXO, newNullifier } from "../lib/utils";
 import { loadProvingKeys } from "../utils";
@@ -88,35 +94,9 @@ describe("Test Qurrency verifier", function () {
       Alice.babyJubPublicKey,
     ];
 
-    const m = [
-      1665, 1665, 0, 1665, 0, 1665, 1665, 0, 1665, 0, 0, 1665, 1665, 1665, 1665,
-      0, 0, 1665, 0, 0, 0, 1665, 1665, 0, 1665, 0, 1665, 0, 0, 1665, 1665, 0, 0,
-      1665, 0, 0, 1665, 1665, 1665, 0, 0, 0, 0, 0, 0, 1665, 0, 0, 1665, 0, 0,
-      1665, 0, 1665, 1665, 0, 1665, 1665, 0, 0, 1665, 1665, 1665, 0, 0, 0, 0, 0,
-      0, 1665, 0, 0, 1665, 1665, 0, 0, 0, 1665, 1665, 0, 1665, 1665, 1665, 1665,
-      0, 1665, 1665, 0, 1665, 1665, 1665, 1665, 0, 1665, 1665, 0, 0, 0, 1665,
-      1665, 0, 1665, 1665, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ];
-
-    const randomness = [
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0,
-    ];
+    const randomness = crypto.randomBytes(32);
+    const r = bytesToBits(randomness);
+    const encryptionNonce = newEncryptionNonce();
 
     const inputObj: any = {
       nullifiers,
@@ -131,8 +111,8 @@ describe("Test Qurrency verifier", function () {
       outputValues,
       outputSalts,
       outputOwnerPublicKeys,
-      randomness,
-      m,
+      randomness: r,
+      encryptionNonce,
     };
     const witness = await circuit.calculateWTNSBin(inputObj, true);
     const startProofGeneration = Date.now();

package/test/usdc-shielding.ts

@@ -15,7 +15,12 @@
 // limitations under the License.
 
 import { ethers, network } from "hardhat";
-import { Signer, BigNumberish, ContractTransactionReceipt } from "ethers";
+import {
+  Signer,
+  BigNumberish,
+  ContractTransactionReceipt,
+  AbiCoder,
+} from "ethers";
 import { expect } from "chai";
 import { loadCircuit, encodeProof, Poseidon } from "zeto-js";
 import { groth16 } from "snarkjs";
@@ -34,13 +39,13 @@ import {
   loadProvingKeys,
   prepareDepositProof,
   prepareNullifierWithdrawProof,
+  encodeToBytesForDeposit,
+  encodeToBytesForWithdraw,
 } from "./utils";
 import { Zeto_AnonNullifier } from "../typechain-types";
-import {
-  deployFungible as deployZeto,
-} from "../scripts/deploy_upgradeable";
+import { deployZeto } from "./lib/deploy";
 
-const USDC_SEPOLIA_ADDRESS = '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238';
+const USDC_SEPOLIA_ADDRESS = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238";
 const TRANSFER_AMOUNT = 1000; // 0.001000 UDSC
 
 describe("Shield USDC balances, transact in privacy, and withdraw back to USDC", function () {
@@ -68,11 +73,12 @@ describe("Shield USDC balances, transact in privacy, and withdraw back to USDC",
     Alice2 = await newUser(b);
     Bob = await newUser(c);
 
-    const usdcAddress = network.name === "sepolia" ? USDC_SEPOLIA_ADDRESS : undefined;
-    ({ zeto, erc20: usdc } = await deployZeto("Zeto_AnonNullifier", usdcAddress));
+    ({ zeto, erc20: usdc } = await deployZeto("Zeto_AnonNullifier"));
 
     circuit = await loadCircuit("anon_nullifier_transfer");
-    ({ provingKeyFile: provingKey } = loadProvingKeys("anon_nullifier_transfer"));
+    ({ provingKeyFile: provingKey } = loadProvingKeys(
+      "anon_nullifier_transfer",
+    ));
 
     const storage1 = new InMemoryDB(str2Bytes(""));
     smtAlice = new Merkletree(storage1, true, 64);
@@ -84,7 +90,9 @@ describe("Shield USDC balances, transact in privacy, and withdraw back to USDC",
   it("Alice shields some USDC balance into the Zeto contract, and get Zeto tokens of the same value", async function () {
     const balance = await usdc.balanceOf(Alice.ethAddress);
     expect(balance).to.be.gt(TRANSFER_AMOUNT);
-    const tx1 = await usdc.connect(Alice.signer).approve(zeto.target, TRANSFER_AMOUNT);
+    const tx1 = await usdc
+      .connect(Alice.signer)
+      .approve(zeto.target, TRANSFER_AMOUNT);
     await tx1.wait();
 
     // Alice proposes the output UTXOs to shield her USDC balance
@@ -95,7 +103,12 @@ describe("Shield USDC balances, transact in privacy, and withdraw back to USDC",
     );
     const tx2 = await zeto
       .connect(Alice.signer)
-      .deposit(TRANSFER_AMOUNT, outputCommitments, encodedProof, "0x");
+      .deposit(
+        TRANSFER_AMOUNT,
+        outputCommitments,
+        encodeToBytesForDeposit(encodedProof),
+        "0x",
+      );
     await tx2.wait();
 
     // Alice locally tracks the UTXOs inside the Sparse Merkle Tree
@@ -179,10 +192,7 @@ describe("Shield USDC balances, transact in privacy, and withdraw back to USDC",
 
     // Alice generates inclusion proofs for the UTXOs to be spent
     let root = await smtAlice.root();
-    const proof1 = await smtAlice.generateCircomVerifierProof(
-      utxo3.hash,
-      root,
-    );
+    const proof1 = await smtAlice.generateCircomVerifierProof(utxo3.hash, root);
     const proof2 = await smtAlice.generateCircomVerifierProof(0n, root);
     const merkleProofs = [
       proof1.siblings.map((s) => s.bigInt()),
@@ -208,16 +218,13 @@ describe("Shield USDC balances, transact in privacy, and withdraw back to USDC",
     // she used to shield the USDC tokens. Other parties can not link the
     // original USDC tokens to the withdrawn USDC tokens, because the public key
     // information behind the UTXO is unknown to other parties.
-    const tx = await zeto
-      .connect(Alice2.signer)
-      .withdraw(
-        TRANSFER_AMOUNT / 2, // the amount to withdraw
-        nullifiers,
-        outputCommitments[0],
-        root.bigInt(),
-        encodedProof,
-        "0x",
-      );
+    const tx = await zeto.connect(Alice2.signer).withdraw(
+      TRANSFER_AMOUNT / 2, // the amount to withdraw
+      nullifiers,
+      outputCommitments[0],
+      encodeToBytesForWithdraw(root.bigInt(), encodedProof),
+      "0x",
+    );
     await tx.wait();
 
     // Alice checks her ERC20 balance
@@ -284,8 +291,7 @@ describe("Shield USDC balances, transact in privacy, and withdraw back to USDC",
     tx = await zeto.connect(signer.signer).transfer(
       nullifiers.filter((ic) => ic !== 0n), // trim off empty utxo hashes to check padding logic for batching works
       outputCommitments.filter((oc) => oc !== 0n), // trim off empty utxo hashes to check padding logic for batching works
-      root,
-      encodedProof,
+      encodeToBytes(root, encodedProof),
       "0x",
     );
     const results: ContractTransactionReceipt | null = await tx.wait();
@@ -359,3 +365,10 @@ describe("Shield USDC balances, transact in privacy, and withdraw back to USDC",
     };
   }
 });
+
+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],
+  );
+}