@lfdecentralizedtrust/zeto-contracts 0.2.2 → 0.5.1

package/test/utils.ts

@@ -16,12 +16,10 @@
 
 import { readFileSync } from "fs";
 import * as path from "path";
-import crypto from "crypto";
-import { BigNumberish } from "ethers";
+import { AbiCoder, BigNumberish, keccak256, toUtf8Bytes } from "ethers";
 import { groth16 } from "snarkjs";
-import { loadCircuit, encodeProof, tokenUriHash } from "zeto-js";
-import { User, UTXO } from "./lib/utils";
-import { formatPrivKeyForBabyJub, stringifyBigInts } from "maci-crypto";
+import { loadCircuit, encodeProof } from "zeto-js";
+import { User, UTXO, ZERO_UTXO, logger } from "./lib/utils";
 
 function provingKeysRoot() {
   const PROVING_KEYS_ROOT = process.env.PROVING_KEYS_ROOT;
@@ -44,6 +42,24 @@ export function loadProvingKeys(type: string) {
   };
 }
 
+export function inflateUtxos(outputUtxos: UTXO[]) {
+  const desiredLength = outputUtxos.length > 2 ? 10 : 2;
+  const inflatedOutputUtxos = [...outputUtxos];
+  for (let i = 0; i < desiredLength - outputUtxos.length; i++) {
+    inflatedOutputUtxos.push(ZERO_UTXO);
+  }
+  return inflatedOutputUtxos;
+}
+
+export function inflateOwners(owners: User[]) {
+  const desiredLength = owners.length > 2 ? 10 : 2;
+  const inflatedOwners = [...owners];
+  for (let i = 0; i < desiredLength - owners.length; i++) {
+    inflatedOwners.push(owners[0]); // use a random owner for the extra utxos
+  }
+  return inflatedOwners;
+}
+
 export async function prepareDepositProof(signer: User, outputs: [UTXO, UTXO]) {
   const outputCommitments: [BigNumberish, BigNumberish] = [
     outputs[0].hash,
@@ -60,10 +76,10 @@ export async function prepareDepositProof(signer: User, outputs: [UTXO, UTXO]) {
   const outputOwnerPublicKeys: [
     [BigNumberish, BigNumberish],
     [BigNumberish, BigNumberish],
-  ] = [signer.babyJubPublicKey, outputs[1].hash ? signer.babyJubPublicKey : [0n, 0n]] as [
-    [BigNumberish, BigNumberish],
-    [BigNumberish, BigNumberish],
-  ];
+  ] = [
+    signer.babyJubPublicKey,
+    outputs[1].hash ? signer.babyJubPublicKey : [0n, 0n],
+  ] as [[BigNumberish, BigNumberish], [BigNumberish, BigNumberish]];
 
   const inputObj = {
     outputCommitments,
@@ -86,7 +102,67 @@ export async function prepareDepositProof(signer: User, outputs: [UTXO, UTXO]) {
   )) as { proof: BigNumberish[]; publicSignals: BigNumberish[] };
   const timeProofGeneration = Date.now() - startProofGeneration;
 
-  console.log(
+  logger.debug(
+    `Witness calculation time: ${timeWithnessCalculation}ms. Proof generation time: ${timeProofGeneration}ms.`,
+  );
+
+  const encodedProof = encodeProof(proof);
+  return {
+    outputCommitments,
+    encodedProof,
+  };
+}
+
+export async function prepareDepositKycProof(
+  signer: User,
+  outputs: [UTXO, UTXO],
+  identitiesRoot: BigInt,
+  identitiesMerkleProof: BigInt[][],
+) {
+  const outputCommitments: [BigNumberish, BigNumberish] = [
+    outputs[0].hash,
+    outputs[1].hash,
+  ] as [BigNumberish, BigNumberish];
+  const outputValues = [
+    BigInt(outputs[0].value || 0),
+    BigInt(outputs[1].value || 0),
+  ];
+  const outputSalts = [
+    BigInt(outputs[0].salt || 0n),
+    BigInt(outputs[1].salt || 0n),
+  ];
+  const outputOwnerPublicKeys: [
+    [BigNumberish, BigNumberish],
+    [BigNumberish, BigNumberish],
+  ] = [
+    signer.babyJubPublicKey,
+    outputs[1].hash ? signer.babyJubPublicKey : [0n, 0n],
+  ] as [[BigNumberish, BigNumberish], [BigNumberish, BigNumberish]];
+
+  const inputObj = {
+    outputCommitments,
+    outputValues,
+    outputSalts,
+    outputOwnerPublicKeys,
+    identitiesRoot,
+    identitiesMerkleProof,
+  };
+
+  const circuit = await loadCircuit("deposit_kyc");
+  const { provingKeyFile } = loadProvingKeys("deposit_kyc");
+
+  const startWitnessCalculation = Date.now();
+  const witness = await circuit.calculateWTNSBin(inputObj, true);
+  const timeWithnessCalculation = Date.now() - startWitnessCalculation;
+
+  const startProofGeneration = Date.now();
+  const { proof, publicSignals } = (await groth16.prove(
+    provingKeyFile,
+    witness,
+  )) as { proof: BigNumberish[]; publicSignals: BigNumberish[] };
+  const timeProofGeneration = Date.now() - startProofGeneration;
+
+  logger.debug(
     `Witness calculation time: ${timeWithnessCalculation}ms. Proof generation time: ${timeProofGeneration}ms.`,
   );
 
@@ -142,7 +218,7 @@ export async function prepareWithdrawProof(
   )) as { proof: BigNumberish[]; publicSignals: BigNumberish[] };
   const timeProofGeneration = Date.now() - startProofGeneration;
 
-  console.log(
+  logger.debug(
     `Witness calculation time: ${timeWithnessCalculation}ms. Proof generation time: ${timeProofGeneration}ms.`,
   );
 
@@ -208,7 +284,7 @@ export async function prepareNullifierWithdrawProof(
   )) as { proof: BigNumberish[]; publicSignals: BigNumberish[] };
   const timeProofGeneration = Date.now() - startProofGeneration;
 
-  console.log(
+  logger.debug(
     `Witness calculation time: ${timeWithnessCalculation}ms. Proof generation time: ${timeProofGeneration}ms.`,
   );
 
@@ -259,7 +335,7 @@ export async function prepareBurnProof(
   )) as { proof: BigNumberish[]; publicSignals: BigNumberish[] };
   const timeProofGeneration = Date.now() - startProofGeneration;
 
-  console.log(
+  logger.debug(
     `Witness calculation time: ${timeWithnessCalculation}ms. Proof generation time: ${timeProofGeneration}ms.`,
   );
 
@@ -320,7 +396,7 @@ export async function prepareNullifierBurnProof(
   )) as { proof: BigNumberish[]; publicSignals: BigNumberish[] };
   const timeProofGeneration = Date.now() - startProofGeneration;
 
-  console.log(
+  logger.debug(
     `Witness calculation time: ${timeWithnessCalculation}ms. Proof generation time: ${timeProofGeneration}ms.`,
   );
 
@@ -333,11 +409,58 @@ export async function prepareNullifierBurnProof(
   };
 }
 
-export function randomBytesAsDigitArray(length: number) {
-  const bytes = crypto.randomBytes(length);
-  let s = "";
-  for (let i = 0; i < bytes.length; i++) {
-    s += bytes[i].toString(2).padStart(8, "0");
-  }
-  return s.split("").map((b) => parseInt(b));
+export function encodeToBytesForDeposit(proof: any) {
+  return new AbiCoder().encode(
+    ["tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)"],
+    [proof],
+  );
+}
+
+export function encodeToBytesForWithdraw(root: any, proof: any) {
+  return new AbiCoder().encode(
+    ["uint256 root", "tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)"],
+    [root, proof],
+  );
 }
+
+// Domain-separation tags mirroring `_SPEND_HASH_DOMAIN` /
+// `_CANCEL_HASH_DOMAIN` in `lib/zeto_fungible.sol`. Keep these strings
+// in sync with the on-chain constants; otherwise computed commitments
+// will not match what the contract expects.
+const SPEND_HASH_DOMAIN = keccak256(toUtf8Bytes("Zeto.spendCommitment.v1"));
+const CANCEL_HASH_DOMAIN = keccak256(toUtf8Bytes("Zeto.cancelCommitment.v1"));
+
+function buildUnlockHash(
+  lockedInputs: UTXO[],
+  lockedOutputs: UTXO[],
+  outputs: UTXO[],
+  data: any,
+  domain: string,
+) {
+  const abiCoder = new AbiCoder();
+  // Hash each dynamic component with `abi.encode` rather than
+  // `abi.encodePacked` so dynamic-length arrays cannot collide
+  // (mirrors `_buildUnlockHash` in zeto_fungible.sol).
+  return keccak256(
+    abiCoder.encode(
+      ["bytes32", "bytes32", "bytes32", "bytes32", "bytes32"],
+      [
+        domain,
+        keccak256(abiCoder.encode(["uint256[]"], [lockedInputs.map((utxo) => utxo.hash)])),
+        keccak256(abiCoder.encode(["uint256[]"], [lockedOutputs.map((utxo) => utxo.hash)])),
+        keccak256(abiCoder.encode(["uint256[]"], [outputs.map((utxo) => utxo.hash)])),
+        keccak256(data),
+      ],
+    ),
+  );
+}
+
+/// Mirror of `IZetoLockableCapability.computeSpendHash`.
+export function calculateSpendHash(lockedInputs: UTXO[], lockedOutputs: UTXO[], outputs: UTXO[], data: any) {
+  return buildUnlockHash(lockedInputs, lockedOutputs, outputs, data, SPEND_HASH_DOMAIN);
+}
+
+/// Mirror of `IZetoLockableCapability.computeCancelHash`.
+export function calculateCancelHash(lockedInputs: UTXO[], lockedOutputs: UTXO[], outputs: UTXO[], data: any) {
+  return buildUnlockHash(lockedInputs, lockedOutputs, outputs, data, CANCEL_HASH_DOMAIN);
+}