@lfdecentralizedtrust/zeto-contracts 0.2.2 → 0.5.1

package/test/zeto_anon_enc_nullifier_kyc.ts

@@ -15,7 +15,12 @@
 // limitations under the License.
 
 import { ethers, network } from "hardhat";
-import { ContractTransactionReceipt, Signer, BigNumberish } from "ethers";
+import {
+  ContractTransactionReceipt,
+  Signer,
+  BigNumberish,
+  AbiCoder,
+} from "ethers";
 import { expect } from "chai";
 import {
   loadCircuit,
@@ -46,13 +51,17 @@ import {
 } from "./lib/utils";
 import {
   loadProvingKeys,
-  prepareDepositProof,
+  prepareDepositKycProof,
   prepareNullifierWithdrawProof,
+  encodeToBytesForDeposit,
+  encodeToBytesForWithdraw,
 } from "./utils";
 import { deployZeto } from "./lib/deploy";
 const poseidonHash = Poseidon.poseidon4;
 
-describe("Zeto based fungible token with anonymity using nullifiers and encryption with KYC", function () {
+describe(
+  "Zeto based fungible token with anonymity using nullifiers and encryption with KYC",
+  function () {
   let deployer: Signer;
   let Alice: User;
   let Bob: User;
@@ -91,11 +100,17 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
 
     ({ deployer, zeto, erc20 } = await deployZeto("Zeto_AnonEncNullifierKyc"));
 
-    const tx2 = await zeto.connect(deployer).register(Alice.babyJubPublicKey, '0x');
+    const tx2 = await zeto
+      .connect(deployer)
+      .register(Alice.babyJubPublicKey, "0x");
     const result1 = await tx2.wait();
-    const tx3 = await zeto.connect(deployer).register(Bob.babyJubPublicKey, '0x');
+    const tx3 = await zeto
+      .connect(deployer)
+      .register(Bob.babyJubPublicKey, "0x");
     const result2 = await tx3.wait();
-    const tx4 = await zeto.connect(deployer).register(Charlie.babyJubPublicKey, '0x');
+    const tx4 = await zeto
+      .connect(deployer)
+      .register(Charlie.babyJubPublicKey, "0x");
     const result3 = await tx4.wait();
 
     const storage1 = new InMemoryDB(str2Bytes("alice"));
@@ -225,12 +240,13 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
 
     const signerAddress = await Alice.signer.getAddress();
     const events = parseUTXOEvents(zeto, result.txResult!);
-    expect(events[0].submitter).to.equal(signerAddress);
-    expect(events[0].inputs).to.deep.equal(nullifiers.map((n) => n.hash));
+    const event = events[0];
+    expect(event.submitter).to.equal(signerAddress);
+    expect(event.inputs).to.deep.equal(nullifiers.map((n) => n.hash));
 
-    const incomingUTXOs: any = events[0].outputs;
+    const incomingUTXOs: any = event.outputs;
 
-    const ecdhPublicKey = events[0].ecdhPublicKey;
+    const ecdhPublicKey = event.ecdhPublicKey;
     // check the non-empty output hashes are correct
     for (let i = 0; i < outputUtxos.length; i++) {
       const utxoOwner = outputOwners[i];
@@ -239,9 +255,9 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
         ecdhPublicKey,
       );
       const plainText = poseidonDecrypt(
-        events[0].encryptedValues.slice(4 * i, 4 * i + 4),
+        event.encryptedValues.slice(4 * i, 4 * i + 4),
         sharedKey,
-        events[0].encryptionNonce,
+        event.encryptionNonce,
         2,
       );
       expect(plainText).to.deep.equal(
@@ -259,11 +275,6 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
       await smtUnregistered.add(incomingUTXOs[i], incomingUTXOs[i]);
     }
 
-    // check empty values, salt and hashes are empty
-    for (let i = outputUtxos.length; i < 10; i++) {
-      expect(incomingUTXOs[i]).to.equal(0);
-    }
-
     // mint sufficient balance in Zeto contract address for Alice to withdraw
     const mintTx = await erc20.connect(deployer).mint(zeto, 3);
     await mintTx.wait();
@@ -316,8 +327,7 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
         3,
         _withdrawNullifiers,
         withdrawCommitments[0],
-        root.bigInt(),
-        withdrawEncodedProof,
+        encodeToBytesForWithdraw(root.bigInt(), withdrawEncodedProof),
         "0x",
       );
     await tx.wait();
@@ -339,13 +349,29 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
 
     utxo100 = newUTXO(100, Alice);
     utxo0 = newUTXO(0, Alice);
-    const { outputCommitments, encodedProof } = await prepareDepositProof(
+    const identitiesRoot = await smtKyc.root();
+    const proof3 = await smtKyc.generateCircomVerifierProof(
+      kycHash(Alice.babyJubPublicKey),
+      identitiesRoot,
+    );
+    const identitiesMerkleProofs = [
+      proof3.siblings.map((s) => s.bigInt()),
+      proof3.siblings.map((s) => s.bigInt()),
+    ];
+    const { outputCommitments, encodedProof } = await prepareDepositKycProof(
       Alice,
       [utxo100, utxo0],
+      identitiesRoot.bigInt(),
+      identitiesMerkleProofs,
     );
     const tx2 = await zeto
       .connect(Alice.signer)
-      .deposit(100, outputCommitments, encodedProof, "0x");
+      .deposit(
+        100,
+        outputCommitments,
+        encodeToBytesForDeposit(encodedProof),
+        "0x",
+      );
     await tx2.wait();
 
     await smtAlice.add(utxo100.hash, utxo100.hash);
@@ -444,20 +470,21 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
     // Bob parses the UTXOs from the onchain event
     const signerAddress = await Alice.signer.getAddress();
     const events = parseUTXOEvents(zeto, result2.txResult!);
-    expect(events[0].submitter).to.equal(signerAddress);
-    expect(events[0].inputs).to.deep.equal([nullifier1.hash, nullifier2.hash]);
-    expect(events[0].outputs).to.deep.equal([_utxo3.hash, utxo4.hash]);
-    await smtBob.add(events[0].outputs[0], events[0].outputs[0]);
-    await smtBob.add(events[0].outputs[1], events[0].outputs[1]);
-
-    const ecdhPublicKey = events[0].ecdhPublicKey;
+    const event = events[0];
+    expect(event.submitter).to.equal(signerAddress);
+    expect(event.inputs).to.deep.equal([nullifier1.hash, nullifier2.hash]);
+    expect(event.outputs).to.deep.equal([_utxo3.hash, utxo4.hash]);
+    await smtBob.add(event.outputs[0], event.outputs[0]);
+    await smtBob.add(event.outputs[1], event.outputs[1]);
+
+    const ecdhPublicKey = event.ecdhPublicKey;
     // Bob reconstructs the shared key using his private key and ephemeral public key
 
     const sharedKey = genEcdhSharedKey(Bob.babyJubPrivateKey, ecdhPublicKey);
     const plainText = poseidonDecrypt(
-      events[0].encryptedValues.slice(0, 4),
+      event.encryptedValues.slice(0, 4),
       sharedKey,
-      events[0].encryptionNonce,
+      event.encryptionNonce,
       2,
     );
     expect(plainText).to.deep.equal(result2.expectedPlainText.slice(0, 2));
@@ -522,8 +549,9 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
 
     // Alice gets the new UTXOs from the onchain event and keeps the local SMT in sync
     const events = parseUTXOEvents(zeto, result.txResult!);
-    await smtAlice.add(events[0].outputs[0], events[0].outputs[0]);
-    await smtAlice.add(events[0].outputs[1], events[0].outputs[1]);
+    const event = events[0];
+    await smtAlice.add(event.outputs[0], event.outputs[0]);
+    await smtAlice.add(event.outputs[1], event.outputs[1]);
   }).timeout(600000);
 
   it("Alice withdraws her UTXOs to ERC20 tokens should succeed", async function () {
@@ -564,8 +592,7 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
         80,
         nullifiers,
         outputCommitments[0],
-        root.bigInt(),
-        encodedProof,
+        encodeToBytesForWithdraw(root.bigInt(), encodedProof),
         "0x",
       );
     await tx.wait();
@@ -583,8 +610,30 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
   describe("unregistered user cases", function () {
     let unregisteredUtxo100: UTXO;
     let unregisteredUtxo0: UTXO;
+    let smtKycUnregistered: Merkletree;
+
+    before(async function () {
+      const storage5 = new InMemoryDB(str2Bytes("unregisteredKyc"));
+      smtKycUnregistered = new Merkletree(storage5, true, 10);
+
+      // add the unregistered user to the local KYC SMT, but not to the onchain SMT
+      await smtKycUnregistered.add(
+        kycHash(unregistered.babyJubPublicKey),
+        kycHash(unregistered.babyJubPublicKey),
+      );
+    });
+
+    it("deposit by an unregistered user should fail", async function () {
+      const identitiesRoot = await smtKycUnregistered.root();
+      const proof3 = await smtKycUnregistered.generateCircomVerifierProof(
+        kycHash(unregistered.babyJubPublicKey),
+        identitiesRoot,
+      );
+      const identitiesMerkleProofs = [
+        proof3.siblings.map((s) => s.bigInt()),
+        proof3.siblings.map((s) => s.bigInt()),
+      ];
 
-    it("deposit by an unregistered user should succeed", async function () {
       const tx = await erc20
         .connect(deployer)
         .mint(unregistered.ethAddress, 100);
@@ -596,150 +645,22 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
 
       unregisteredUtxo100 = newUTXO(100, unregistered);
       unregisteredUtxo0 = newUTXO(0, unregistered);
-      const { outputCommitments, encodedProof } = await prepareDepositProof(
+      const { outputCommitments, encodedProof } = await prepareDepositKycProof(
         unregistered,
         [unregisteredUtxo100, unregisteredUtxo0],
+        identitiesRoot.bigInt(),
+        identitiesMerkleProofs,
       );
-      const tx2 = await zeto
-        .connect(unregistered.signer)
-        .deposit(100, outputCommitments, encodedProof, "0x");
-      await tx2.wait();
-
-      // Alice tracks the UTXO inside the SMT
-      await smtAlice.add(unregisteredUtxo100.hash, unregisteredUtxo100.hash);
-      await smtAlice.add(unregisteredUtxo0.hash, unregisteredUtxo0.hash);
-      // Bob also locally tracks the UTXOs inside the SMT
-      await smtBob.add(unregisteredUtxo100.hash, unregisteredUtxo100.hash);
-      await smtBob.add(unregisteredUtxo0.hash, unregisteredUtxo0.hash);
-    });
-
-    it("transfer from an unregistered user should fail", async function () {
-      // catch up the local SMT for the unregistered user
-      await smtUnregistered.add(utxo100.hash, utxo100.hash);
-      await smtUnregistered.add(utxo0.hash, utxo0.hash);
-      await smtUnregistered.add(utxo1.hash, utxo1.hash);
-      await smtUnregistered.add(utxo2.hash, utxo2.hash);
-      await smtUnregistered.add(_utxo3.hash, _utxo3.hash);
-      await smtUnregistered.add(utxo4.hash, utxo4.hash);
-      await smtUnregistered.add(utxo6.hash, utxo6.hash);
-      await smtUnregistered.add(utxo7.hash, utxo7.hash);
-      await smtUnregistered.add(
-        withdrawChangeUTXO.hash,
-        withdrawChangeUTXO.hash,
-      );
-      await smtUnregistered.add(
-        unregisteredUtxo100.hash,
-        unregisteredUtxo100.hash,
-      );
-      await smtUnregistered.add(unregisteredUtxo0.hash, unregisteredUtxo0.hash);
-      const utxosRoot = await smtUnregistered.root();
-
-      const nullifier = newNullifier(unregisteredUtxo100, unregistered);
-      const output1 = newUTXO(100, Bob);
-      const output2 = newUTXO(0, unregistered);
-      const proof = await smtUnregistered.generateCircomVerifierProof(
-        unregisteredUtxo100.hash,
-        utxosRoot,
-      );
-      const merkleProofs = [
-        proof.siblings.map((s) => s.bigInt()),
-        proof.siblings.map((s) => s.bigInt()),
-      ];
-
-      // add the unregistered user to the local KYC SMT, but not to the onchain SMT
-      await smtKyc.add(
-        kycHash(unregistered.babyJubPublicKey),
-        kycHash(unregistered.babyJubPublicKey),
-      );
-      const identitiesRoot = await smtKyc.root();
-      const proof3 = await smtKyc.generateCircomVerifierProof(
-        kycHash(unregistered.babyJubPublicKey),
-        identitiesRoot,
-      );
-      const proof4 = await smtKyc.generateCircomVerifierProof(
-        kycHash(Bob.babyJubPublicKey),
-        identitiesRoot,
-      );
-      const identitiesMerkleProofs = [
-        proof3.siblings.map((s) => s.bigInt()), // identity proof for the sender (unregistered)
-        proof4.siblings.map((s) => s.bigInt()), // identity proof for the 1st owner of the output UTXO (Bob)
-        proof3.siblings.map((s) => s.bigInt()), // identity proof for the 2nd owner of the output UTXO (unregistered)
-      ];
       await expect(
-        doTransfer(
-          unregistered,
-          [unregisteredUtxo100, ZERO_UTXO],
-          [nullifier, ZERO_UTXO],
-          [output1, output2],
-          utxosRoot.bigInt(),
-          merkleProofs,
-          identitiesRoot.bigInt(),
-          identitiesMerkleProofs,
-          [Bob, unregistered],
-        ),
-      ).rejectedWith("Invalid proof");
-    });
-
-    it("the unregistered user can still withdraw their UTXOs to ERC20 tokens", async function () {
-      const startingBalance = await erc20.balanceOf(unregistered.ethAddress);
-      // unregistered user generates the nullifiers for the UTXOs to be spent
-      const nullifier1 = newNullifier(unregisteredUtxo100, unregistered);
-
-      // unregistered user generates inclusion proofs for the UTXOs to be spent
-      let root = await smtUnregistered.root();
-      const proof1 = await smtUnregistered.generateCircomVerifierProof(
-        unregisteredUtxo100.hash,
-        root,
-      );
-      const proof2 = await smtUnregistered.generateCircomVerifierProof(
-        0n,
-        root,
-      );
-      const merkleProofs = [
-        proof1.siblings.map((s) => s.bigInt()),
-        proof2.siblings.map((s) => s.bigInt()),
-      ];
-
-      // unregistered user proposes the output ERC20 tokens
-      const unregisteredWithdrawChangeUTXO = newUTXO(0, unregistered);
-
-      const { nullifiers, outputCommitments, encodedProof } =
-        await prepareNullifierWithdrawProof(
-          unregistered,
-          [unregisteredUtxo100, ZERO_UTXO],
-          [nullifier1, ZERO_UTXO],
-          unregisteredWithdrawChangeUTXO,
-          root.bigInt(),
-          merkleProofs,
-        );
-
-      // unregistered user withdraws her UTXOs to ERC20 tokens
-      const tx = await zeto
-        .connect(unregistered.signer)
-        .withdraw(
-          100,
-          nullifiers,
-          outputCommitments[0],
-          root.bigInt(),
-          encodedProof,
-          "0x",
-        );
-      await tx.wait();
-
-      // Alice tracks the UTXO inside the SMT
-      await smtAlice.add(
-        unregisteredWithdrawChangeUTXO.hash,
-        unregisteredWithdrawChangeUTXO.hash,
-      );
-      // Bob also locally tracks the UTXOs inside the SMT
-      await smtBob.add(
-        unregisteredWithdrawChangeUTXO.hash,
-        unregisteredWithdrawChangeUTXO.hash,
-      );
-
-      // unregistered user checks her ERC20 balance
-      const endingBalance = await erc20.balanceOf(unregistered.ethAddress);
-      expect(endingBalance - startingBalance).to.be.equal(100);
+        zeto
+          .connect(unregistered.signer)
+          .deposit(
+            100,
+            outputCommitments,
+            encodeToBytesForDeposit(encodedProof),
+            "0x",
+          ),
+      ).to.be.rejectedWith("VM Exception while processing transaction: reverted with custom error 'InvalidProof()'");
     });
   });
 
@@ -788,8 +709,7 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
             10,
             nullifiers,
             outputCommitments[0],
-            root.bigInt(),
-            encodedProof,
+            encodeToBytesForWithdraw(root.bigInt(), encodedProof),
             "0x",
           ),
       ).rejectedWith("UTXOAlreadySpent");
@@ -1181,11 +1101,13 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
     const 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,
-      encryptionNonce,
-      ecdhPublicKey,
-      encryptedValues,
-      encodedProof,
+      encodeToBytes(
+        root,
+        encryptionNonce,
+        ecdhPublicKey,
+        encryptedValues,
+        encodedProof,
+      ),
       "0x",
     );
     const results: ContractTransactionReceipt | null = await tx.wait();
@@ -1195,3 +1117,22 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
     return results;
   }
 });
+
+function encodeToBytes(
+  root: any,
+  encryptionNonce: any,
+  ecdhPublicKey: any,
+  encryptedValues: any,
+  proof: any,
+) {
+  return new AbiCoder().encode(
+    [
+      "uint256 root",
+      "uint256 encryptionNonce",
+      "uint256[2] ecdhPublicKey",
+      "uint256[] encryptedValues",
+      "tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)",
+    ],
+    [root, encryptionNonce, ecdhPublicKey, encryptedValues, proof],
+  );
+}

package/test/zeto_anon_enc_nullifier_non_repudiation.ts

@@ -15,7 +15,12 @@
 // limitations under the License.
 
 import { ethers, network } from "hardhat";
-import { ContractTransactionReceipt, Signer, BigNumberish } from "ethers";
+import {
+  ContractTransactionReceipt,
+  Signer,
+  BigNumberish,
+  AbiCoder,
+} from "ethers";
 import { expect } from "chai";
 import {
   loadCircuit,
@@ -46,11 +51,15 @@ import {
   loadProvingKeys,
   prepareDepositProof,
   prepareNullifierWithdrawProof,
+  encodeToBytesForDeposit,
+  encodeToBytesForWithdraw,
 } from "./utils";
 import { deployZeto } from "./lib/deploy";
 const poseidonHash = Poseidon.poseidon4;
 
-describe("Zeto based fungible token with anonymity using nullifiers and encryption for non-repudiation", function () {
+describe(
+  "Zeto based fungible token with anonymity using nullifiers and encryption for non-repudiation",
+  function () {
   let deployer: Signer;
   let Alice: User;
   let Bob: User;
@@ -177,12 +186,13 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
 
     const signerAddress = await Alice.signer.getAddress();
     const events = parseUTXOEvents(zeto, result.txResult!);
-    expect(events[0].submitter).to.equal(signerAddress);
-    expect(events[0].inputs).to.deep.equal(nullifiers.map((n) => n.hash));
+    const event = events[0];
+    expect(event.submitter).to.equal(signerAddress);
+    expect(event.inputs).to.deep.equal(nullifiers.map((n) => n.hash));
 
-    const incomingUTXOs: any = events[0].outputs;
+    const incomingUTXOs: any = event.outputs;
 
-    const ecdhPublicKey = events[0].ecdhPublicKey;
+    const ecdhPublicKey = event.ecdhPublicKey;
 
     // check the non-empty output hashes are correct
     for (let i = 0; i < outputUtxos.length; i++) {
@@ -192,9 +202,9 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
         ecdhPublicKey,
       );
       const plainText = poseidonDecrypt(
-        events[0].encryptedValuesForReceiver.slice(4 * i, 4 * i + 4),
+        event.encryptedValuesForReceiver.slice(4 * i, 4 * i + 4),
         sharedKey,
-        events[0].encryptionNonce,
+        event.encryptionNonce,
         2,
       );
       expect(plainText).to.deep.equal(
@@ -210,20 +220,15 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
       await smtAlice.add(incomingUTXOs[i], incomingUTXOs[i]);
       await smtBob.add(incomingUTXOs[i], incomingUTXOs[i]);
     }
-
-    // check empty values, salt and hashes are empty
-    for (let i = outputUtxos.length; i < 10; i++) {
-      expect(incomingUTXOs[i]).to.equal(0);
-    }
     // The regulator uses the encrypted values in the event to decrypt and recover the UTXO value and salt
     const auditKey = genEcdhSharedKey(
       Authority.babyJubPrivateKey,
       ecdhPublicKey,
     );
     const auditPlainText = poseidonDecrypt(
-      events[0].encryptedValuesForAuthority,
+      event.encryptedValuesForAuthority,
       auditKey,
-      events[0].encryptionNonce,
+      event.encryptionNonce,
       62,
     );
 
@@ -252,12 +257,6 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
       expect(calHash).to.equal(outputUtxos[i].hash);
     }
 
-    // check empty hashes are empty
-    for (let i = outputUtxos.length; i < 10; i++) {
-      expect(auditPlainText[2 * i + 42]).to.equal(0);
-      expect(auditPlainText[2 * i + 43]).to.equal(0);
-    }
-
     // mint sufficient balance in Zeto contract address for Alice to withdraw
     const mintTx = await erc20.connect(deployer).mint(zeto, 3);
     await mintTx.wait();
@@ -310,8 +309,7 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
         3,
         _withdrawNullifiers,
         withdrawCommitments[0],
-        root.bigInt(),
-        withdrawEncodedProof,
+        encodeToBytesForWithdraw(root.bigInt(), withdrawEncodedProof),
         "0x",
       );
     await tx.wait();
@@ -339,7 +337,12 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
     );
     const tx2 = await zeto
       .connect(Alice.signer)
-      .deposit(100, outputCommitments, encodedProof, "0x");
+      .deposit(
+        100,
+        outputCommitments,
+        encodeToBytesForDeposit(encodedProof),
+        "0x",
+      );
     await tx2.wait();
 
     await smtAlice.add(utxo100.hash, utxo100.hash);
@@ -414,20 +417,21 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
     // Bob parses the UTXOs from the onchain event
     const signerAddress = await Alice.signer.getAddress();
     const events = parseUTXOEvents(zeto, result2.txResult!);
-    expect(events[0].submitter).to.equal(signerAddress);
-    expect(events[0].inputs).to.deep.equal([nullifier1.hash, nullifier2.hash]);
-    expect(events[0].outputs).to.deep.equal([_utxo3.hash, utxo4.hash]);
-    await smtBob.add(events[0].outputs[0], events[0].outputs[0]);
-    await smtBob.add(events[0].outputs[1], events[0].outputs[1]);
-
-    const ecdhPublicKey = events[0].ecdhPublicKey;
+    const event = events[0];
+    expect(event.submitter).to.equal(signerAddress);
+    expect(event.inputs).to.deep.equal([nullifier1.hash, nullifier2.hash]);
+    expect(event.outputs).to.deep.equal([_utxo3.hash, utxo4.hash]);
+    await smtBob.add(event.outputs[0], event.outputs[0]);
+    await smtBob.add(event.outputs[1], event.outputs[1]);
+
+    const ecdhPublicKey = event.ecdhPublicKey;
     // Bob reconstructs the shared key using his private key and ephemeral public key
 
     const sharedKey = genEcdhSharedKey(Bob.babyJubPrivateKey, ecdhPublicKey);
     const plainText1 = poseidonDecrypt(
-      events[0].encryptedValuesForReceiver.slice(0, 4),
+      event.encryptedValuesForReceiver.slice(0, 4),
       sharedKey,
-      events[0].encryptionNonce,
+      event.encryptionNonce,
       2,
     );
     expect(plainText1).to.deep.equal(result2.expectedPlainText.slice(0, 2));
@@ -441,9 +445,9 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
       ecdhPublicKey,
     );
     const plainText2 = poseidonDecrypt(
-      events[0].encryptedValuesForAuthority,
+      event.encryptedValuesForAuthority,
       sharedKey2,
-      events[0].encryptionNonce,
+      event.encryptionNonce,
       14,
     );
     expect(plainText2).to.deep.equal([
@@ -527,8 +531,9 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
 
     // Alice gets the new UTXOs from the onchain event and keeps the local SMT in sync
     const events = parseUTXOEvents(zeto, result.txResult!);
-    await smtAlice.add(events[0].outputs[0], events[0].outputs[0]);
-    await smtAlice.add(events[0].outputs[1], events[0].outputs[1]);
+    const event = events[0];
+    await smtAlice.add(event.outputs[0], event.outputs[0]);
+    await smtAlice.add(event.outputs[1], event.outputs[1]);
   }).timeout(600000);
 
   it("Alice withdraws her UTXOs to ERC20 tokens should succeed", async function () {
@@ -568,8 +573,7 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
         80,
         nullifiers,
         outputCommitments[0],
-        root.bigInt(),
-        encodedProof,
+        encodeToBytesForWithdraw(root.bigInt(), encodedProof),
         "0x",
       );
     await tx.wait();
@@ -629,8 +633,7 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
             80,
             nullifiers,
             outputCommitments[0],
-            root.bigInt(),
-            encodedProof,
+            encodeToBytesForWithdraw(root.bigInt(), encodedProof),
             "0x",
           ),
       ).rejectedWith("UTXOAlreadySpent");
@@ -944,12 +947,14 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
     const 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,
-      encryptionNonce,
-      ecdhPublicKey,
-      encryptedValuesForReceiver,
-      encryptedValuesForRegulator,
-      encodedProof,
+      encodeToBytes(
+        root,
+        encryptionNonce,
+        ecdhPublicKey,
+        encryptedValuesForReceiver,
+        encryptedValuesForRegulator,
+        encodedProof,
+      ),
       "0x",
     );
     const results: ContractTransactionReceipt | null = await tx.wait();
@@ -959,3 +964,31 @@ describe("Zeto based fungible token with anonymity using nullifiers and encrypti
     return results;
   }
 });
+
+function encodeToBytes(
+  root: any,
+  encryptionNonce: any,
+  ecdhPublicKey: any,
+  encryptedValuesForReceiver: any,
+  encryptedValuesForAuthority: any,
+  proof: any,
+) {
+  return new AbiCoder().encode(
+    [
+      "uint256 root",
+      "uint256 encryptionNonce",
+      "uint256[2] ecdhPublicKey",
+      "uint256[] encryptedValuesForReceiver",
+      "uint256[] encryptedValuesForAuthority",
+      "tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)",
+    ],
+    [
+      root,
+      encryptionNonce,
+      ecdhPublicKey,
+      encryptedValuesForReceiver,
+      encryptedValuesForAuthority,
+      proof,
+    ],
+  );
+}