@lfdecentralizedtrust/zeto-contracts 0.2.2 → 0.5.1

package/test/test/escrow1.ts

@@ -15,11 +15,16 @@
 // 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 zkEscrowModule from "../../ignition/modules/test/escrow1";
-import zetoAnonTests from "../zeto_anon";
+import { prepareProof } from "../lib/anon_zeto_helpers";
 import {
   UTXO,
   User,
@@ -27,11 +32,36 @@ import {
   newUTXO,
   doMint,
   ZERO_UTXO,
-  parseUTXOEvents,
+  logger,
 } from "../lib/utils";
 import { loadProvingKeys } from "../utils";
 import { deployZeto } from "../lib/deploy";
 
+// ABI fragments for the ZetoLockableCapability *Args payloads.
+// These mirror the canonical encodings used by every Zeto token that
+// implements ILockableCapability.
+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_Anon", function () {
   let Alice: User;
   let Bob: User;
@@ -48,6 +78,7 @@ describe("Escrow flow for payment with Zeto_Anon", function () {
   // UTXOs involved in the escrow flow
   let lockedPayment1: UTXO;
   let paymentToBob: UTXO;
+  let lockId: string;
 
   // other variables
   let deployer: Signer;
@@ -66,11 +97,15 @@ describe("Escrow flow for payment with Zeto_Anon", function () {
     Bob = await newUser(b);
     Charlie = await newUser(c);
 
+    // The Zeto_Anon token uses the same `anon` circuit for both regular
+    // transfers and the locked-input branch (the lockVerifier is wired
+    // to Groth16Verifier_Anon in the ignition module). One circuit/key
+    // pair therefore covers both the createLock and spendLock proofs.
     circuit = await loadCircuit("anon");
     ({ provingKeyFile: provingKey } = loadProvingKeys("anon"));
 
     ({ deployer, zeto: zkPayment } = await deployZeto("Zeto_Anon"));
-    console.log(`ZK Payment contract deployed at ${zkPayment.target}`);
+    logger.debug(`ZK Payment contract deployed at ${zkPayment.target}`);
     ({ zkEscrow } = await ignition.deploy(zkEscrowModule, {
       parameters: {
         zkEscrow1: {
@@ -85,62 +120,101 @@ describe("Escrow flow for payment with Zeto_Anon", 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
+    // simulate Alice and Bob listening to minting events and updating
+    // their local merkle trees
     for (const log of result.logs) {
       const event = zkPayment.interface.parseLog(log as any);
       expect(event.args.outputs.length).to.equal(2);
     }
   });
 
-  it("Alice locks some payment tokens and designates the escrow as the delegate", async function () {
+  it("Alice locks payment1 by calling createLock on the Zeto token", async function () {
+    // The locked output preserves the value but is a fresh commitment
+    // (new salt). The createLock proof attests to the standard transfer
+    // payment1 -> lockedPayment1.
     lockedPayment1 = newUTXO(payment1.value!, Alice);
-    const { inputCommitments, outputCommitments, encodedProof } =
-      await zetoAnonTests.prepareProof(
-        circuit,
-        provingKey,
-        Alice,
-        [payment1, ZERO_UTXO],
-        [lockedPayment1, ZERO_UTXO],
-        [Alice, {}],
-      );
+    const encodedZkProof = await prepareProof(
+      circuit,
+      provingKey,
+      Alice,
+      [payment1, ZERO_UTXO],
+      [lockedPayment1, ZERO_UTXO],
+      [Alice, {}],
+    );
+
+    const createArgs = encodeCreateArgs({
+      txId: randomBytes32(),
+      inputs: [payment1.hash],
+      // For the fungible Zeto_Anon createLock, lockedOutputs holds the
+      // freshly-locked UTXO and outputs is empty (no change is being
+      // returned to Alice, since payment1's full value is moved into
+      // the lock).
+      outputs: [],
+      lockedOutputs: [lockedPayment1.hash],
+      proof: encodeProofOnly(encodedZkProof),
+    });
+
+    // Pre-compute the lockId off-chain to assert the contract derives
+    // the same value (deterministic from caller + txId).
+    lockId = await zkPayment.connect(Alice.signer).computeLockId(createArgs);
+
+    const tx = await zkPayment
+      .connect(Alice.signer)
+      .createLock(createArgs, ethers.ZeroHash, ethers.ZeroHash, "0x");
+    const result: ContractTransactionReceipt | null = await tx.wait();
+    logger.debug(`createLock() complete. Gas used: ${result?.gasUsed}`);
+
+    // Sanity-check the lock state after creation.
+    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,
+    ]);
+  });
+
+  it("Alice delegates the lock to the escrow contract", async function () {
     const tx = await zkPayment
       .connect(Alice.signer)
-      .lock(
-        inputCommitments,
-        [],
-        outputCommitments,
-        encodedProof,
+      .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
-    expect(lockedUTXO).to.equal(lockedPayment1.hash);
-    expect(lockDelegate).to.equal(zkEscrow.target);
+    await tx.wait();
+
+    // After delegation the escrow is the sole spender; Alice can no
+    // longer spend the lock directly.
+    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 () {
-    paymentToBob = newUTXO(lockedPayment1.value!, Bob, lockedPayment1.salt);
+    paymentToBob = newUTXO(lockedPayment1.value!, Bob);
     const tx = await zkEscrow
       .connect(Alice.signer)
-      .initiatePayment([lockedPayment1.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];
-    const check = newUTXO(lockedPayment1.value!, Bob, lockedPayment1.salt);
-    expect(proposedPayment).to.equal(check.hash);
-    paymentId = events[0].paymentId;
+    const initiated = parseEscrowEvent(zkEscrow, result, "PaymentInitiated");
+    expect(initiated, "PaymentInitiated event not emitted").to.not.be.undefined;
+
+    // Bob listens to the payment events and verifies the proposed
+    // payment matches what Alice promised off-chain.
+    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 () {
-    const { encodedProof } = await zetoAnonTests.prepareProof(
+  it("Alice approves the payment by submitting a valid locked-input proof", async function () {
+    // The spend proof transfers lockedPayment1 -> paymentToBob (now
+    // owned by Bob). Same `anon` circuit as the createLock step.
+    const encodedZkProof = await prepareProof(
       circuit,
       provingKey,
       Alice,
@@ -150,29 +224,82 @@ describe("Escrow flow for payment with Zeto_Anon", function () {
     );
     const tx = await zkEscrow
       .connect(Alice.signer)
-      .approvePayment(paymentId, encodedProof, "0x");
+      .approvePayment(paymentId, encodeProofOnly(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);
+
+    // Bob listens to the escrow's PaymentApproved event; the escrow
+    // having stored the proof guarantees completePayment cannot fail
+    // on proof grounds later.
+    const approved = parseEscrowEvent(zkEscrow, result, "PaymentApproved");
+    expect(approved, "PaymentApproved event not emitted").to.not.be.undefined;
+    expect(approved!.paymentId).to.equal(paymentId);
   });
 
-  it("Bob, or anyone, can call the escrow to finalize the payment and receive the locked UTXO", async function () {
+  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);
+
+    // Lock is consumed; the locked-UTXO ledger no longer carries
+    // lockedPayment1.
+    expect(await zkPayment.isLockActive(lockId)).to.equal(false);
+    expect((await zkPayment.locked(lockedPayment1.hash))[0]).to.be.false;
+
+    // Escrow's PaymentCompleted event fires for the same paymentId.
+    const completed = parseEscrowEvent(zkEscrow, result, "PaymentCompleted");
+    expect(completed, "PaymentCompleted event not emitted").to.not.be.undefined;
+    expect(completed!.paymentId).to.equal(paymentId);
   });
 });
+
+// parseEscrowEvent extracts the first event of a given name from a
+// transaction receipt by parsing logs through the escrow contract's
+// own ABI. Unlike `parseUTXOEvents`, which only knows about the Zeto
+// token's UTXO event family, 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 the args Result directly; ethers exposes named fields
+      // (e.g. result.paymentId) alongside positional ones.
+      return parsed.args;
+    }
+  }
+  return undefined;
+}
+
+// encodeProofOnly mirrors the wire format that
+// {Zeto_Anon.constructPublicInputs} expects: a bare `Commonlib.Proof`
+// tuple (no merkle root prefix, since Zeto_Anon is non-nullifier).
+function encodeProofOnly(proof: any) {
+  return new AbiCoder().encode(
+    ["tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC)"],
+    [proof],
+  );
+}