@zerc20/wallet-sdk 0.5.0 → 0.6.0

package/src/spend.ts

@@ -6,9 +6,12 @@
 // and deposits into one note to self, proved by the merge prover (a wallet cannot: its key is 6.3 GB). More take
 // another merge, once a root is over the first one's note.
 //
-// A relayed JoinSplit or merge is done once its first input's nullifier is final, as sync sees it: the relayer's
-// answer alone could be a lie, or a reorg could drop the transaction. Only one that cannot land fails, which frees its
-// inputs: one whose nullifier is nowhere on chain, after it kept reverting.
+// A relayed JoinSplit or merge is done once its change (a merge's note) is final where this wallet expects it, as sync
+// sees it: only its own transaction puts that note there, as its salt is fresh and the proof binds it to the inputs'
+// nullifiers. The relayer's answer alone could be a lie, a reorg could drop the transaction, and a spent input alone
+// could be another device's doing: each device of a wallet locks its inputs in its own state. Only one that cannot
+// land fails, which frees its inputs: one that kept reverting with no input spent, or one whose input another
+// transaction spent.
 
 import { type Receipt, type Recipient, commit, decodeCode, planPayCode, planSelf, planSend } from '@zerc20/storage-sdk';
 import {
@@ -27,16 +30,7 @@ import { fail } from './errors.js';
 import { prove } from './prove.js';
 import { scan } from './scan.js';
 import type { Indexer } from './servers.js';
-import {
-  type Relayed,
-  RelayUnknown,
-  attest,
-  proofOf,
-  relay,
-  relayMerge,
-  relayerFees,
-  requestProof,
-} from './services.js';
+import { attest, proofOf, relay, relayMerge, relayerFees, requestProof } from './services.js';
 import { type NoteRecord, type OperationRecord, type Position, type SpendOperation, unspent } from './state.js';
 import { commitmentsAt, noteReceipt, storageState, takeRefresh, tokenIds } from './sync.js';
 import { aspPath, aspPaths, commitmentPath, commitmentPaths } from './tree.js';
@@ -77,9 +71,14 @@ export interface Step {
   attempts: number;
   /** Once relayed: the block the relayer saw it mined in. */
   relayedBlock?: number;
-  /** The indexer's nullifier count once it is past that block, or just after a relay that found it landed already.
-   * Final nullifiers past it, and the input's still not among them, means a reorg dropped the transaction. */
+  /** The indexer's nullifier count once it is past that block, or just after a relay that reverted on an input spent
+   * already: that leaves the step `attested`, not relayed again until its change tells whose transaction spent it.
+   * Final nullifiers past it, and its inputs still not among them, means whatever spent them is gone: a reorg dropped
+   * it, or the relayer never sent it. */
   relayedAt?: number;
+  /** The final commitment count once an input is seen spent. Final commitments past it, and the change still not among
+   * them, means another transaction spent the input, and this step can never land. */
+  spentAt?: number;
 }
 
 /** The most inputs one merge spends: the attester takes requests up to 2 MB, at 8 KiB of sealed witness per input
@@ -103,9 +102,13 @@ export interface MergeStep {
   /** Refused by the prover, or reverting with no sign of it on chain: built again with the same output a few times,
    * then failed. */
   attempts: number;
-  /** As a JoinSplit's. */
+  /** Built again after a relay of it reverted, which counts in `attempts` beside the prover's refusals: the request
+   * out may still land, so the step is not cancelled. */
+  sent?: true;
+  /** As a JoinSplit's, with `proved` where a JoinSplit is `attested`. */
   relayedBlock?: number;
   relayedAt?: number;
+  spentAt?: number;
 }
 
 /** Where a send or withdrawal goes; `self` merges the wallet's own notes and nothing leaves. */
@@ -648,27 +651,72 @@ const positionsAt = (ctx: Ctx, chainId: bigint, index: number): Position[] =>
 const positionOf = (ctx: Ctx, chainId: bigint, index: number): Position | undefined =>
   positionsAt(ctx, chainId, index).find((f) => !f.tentative);
 
-/** Whether the step's first input is spent on chain: among the final nullifiers (as sync last saw them), or among the
- * newer ones. Nothing but the step spends a locked input (rage exit refuses one, and a wallet is open in one tab), so
- * a spent input is the step landing. Reads the pages everyone polls, never asks about the nullifier. */
-async function inputSpent(ctx: Ctx, op: SpendOperation, step: { inputs: Coin[] }): Promise<boolean> {
-  const f = positionOf(ctx, op.chainId, step.inputs[0].index);
-  if (f?.spent) return true;
-  if (!f?.nullifier) return false;
+/** Whether any of the step's inputs is spent on chain: among the final nullifiers (as sync last saw them), or among
+ * the newer ones. Reads the pages everyone polls, never asks about a nullifier. */
+async function inputsSpent(ctx: Ctx, op: SpendOperation, step: { inputs: Coin[] }): Promise<boolean> {
+  const inputs = step.inputs.map((coin) => positionOf(ctx, op.chainId, coin.index));
+  if (inputs.some((f) => f?.spent)) return true;
+  // copies: sync alone moves the watches, over final entries
+  const watches = inputs.flatMap((f) => (f?.nullifier ? [{ ...f.nullifier }] : []));
+  if (watches.length === 0) return false;
   const c = chainCtx(ctx, op.chainId);
   const { nullifiers } = await c.indexer.status();
-  // a copy: sync alone moves the watch, over final entries
-  const watch = { ...f.nullifier };
-  const hits = await scan([watch], 8, (p) => c.indexer.page('nullifiers', p), watch.scannedTo, nullifiers);
+  const from = Math.min(...watches.map((w) => w.scannedTo));
+  const hits = await scan(watches, 8, (p) => c.indexer.page('nullifiers', p), from, nullifiers);
   return hits.length > 0;
 }
 
-/** Where a relayed JoinSplit stands, by its first input `f` as sync last saw it and `relayedAt`, a nullifier count past
- * its own (`undefined` while not known): spent, or the final nullifiers passed that count without its own (a reorg
- * dropped it, or the relayer never sent it), or neither yet. */
-export function relayedState(f: Position | undefined, relayedAt: number | undefined): 'landed' | 'dropped' | 'waiting' {
-  if (f?.spent) return 'landed';
-  return f?.nullifier && relayedAt !== undefined && f.nullifier.scannedTo >= relayedAt ? 'dropped' : 'waiting';
+/** Where a relayed step stands, by its `change` (a merge's note) and its `inputs` as sync last saw them:
+ * - `landed`: the change is final where this wallet expects it;
+ * - `taken`: an input is spent and the final commitments passed `spentAt` without the change, so another transaction
+ *   spent it, and this step can never land;
+ * - `dropped`: no input is spent and the final nullifiers passed `relayedAt` without them: whatever was spending them
+ *   is gone, a reorg dropped it or the relayer never sent it;
+ * - `mined`: the change is in a block, not final yet;
+ * - `waiting`: none of these yet. */
+export function relayedState(
+  change: Pick<NoteRecord, 'found' | 'watch'> | undefined,
+  inputs: (Position | undefined)[],
+  relayedAt: number | undefined,
+  spentAt: number | undefined,
+): 'landed' | 'taken' | 'dropped' | 'mined' | 'waiting' {
+  const seen = change?.found.filter((f) => f.confirmed) ?? [];
+  if (seen.some((f) => !f.tentative)) return 'landed';
+  if (inputs.some((f) => f?.spent)) {
+    // a final position not read yet may be the change
+    const missed =
+      spentAt !== undefined &&
+      !!change?.watch &&
+      change.watch.scannedTo >= spentAt &&
+      !change.found.some((f) => !f.tentative);
+    if (missed) return 'taken';
+  } else {
+    const watches = inputs.flatMap((f) => (f?.nullifier ? [f.nullifier] : []));
+    if (relayedAt !== undefined && watches.length > 0 && watches.every((w) => w.scannedTo >= relayedAt))
+      return 'dropped';
+  }
+  return seen.length > 0 ? 'mined' : 'waiting';
+}
+
+/** `relayedState` of `step`, failing the operation once another transaction took an input. The first time an input
+ * is seen spent, short of the step landing, it notes the final commitment count: a later status counts no fewer, so
+ * once the change's watch passes it, it has looked wherever that transaction put its notes. */
+async function standing(
+  ctx: Ctx,
+  op: SpendOperation,
+  step: Step | MergeStep,
+): Promise<ReturnType<typeof relayedState>> {
+  const inputs = step.inputs.map((coin) => positionOf(ctx, op.chainId, coin.index));
+  const salt = 'output' in step ? step.output.salt : step.outputs[1].salt;
+  const change = ctx.state.notes.find((n) => n.chainId === op.chainId && n.salt === salt);
+  const now = relayedState(change, inputs, step.relayedAt, step.spentAt);
+  if (now === 'taken')
+    fail('spent-elsewhere', 'another device of this wallet spent a note or deposit of it first: it paid nothing');
+  if (now !== 'landed' && step.spentAt === undefined && inputs.some((f) => f?.spent)) {
+    step.spentAt = (await chainCtx(ctx, op.chainId).indexer.status()).commitmentsFinal;
+    await ctx.save();
+  }
+  return now;
 }
 
 /** The indexer's nullifier count once it is past `block`, so past the nullifiers of a transaction mined there unless a
@@ -688,6 +736,18 @@ export function landed(op: SpendOperation): boolean {
   );
 }
 
+/** Whether `op` can still be cancelled, having paid nothing: a payment, withdrawal or consolidation under way with no
+ * request out to the relayer, and no merge of it landed. A step at its relay stage has one out, as its request leaves
+ * the moment it gets there; so has one built again after a relay of it reverted, as that request may still land: a
+ * JoinSplit's `attempts` count only those, and a merge, whose `attempts` count its prover's refusals too, is `sent`. */
+export function cancellable(op: OperationRecord): boolean {
+  if (op.status !== 'pending' || op.kind === 'deposit' || op.data.paid > 0n) return false;
+  const step = op.data.step;
+  if (!step) return true;
+  if ('output' in step) return !step.sent && step.stage !== 'proved' && step.stage !== 'relayed';
+  return step.attempts === 0 && step.stage !== 'attested' && step.stage !== 'relayed';
+}
+
 function markSpent(ctx: Ctx, op: SpendOperation, step: { inputs: Coin[] }): void {
   for (const coin of step.inputs) for (const f of positionsAt(ctx, op.chainId, coin.index)) f.spent = true;
 }
@@ -700,14 +760,17 @@ function placeChange(ctx: Ctx, op: SpendOperation, salt: Hex, index: number | nu
   }
 }
 
-/** Takes `op` as far as it can go now, saving before each step that leaves the device. */
+/** Takes `op` as far as it can go now, saving before each step that leaves the device. One cancelled meanwhile
+ * (`cancel`) finishes the stage under way and starts no other: its status is looked at after each, and nothing it does
+ * later is kept, as it is out of the state. A relayer that is relaying its request already throws `Relaying`. */
 export async function advanceSpend(ctx: Ctx, op: SpendOperation): Promise<void> {
   const data = op.data;
   const c = chainCtx(ctx, op.chainId);
   for (;;) {
+    if (op.status !== 'pending') return;
     if (!data.step) {
       const step = await planStep(ctx, op);
-      if (!step) return;
+      if (!step || op.status !== 'pending') return;
       if (step === 'done') {
         op.status = 'done';
         await ctx.save();
@@ -726,6 +789,7 @@ export async function advanceSpend(ctx: Ctx, op: SpendOperation): Promise<void>
       step.stage = 'noted';
       await ctx.save();
     }
+    if (op.status !== 'pending') return;
     if (step.stage === 'noted') {
       const built = await witnessOf(ctx, op, step);
       if (!built) return;
@@ -771,6 +835,7 @@ export async function advanceSpend(ctx: Ctx, op: SpendOperation): Promise<void>
       step.stage = 'proved';
       await ctx.save();
     }
+    if (op.status !== 'pending') return;
     if (step.stage === 'proved') {
       const attestation = await attest(c.config, step.statement!, step.witness!);
       step.request = { ...step.request!, attestation };
@@ -778,21 +843,25 @@ export async function advanceSpend(ctx: Ctx, op: SpendOperation): Promise<void>
       step.stage = 'attested';
       await ctx.save();
     }
+    if (op.status !== 'pending') return;
+    if (step.stage === 'attested' && step.relayedAt !== undefined) {
+      // a relay of it reverted on an input spent already: an earlier relay of it landed, one whose answer was lost, or
+      // another transaction spent the input. Relaying it again would tell nothing more
+      const now = await standing(ctx, op, step);
+      if (now === 'waiting') return;
+      if (now === 'dropped') delete step.relayedAt;
+      else step.stage = 'relayed';
+      await ctx.save();
+    }
     if (step.stage === 'attested') {
       const relayerOut = step.outputs.find((o) => o.role === 'relayer');
-      let result: Relayed | { reverted: string };
-      try {
-        result = await relay(
-          c.config,
-          step.request!,
-          relayerOut ? { value: relayerOut.value, salt: relayerOut.salt } : undefined,
-        );
-      } catch (e) {
-        if (e instanceof RelayUnknown) return; // try the same request again next time
-        throw e;
-      }
+      const result = await relay(
+        c.config,
+        step.request!,
+        relayerOut ? { value: relayerOut.value, salt: relayerOut.salt } : undefined,
+      );
       if ('reverted' in result) {
-        if (!(await inputSpent(ctx, op, step))) {
+        if (!(await inputsSpent(ctx, op, step))) {
           // stale roots, most likely: prove again with the same outputs, next sync. A JoinSplit that keeps reverting
           // is not on chain and cannot land, so failing it frees its inputs.
           if (++step.attempts > 3)
@@ -804,23 +873,24 @@ export async function advanceSpend(ctx: Ctx, op: SpendOperation): Promise<void>
           await ctx.save();
           return;
         }
-        // an earlier relay of it landed, one whose answer was lost, and the indexer counts its nullifier already
+        // the indexer counts the nullifiers of whatever spent it already
         step.relayedAt = (await c.indexer.status()).nullifiers;
-      } else {
-        placeChange(ctx, op, step.outputs[1].salt, result.noteIndex2);
-        data.txHashes = [...(data.txHashes ?? []), result.txHash];
-        step.relayedBlock = result.block;
-        delete step.relayedAt;
+        await ctx.save();
+        return;
       }
+      placeChange(ctx, op, step.outputs[1].salt, result.noteIndex2);
+      data.txHashes = [...(data.txHashes ?? []), result.txHash];
+      step.relayedBlock = result.block;
       step.stage = 'relayed';
       await ctx.save();
     }
     if (step.stage === 'relayed') {
       step.relayedAt ??= await nullifiersPast(c.indexer, step.relayedBlock!);
-      const now = relayedState(positionOf(ctx, op.chainId, step.inputs[0].index), step.relayedAt);
+      const now = await standing(ctx, op, step);
       if (now === 'dropped') {
         // relay it again next sync; if it did land after all, that reverts and finds it
         step.stage = 'attested';
+        delete step.relayedAt;
         await ctx.save();
       }
       if (now !== 'landed') return;
@@ -853,6 +923,7 @@ async function advanceMerge(ctx: Ctx, op: SpendOperation, step: MergeStep): Prom
     step.stage = 'noted';
     await ctx.save();
   }
+  if (op.status !== 'pending') return false;
   if (step.stage === 'noted') {
     const built = await mergeWitnessOf(ctx, op, step);
     if (!built) return false;
@@ -888,6 +959,7 @@ async function advanceMerge(ctx: Ctx, op: SpendOperation, step: MergeStep): Prom
     step.stage = 'attested';
     await ctx.save();
   }
+  if (op.status !== 'pending') return false;
   if (step.stage === 'attested') {
     await requestProof(c.config, prover, step.statement!, step.witness!, step.inputs.length);
     delete step.witness; // the prover has it: the inputs' openings need not stay saved here
@@ -909,33 +981,39 @@ async function advanceMerge(ctx: Ctx, op: SpendOperation, step: MergeStep): Prom
     step.stage = 'proved';
     await ctx.save();
   }
+  if (op.status !== 'pending') return false;
+  if (step.stage === 'proved' && step.relayedAt !== undefined) {
+    // as a JoinSplit's, told apart by its note
+    const now = await standing(ctx, op, step);
+    if (now === 'waiting') return false;
+    if (now === 'dropped') delete step.relayedAt;
+    else step.stage = 'relayed';
+    await ctx.save();
+  }
   if (step.stage === 'proved') {
-    let result: Awaited<ReturnType<typeof relayMerge>>;
-    try {
-      result = await relayMerge(c.config, step.request!);
-    } catch (e) {
-      if (e instanceof RelayUnknown) return false; // try the same request again next time
-      throw e;
-    }
+    const result = await relayMerge(c.config, step.request!);
     if ('reverted' in result) {
       // stale roots, most likely: built again with the same output, next sync
-      if (!(await inputSpent(ctx, op, step))) return again(result.reverted);
-      // an earlier relay of it landed, one whose answer was lost, and the indexer counts its nullifiers already
+      if (!(await inputsSpent(ctx, op, step))) {
+        step.sent = true;
+        return again(result.reverted);
+      }
       step.relayedAt = (await c.indexer.status()).nullifiers;
-    } else {
-      placeChange(ctx, op, step.output.salt, result.noteIndex);
-      data.txHashes = [...(data.txHashes ?? []), result.txHash];
-      step.relayedBlock = result.block;
-      delete step.relayedAt;
+      await ctx.save();
+      return false;
     }
+    placeChange(ctx, op, step.output.salt, result.noteIndex);
+    data.txHashes = [...(data.txHashes ?? []), result.txHash];
+    step.relayedBlock = result.block;
     step.stage = 'relayed';
     await ctx.save();
   }
   step.relayedAt ??= await nullifiersPast(c.indexer, step.relayedBlock!);
-  const now = relayedState(positionOf(ctx, op.chainId, step.inputs[0].index), step.relayedAt);
+  const now = await standing(ctx, op, step);
   if (now === 'dropped') {
     // relay it again next sync; if it did land after all, that reverts and finds it
     step.stage = 'proved';
+    delete step.relayedAt;
     await ctx.save();
   }
   if (now !== 'landed') return false;