@lfdecentralizedtrust/zeto-contracts 0.2.2 → 0.5.1

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,9 +10,12 @@ import {
   deployNonFungible as deployNonFungibleCloneable,
 } from "../../scripts/deploy_cloneable";
 import fungibilities from "../../scripts/tokens.json";
+import { logger } from "./utils";
 import { ethers } from "hardhat";
+import { assertEip170Compliant } from "./eip170";
 
 export async function deployZeto(tokenName: string) {
+  await assertEip170Compliant(tokenName);
   let zeto, erc20, deployer;
 
   // for testing with public chains, skip deployment if
@@ -34,7 +37,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 +45,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/eip170.ts

@@ -0,0 +1,23 @@
+import { artifacts } from "hardhat";
+import {
+  EIP170_BYTE_LIMIT,
+  EIP170_EXEMPT_TOKEN_SET,
+} from "../../config/eip170";
+
+/**
+ * Assert a token implementation fits EIP-170 before deploy when it is not exempt.
+ * Hardhat Network runs with allowUnlimitedContractSize enabled (see hardhat.config.ts);
+ * exempt tokens may exceed the limit.
+ */
+export async function assertEip170Compliant(tokenName: string): Promise<void> {
+  if (EIP170_EXEMPT_TOKEN_SET.has(tokenName)) {
+    return;
+  }
+  const artifact = await artifacts.readArtifact(tokenName);
+  const deployedBytes = (artifact.deployedBytecode.length - 2) / 2;
+  if (deployedBytes > EIP170_BYTE_LIMIT) {
+    throw new Error(
+      `${tokenName} deployed bytecode is ${deployedBytes} bytes, exceeding EIP-170 limit ${EIP170_BYTE_LIMIT}`,
+    );
+  }
+}

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