@lfdecentralizedtrust/zeto-contracts 0.2.2 → 0.5.0

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

package/test/lib/anon_zeto_helpers.ts

@@ -0,0 +1,76 @@
+// Copyright © 2024 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Shared ZK helpers for the plain `anon` circuit (non-nullifier tokens such as
+// {Zeto_Anon}). Kept separate from `zeto_anon.ts` so escrow and other suites
+// can import these without registering the full Zeto_Anon Hardhat test module.
+
+import { AbiCoder, BigNumberish } from "ethers";
+import { encodeProof } from "zeto-js";
+import { groth16 } from "snarkjs";
+import { formatPrivKeyForBabyJub, stringifyBigInts } from "maci-crypto";
+import { User, UTXO, logger, ZERO_UTXO } from "./utils";
+
+const ZERO_PUBKEY = [0n, 0n];
+
+export async function prepareProof(
+  circuit: any,
+  provingKey: any,
+  signer: User,
+  inputs: UTXO[],
+  outputs: UTXO[],
+  owners: User[],
+) {
+  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 outputSalts = outputs.map((o) => o.salt || 0n);
+  const outputOwnerPublicKeys: BigNumberish[][] = owners.map(
+    (owner) => owner.babyJubPublicKey || ZERO_PUBKEY,
+  ) as BigNumberish[][];
+  const otherInputs = stringifyBigInts({
+    inputOwnerPrivateKey: formatPrivKeyForBabyJub(signer.babyJubPrivateKey),
+  });
+
+  const startWitnessCalculation = Date.now();
+  const witness = await circuit.calculateWTNSBin(
+    {
+      inputCommitments,
+      inputValues,
+      inputSalts,
+      outputCommitments,
+      outputValues,
+      outputSalts,
+      outputOwnerPublicKeys,
+      ...otherInputs,
+    },
+    true,
+  );
+  const timeWitnessCalculation = Date.now() - startWitnessCalculation;
+
+  const startProofGeneration = Date.now();
+  const { proof, publicSignals } = (await groth16.prove(
+    provingKey,
+    witness,
+  )) as { proof: BigNumberish[]; publicSignals: BigNumberish[] };
+  const timeProofGeneration = Date.now() - startProofGeneration;
+  logger.debug(
+    `Witness calculation time: ${timeWitnessCalculation}ms, Proof generation time: ${timeProofGeneration}ms`,
+  );
+  const encodedProof = encodeProof(proof);
+  return encodedProof;
+}
+
+export function encodeToBytes(proof: any) {
+  return new AbiCoder().encode(
+    ["tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)"],
+    [proof],
+  );
+}

package/test/lib/deploy.ts

@@ -10,6 +10,7 @@ import {
   deployNonFungible as deployNonFungibleCloneable,
 } from "../../scripts/deploy_cloneable";
 import fungibilities from "../../scripts/tokens.json";
+import { logger } from "./utils";
 import { ethers } from "hardhat";
 
 export async function deployZeto(tokenName: string) {
@@ -34,7 +35,7 @@ export async function deployZeto(tokenName: string) {
   }
 
   if (process.env.USE_FACTORY !== "true") {
-    console.log("Deploying as upgradeable contracts");
+    logger.debug("Deploying as upgradeable contracts");
     // setup via the deployment scripts
     const deployFunc = isFungible
       ? deployFungibleUpgradeable
@@ -42,7 +43,7 @@ export async function deployZeto(tokenName: string) {
     const result = await deployFunc(tokenName);
     ({ deployer, zeto, erc20 } = result as any);
   } else {
-    console.log('Deploying as cloneable contracts using "ZetoTokenFactory"');
+    logger.debug('Deploying as cloneable contracts using "ZetoTokenFactory"');
     let args, zetoImpl;
     const deployFunc = isFungible
       ? deployFungibleCloneable

package/test/lib/utils.ts

@@ -18,13 +18,15 @@ import {
   ContractTransactionReceipt,
   Signer,
   BigNumberish,
-  AddressLike,
 } from "ethers";
 import {
   genKeypair,
   formatPrivKeyForBabyJub,
-  genEcdhSharedKey,
 } from "maci-crypto";
+import { Logger, ILogObj } from "tslog";
+const logLevel = process.env.LOG_LEVEL || "3";
+export const logger: Logger<ILogObj> = new Logger({ name: "e2e", minLevel: parseInt(logLevel) });
+
 import { Poseidon, newSalt, tokenUriHash } from "zeto-js";
 
 const poseidonHash3 = Poseidon.poseidon3;
@@ -35,18 +37,18 @@ export interface UTXO {
   value?: number;
   tokenId?: number;
   uri?: string;
-  hash: BigInt;
-  salt?: BigInt;
+  hash: bigint;
+  salt?: bigint;
 }
 
-export const ZERO_UTXO: UTXO = { hash: BigInt(0) };
+export const ZERO_UTXO: UTXO = { hash: 0n };
 
 export interface User {
   signer: Signer;
   ethAddress: string;
-  babyJubPrivateKey: BigInt;
-  babyJubPublicKey: BigInt[];
-  formattedPrivateKey: BigInt;
+  babyJubPrivateKey: bigint;
+  babyJubPublicKey: bigint[];
+  formattedPrivateKey: bigint;
 }
 
 export async function newUser(signer: Signer) {
@@ -62,7 +64,7 @@ export async function newUser(signer: Signer) {
   };
 }
 
-export function newUTXO(value: number, owner: User, salt?: BigInt): UTXO {
+export function newUTXO(value: number, owner: User, salt?: bigint): UTXO {
   if (!salt) salt = newSalt();
   const hash = poseidonHash4([
     BigInt(value),
@@ -77,7 +79,7 @@ export function newAssetUTXO(
   tokenId: number,
   uri: string,
   owner: User,
-  salt?: BigInt,
+  salt?: bigint,
 ): UTXO {
   if (!salt) salt = newSalt();
   const hash = poseidonHash5([
@@ -122,10 +124,13 @@ export async function doMint(
     .connect(minter)
     .mint(outputCommitments, "0x");
   const result = await tx.wait();
-  console.log(`Method mint() complete. Gas used: ${result?.gasUsed}`);
+  logger.debug(`Method mint() complete. Gas used: ${result?.gasUsed}`);
   if (result?.gasUsed && Array.isArray(gasHistories)) {
     gasHistories.push(result?.gasUsed);
   }
+  if (!result) {
+    throw new Error("doMint: transaction receipt is null");
+  }
   return result;
 }
 
@@ -141,10 +146,13 @@ export async function doDeposit(
     .connect(depositUser)
     .deposit(amount, commitment, proof, "0x");
   const result = await tx.wait();
-  console.log(`Method deposit() complete. Gas used: ${result?.gasUsed}`);
+  logger.debug(`Method deposit() complete. Gas used: ${result?.gasUsed}`);
   if (result?.gasUsed && Array.isArray(gasHistories)) {
     gasHistories.push(result?.gasUsed);
   }
+  if (!result) {
+    throw new Error("doDeposit: transaction receipt is null");
+  }
   return result;
 }
 
@@ -162,17 +170,23 @@ export async function doWithdraw(
     .connect(withdrawUser)
     .withdraw(amount, nullifiers, commitment, root, proof);
   const result = await tx.wait();
-  console.log(`Method withdraw() complete. Gas used: ${result?.gasUsed}`);
+  logger.debug(`Method withdraw() complete. Gas used: ${result?.gasUsed}`);
   if (result?.gasUsed && Array.isArray(gasHistories)) {
     gasHistories.push(result?.gasUsed);
   }
+  if (!result) {
+    throw new Error("doWithdraw: transaction receipt is null");
+  }
   return result;
 }
 
 export function parseUTXOEvents(
   zetoTokenContract: any,
-  result: ContractTransactionReceipt,
+  result: ContractTransactionReceipt | null,
 ) {
+  if (!result) {
+    throw new Error("parseUTXOEvents: transaction receipt is null");
+  }
   let returnValues: any[] = [];
   for (const log of result.logs || []) {
     const event = zetoTokenContract.interface.parseLog(log as any);
@@ -183,6 +197,13 @@ export function parseUTXOEvents(
         outputs: event?.args.outputs,
         submitter: event?.args.submitter,
       };
+    } else if (event?.name === "UTXOTransferLocked") {
+      e = {
+        lockedInputs: event?.args.lockedInputs,
+        lockedOutputs: event?.args.lockedOutputs,
+        outputs: event?.args.outputs,
+        submitter: event?.args.submitter,
+      };
     } else if (event?.name === "UTXOTransferWithEncryptedValues") {
       e = {
         inputs: event?.args.inputs,
@@ -192,6 +213,15 @@ export function parseUTXOEvents(
         submitter: event?.args.submitter,
         ecdhPublicKey: event?.args.ecdhPublicKey,
       };
+    } else if (event?.name === "UTXOTransferWithMlkemEncryptedValues") {
+      e = {
+        inputs: event?.args.inputs,
+        outputs: event?.args.outputs,
+        encryptedValues: event?.args.encryptedValues,
+        encryptionNonce: event?.args.encryptionNonce,
+        submitter: event?.args.submitter,
+        encapsulatedSharedSecret: event?.args.encapsulatedSharedSecret,
+      };
     } else if (event?.name === "UTXOTransferNonRepudiation") {
       e = {
         inputs: event?.args.inputs,
@@ -208,36 +238,45 @@ export function parseUTXOEvents(
         receivers: event?.args.receivers,
         submitter: event?.args.submitter,
       };
-    } else if (event?.name === "TradeCompleted") {
+    } else if (event?.name === "UTXOWithdraw") {
       e = {
-        tradeId: event?.args.tradeId,
-        trade: event?.args.trade,
+        amount: event?.args.amount,
+        inputs: event?.args.inputs,
+        output: event?.args.output,
       };
-    } else if (event?.name === "UTXOsLocked") {
+    } else if (event?.name === "LockCreate") {
       e = {
-        outputs: event?.args.outputs,
-        lockedOutputs: event?.args.lockedOutputs,
-        delegate: event?.args.delegate,
+        lockId: event?.args.lockId,
+        lockData: event?.args.lockData,
       };
-    } else if (event?.name === "LockDelegateChanged") {
+    } else if (event?.name === "UnlockPrepare") {
       e = {
-        lockedOutputs: event?.args.lockedOutputs,
-        oldDelegate: event?.args.oldDelegate,
-        newDelegate: event?.args.newDelegate,
+        lockId: event?.args.lockId,
+        operator: event?.args.operator,
+        settle: event?.args.settle,
       };
-    } else if (event?.name === "PaymentInitiated") {
+    } else if (event?.name === "Unlock") {
       e = {
-        paymentId: event?.args.paymentId,
-        lockedInputs: event?.args.lockedInputs,
-        nullifiers: event?.args.nullifiers,
-        outputs: event?.args.outputs,
+        lockId: event?.args.lockId,
+        operator: event?.args.operator,
+        inputs: event?.args.inputs,
+        delegate: event?.args.delegate,
+        settle: event?.args.settle,
       };
-    } else if (
-      event?.name === "PaymentApproved" ||
-      event?.name === "PaymentCompleted"
-    ) {
+    } else if (event?.name === "LockRollback") {
       e = {
-        paymentId: event?.args.paymentId,
+        lockId: event?.args.lockId,
+        operator: event?.args.operator,
+        inputs: event?.args.inputs,
+        delegate: event?.args.delegate,
+        rollback: event?.args.rollback,
+      };
+    } else if (event?.name === "LockDelegate") {
+      e = {
+        lockId: event?.args.lockId,
+        operator: event?.args.operator,
+        oldDelegate: event?.args.oldDelegate,
+        newDelegate: event?.args.newDelegate,
       };
     }
     returnValues.push(e);