@elisym/commerce 0.3.0 → 0.4.0

package/dist/buyer.js

@@ -2,8 +2,9 @@ import { MAX_FUTURE_SKEW_SECS, isPublicHostname, KIND_INBOX_RELAYS, decodeProduc
 import { verifyEvent, generateSecretKey, getPublicKey } from 'nostr-tools/pure';
 import { getTransactionDecoder, partiallySignTransaction, getTransactionEncoder, isAddress, address, getCompiledTransactionMessageDecoder, verifySignature, getPublicKeyFromAddress, getBase64Decoder, getBase58Decoder, createNoopSigner, pipe, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, setTransactionMessageComputeUnitLimit, setTransactionMessageComputeUnitPrice, appendTransactionMessageInstructions, compileTransaction } from '@solana/kit';
 import { bytesToHex, hexToBytes, normalizeURL } from 'nostr-tools/utils';
-import { parsePaymentRequest, composeSolanaPaymentRequest, estimatePriorityFeeMicroLamports, estimateSolFeeLamports, directInstructionsFromCompiledMessage, boundTransferAmount, buildPaymentInstructions, getProtocolProgramId, verifyDirectSolanaPayment } from '@elisym/pay-core';
+import { parsePaymentRequest, composeSolanaPaymentRequest, estimatePriorityFeeMicroLamports, estimateSolFeeLamports, directInstructionsFromCompiledMessage, boundTransferAmount, PaymentRequestV2Schema, buildPaymentInstructions, getProtocolProgramId, verifyDirectSolanaPayment } from '@elisym/pay-core';
 import { TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda } from '@solana-program/token';
+import { readFinalizedBlock, MIN_PAY_WINDOW_SECS, buildTempoPaymentCalls, readTxHash, verifyTempoPayment, EVM_LATE_PAYMENT_GRACE_SECS, checkEvmChain, checkTempoReceivePolicies, composeTempoPaymentRequest } from '@elisym/pay-core/evm';
 import { SimplePool } from 'nostr-tools/pool';
 
 // src/buyer/constants.ts
@@ -172,8 +173,8 @@ function isPageOrigin(value) {
 function isSnapshotStale(snapshotAt, now = nowSecs()) {
   return now - snapshotAt > OFFER_SNAPSHOT_MAX_AGE_SECS;
 }
-function refuse(refusal, message) {
-  return { ok: false, refusal, message };
+function refuse(refusal2, message) {
+  return { ok: false, refusal: refusal2, message };
 }
 async function loadOffer(naddr, options) {
   if (!isPageOrigin(options.pageOrigin)) {
@@ -617,7 +618,10 @@ var PATCH_KEYS = [
   "inboxRelays",
   "acknowledgedRelays",
   "paidTx",
-  "status"
+  "paidAt",
+  "status",
+  "endedBy",
+  "confirmedOverIds"
 ];
 var STATUS_SUCCESSORS = {
   pending: ["pending", "confirmed", "completed", "cancelled"],
@@ -653,6 +657,20 @@ function patchRefusal(current, patch) {
   if (patch.paidTx !== void 0 && (current.paidTx !== void 0 || !PAID_STATES.includes(nextState))) {
     return "not_ready";
   }
+  if (patch.paidAt !== void 0 && patch.paidTx === void 0) {
+    return "not_ready";
+  }
+  const tempo = railOf(current) === "tempo";
+  const endsUnpaid = patch.state === "ended-unpaid" && current.state !== "ended-unpaid";
+  if (patch.endedBy !== void 0 && (!tempo || !endsUnpaid || patch.endedBy !== "nothing")) {
+    return "not_ready";
+  }
+  if (tempo && endsUnpaid && patch.endedBy === void 0) {
+    return "not_ready";
+  }
+  if (patch.confirmedOverIds !== void 0 && !(current.confirmedOverIds ?? []).every((id) => patch.confirmedOverIds?.includes(id))) {
+    return "not_ready";
+  }
   if (patch.receiptWrap !== void 0 && current.receiptWrap !== void 0 && current.state !== "paying") {
     return "not_ready";
   }
@@ -742,13 +760,21 @@ function judgeUpdate(records, orderId, expectedVersion, patch) {
       Object.assign(defined, { [key]: patch[key] });
     }
   }
-  const refusal = patchRefusal(current, defined);
-  if (refusal !== void 0) {
-    return refused(refusal);
+  const refusal2 = patchRefusal(current, defined);
+  if (refusal2 !== void 0) {
+    return refused(refusal2);
   }
   return accepted({ ...current, ...defined, version: current.version + 1 });
 }
-function judgeSetMarker(records, orderId, expectedVersion, marker) {
+function unconfirmedOver(records, current, now) {
+  return records.filter(
+    (sibling) => sibling.orderId !== current.orderId && railOf(sibling) === "tempo" && sibling.state === "ended-unpaid" && (sibling.endedBy === "over" || sibling.endedBy === void 0) && (now === void 0 || now - sibling.createdAt <= MERCHANT_CATCH_UP_SECS + MAX_CLOCK_SKEW_SECS) && !(current.confirmedOverIds ?? []).includes(sibling.orderId)
+  ).map((sibling) => sibling.orderId);
+}
+function needsConfirmation(unconfirmed) {
+  return { result: { ok: false, reason: "needs_confirmation", unconfirmed } };
+}
+function judgeSetMarker(records, orderId, expectedVersion, marker, now) {
   const current = judgedRecord(records, orderId, expectedVersion);
   if (isJudged(current)) {
     return current;
@@ -760,9 +786,13 @@ function judgeSetMarker(records, orderId, expectedVersion, marker) {
   if (holder !== void 0) {
     return refused("exclusion", holder.orderId);
   }
+  const unconfirmed = unconfirmedOver(records, current, now);
+  if (unconfirmed.length > 0) {
+    return needsConfirmation(unconfirmed);
+  }
   return accepted({ ...current, marker, state: "paying", version: current.version + 1 });
 }
-function judgeUpdateMarker(records, orderId, expectedVersion, attemptId, next) {
+function judgeUpdateMarker(records, orderId, expectedVersion, attemptId, next, now) {
   const current = records.find((record) => record.orderId === orderId);
   if (current === void 0) {
     return refused("missing");
@@ -786,10 +816,14 @@ function judgeUpdateMarker(records, orderId, expectedVersion, attemptId, next) {
     if (holder !== void 0) {
       return refused("exclusion", holder.orderId);
     }
+    const unconfirmed = unconfirmedOver(records, current, now);
+    if (unconfirmed.length > 0) {
+      return needsConfirmation(unconfirmed);
+    }
   }
   return accepted({ ...current, marker: next, version: current.version + 1 });
 }
-function judgeClearMarker(records, orderId, expectedVersion, attemptId, nextState) {
+function judgeClearMarker(records, orderId, expectedVersion, attemptId, nextState, endedBy) {
   const current = records.find((record) => record.orderId === orderId);
   if (current === void 0) {
     return refused("missing");
@@ -800,7 +834,16 @@ function judgeClearMarker(records, orderId, expectedVersion, attemptId, nextStat
   if (current.state !== "paying") {
     return refused("not_ready");
   }
-  if (nextState === "ended-unpaid" && current.marker?.rail === "tempo" && current.marker.bundleId !== void 0) {
+  const tempo = current.marker?.rail === "tempo";
+  if (nextState === "ended-unpaid" && tempo) {
+    if (current.marker !== void 0 && holdsEvidence(current.marker)) {
+      return refused("not_ready");
+    }
+    if (endedBy === void 0) {
+      return refused("not_ready");
+    }
+  }
+  if (endedBy !== void 0 && (!tempo || nextState !== "ended-unpaid")) {
     return refused("not_ready");
   }
   if (nextState === "ordered" && current.marker !== void 0 && holdsEvidence(current.marker)) {
@@ -810,7 +853,12 @@ function judgeClearMarker(records, orderId, expectedVersion, attemptId, nextStat
     const { marker: _removed, ...rest } = current;
     return accepted({ ...rest, state: nextState, version: current.version + 1 });
   }
-  return accepted({ ...current, state: nextState, version: current.version + 1 });
+  return accepted({
+    ...current,
+    state: nextState,
+    ...endedBy === void 0 ? {} : { endedBy },
+    version: current.version + 1
+  });
 }
 function mergePins(current, storePubkey, ownerPubkey, payouts) {
   if (current !== void 0 && current.pinnedOwnerPubkey !== ownerPubkey) {
@@ -861,24 +909,24 @@ var OrderStore = class {
     return this.judge(orderId, (records) => judgeUpdate(records, orderId, expectedVersion, patch));
   }
   /** See `judgeSetMarker`. */
-  setMarker(orderId, expectedVersion, marker) {
+  setMarker(orderId, expectedVersion, marker, now) {
     return this.judge(
       orderId,
-      (records) => judgeSetMarker(records, orderId, expectedVersion, marker)
+      (records) => judgeSetMarker(records, orderId, expectedVersion, marker, now)
     );
   }
   /** See `judgeUpdateMarker`. */
-  updateMarker(orderId, expectedVersion, attemptId, next) {
+  updateMarker(orderId, expectedVersion, attemptId, next, now) {
     return this.judge(
       orderId,
-      (records) => judgeUpdateMarker(records, orderId, expectedVersion, attemptId, next)
+      (records) => judgeUpdateMarker(records, orderId, expectedVersion, attemptId, next, now)
     );
   }
   /** See `judgeClearMarker`. */
-  clearMarker(orderId, expectedVersion, attemptId, nextState) {
+  clearMarker(orderId, expectedVersion, attemptId, nextState, endedBy) {
     return this.judge(
       orderId,
-      (records) => judgeClearMarker(records, orderId, expectedVersion, attemptId, nextState)
+      (records) => judgeClearMarker(records, orderId, expectedVersion, attemptId, nextState, endedBy)
     );
   }
   pins(storePubkey) {
@@ -1272,6 +1320,14 @@ function storeRefusal(written, record) {
       ...written.holder === void 0 ? {} : { holder: written.holder }
     };
   }
+  if (written.reason === "needs_confirmation") {
+    return {
+      ok: false,
+      reason: "needs_confirmation",
+      record,
+      unconfirmed: written.unconfirmed ?? []
+    };
+  }
   return { ok: false, reason: written.reason === "conflict" ? "conflict" : "not_payable", record };
 }
 async function withReleaseOnThrow(attemptId, deps, write) {
@@ -1324,7 +1380,7 @@ async function payWithSolana(record, wallet, input, deps) {
   const marked = await withReleaseOnThrow(
     marker.attemptId,
     deps,
-    () => deps.store.setMarker(record.orderId, record.version, marker)
+    () => deps.store.setMarker(record.orderId, record.version, marker, (deps.now ?? nowSecs)())
   );
   if (!marked.ok) {
     deps.release?.(marker.attemptId);
@@ -1427,7 +1483,8 @@ async function recordPaid(record, signature, deps) {
     }
     const written = await deps.store.update(current.orderId, current.version, {
       state: "paid",
-      paidTx: signature
+      paidTx: signature,
+      paidAt: (deps.now ?? nowSecs)()
     });
     if (written.ok) {
       return written.record;
@@ -1527,7 +1584,13 @@ async function retryWithSolana(record, wallet, input, deps) {
   const replaced = await withReleaseOnThrow(
     marker.attemptId,
     deps,
-    () => deps.store.updateMarker(judged.orderId, judged.version, previous.attemptId, marker)
+    () => deps.store.updateMarker(
+      judged.orderId,
+      judged.version,
+      previous.attemptId,
+      marker,
+      (deps.now ?? nowSecs)()
+    )
   );
   if (!replaced.ok) {
     deps.release?.(marker.attemptId);
@@ -1557,6 +1620,406 @@ async function endSolanaOrder(record, deps) {
   );
   return written.ok ? { ended: true, record: written.record } : { ended: false, record: watch.record };
 }
+var BALANCE_OF_SELECTOR = "0x70a08231";
+var EVM_ADDRESS_RE = /^0x[0-9a-f]{40}$/;
+var UINT256_RE = /^0x[0-9a-fA-F]{64}$/;
+function tempoFeeMargin(decimals) {
+  return decimals > 2 ? 10n ** BigInt(decimals - 2) : 1n;
+}
+function tempoTargetOf(record) {
+  const caip19 = parseCaip19(record.payout.caip19);
+  const mint = caip19?.asset.mint;
+  if (caip19 === void 0 || caip19.chain.family !== "evm" || mint === void 0) {
+    return void 0;
+  }
+  return { chain: caip19.chain, asset: caip19.asset, token: mint.toLowerCase() };
+}
+function storedTempoRequest(record) {
+  if (record.paymentRequest === void 0) {
+    return void 0;
+  }
+  try {
+    const parsed = PaymentRequestV2Schema.safeParse(JSON.parse(record.paymentRequest));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function tempoRequestMatches(request, record, target) {
+  return request.chain === target.chain.caip2 && request.asset.toLowerCase() === `${target.chain.caip2}/erc20:${target.token}` && request.recipient === record.payout.address.toLowerCase() && request.memo === record.reference && BigInt(request.amount) === BigInt(record.amount) && request.fee_address === void 0 && (request.fee_amount === void 0 || BigInt(request.fee_amount) === 0n);
+}
+async function readTempoChainTime(client) {
+  const head = await readFinalizedBlock(client);
+  if (head === null) {
+    throw new Error("The Tempo chain could not be read.");
+  }
+  return head.timestamp;
+}
+async function tokenBalance2(client, token, owner) {
+  try {
+    const answer = await client.request({
+      method: "eth_call",
+      params: [
+        { to: token, data: `${BALANCE_OF_SELECTOR}${owner.slice(2).padStart(64, "0")}` },
+        "latest"
+      ]
+    });
+    return typeof answer === "string" && UINT256_RE.test(answer) ? BigInt(answer) : null;
+  } catch {
+    return null;
+  }
+}
+function refusal(reason, record) {
+  return record === void 0 ? { ok: false, reason } : { ok: false, reason, record };
+}
+async function endNothingRequested(record, deps) {
+  const written = await deps.store.update(record.orderId, record.version, {
+    state: "ended-unpaid",
+    endedBy: "nothing"
+  });
+  return written.ok ? written.record : record;
+}
+function storeRefusal2(written, record) {
+  if (written.reason === "exclusion") {
+    return {
+      ...refusal("exclusion", record),
+      ...written.holder === void 0 ? {} : { holder: written.holder }
+    };
+  }
+  if (written.reason === "needs_confirmation") {
+    return { ...refusal("needs_confirmation", record), unconfirmed: written.unconfirmed ?? [] };
+  }
+  return refusal(written.reason === "conflict" ? "conflict" : "not_payable", record);
+}
+async function checkBeforeTempoPaying(record, payer, fresh, target, head, deps) {
+  if (record.state !== "ordered" || record.marker !== void 0) {
+    return refusal("not_payable", record);
+  }
+  if (isSnapshotStale(fresh.snapshotAt, (deps.now ?? nowSecs)())) {
+    return refusal("stale_offer", record);
+  }
+  const match = fresh.payouts.find(
+    (payout) => payout.target.caip19.id === record.payout.caip19 && payout.target.address === record.payout.address
+  );
+  if (fresh.productAddress !== record.productAddress || !isOfferPayout(fresh.offer, record.payout.caip19, record.payout.address) || match === void 0 || match.amount !== BigInt(record.amount)) {
+    return refusal("offer_changed", record);
+  }
+  if (head.timestamp > record.createdAt + MERCHANT_CATCH_UP_SECS - PAY_CUTOFF_SECS) {
+    return refusal("too_late", record);
+  }
+  const recipient = record.payout.address.toLowerCase();
+  if (payer === recipient) {
+    return refusal("self_payment", record);
+  }
+  const named = await checkEvmChain(deps.client, target.chain).catch(() => "wrong");
+  if (named === "wrong") {
+    return refusal("wrong_chain", record);
+  }
+  if (named === null) {
+    return refusal("rpc_error", record);
+  }
+  const policy = await checkTempoReceivePolicies(deps.client, {
+    chain: target.chain,
+    token: target.token,
+    payer,
+    recipient
+  });
+  if (!policy.ok) {
+    return refusal(policy.reason === "blocked" ? "policy_blocked" : "rpc_error", record);
+  }
+  const balance = await tokenBalance2(deps.client, target.token, payer);
+  if (balance === null) {
+    return refusal("rpc_error", record);
+  }
+  const needed = BigInt(record.amount) + tempoFeeMargin(target.asset.decimals);
+  if (balance < needed) {
+    return { ...refusal("insufficient_token", record), needed, available: balance };
+  }
+  return void 0;
+}
+async function requestFor(record, target, head, deps) {
+  if (record.paymentRequest !== void 0) {
+    const stored = storedTempoRequest(record);
+    return stored !== void 0 && tempoRequestMatches(stored, record, target) ? { request: stored, record } : refusal("not_payable", record);
+  }
+  let request;
+  try {
+    request = composeTempoPaymentRequest({
+      chain: target.chain,
+      asset: target.asset,
+      recipient: record.payout.address.toLowerCase(),
+      amount: BigInt(record.amount),
+      feeBps: 0,
+      treasury: record.payout.address.toLowerCase(),
+      memo: record.reference,
+      createdAt: head.timestamp
+    });
+  } catch {
+    return refusal("unpayable", await endNothingRequested(record, deps));
+  }
+  const written = await deps.store.update(record.orderId, record.version, {
+    paymentRequest: JSON.stringify(request)
+  });
+  if (!written.ok) {
+    return storeRefusal2(written, record);
+  }
+  return { request, record: written.record };
+}
+function isRefusal(value) {
+  return "ok" in value;
+}
+async function saveTempoHash(record, attemptId, hash, deps) {
+  let current = record;
+  for (let attempt = 0; attempt < STORE_WRITE_ATTEMPTS && current !== void 0; attempt += 1) {
+    const marker = current.marker;
+    if (marker?.rail !== "tempo" || marker.attemptId !== attemptId) {
+      return { saved: false, record: current, stopped: true };
+    }
+    if (marker.txHash === hash) {
+      return { saved: true, record: current };
+    }
+    const written = await deps.store.updateMarker(current.orderId, current.version, attemptId, {
+      ...marker,
+      txHash: hash
+    });
+    if (written.ok) {
+      return { saved: true, record: written.record };
+    }
+    if (written.reason === "not_ready") {
+      return { saved: false, record: current, stopped: true };
+    }
+    current = await deps.store.get(record.orderId);
+  }
+  return { saved: false, record: current ?? record };
+}
+async function endRejected(record, attemptId, deps) {
+  let current = record;
+  for (let attempt = 0; attempt < STORE_WRITE_ATTEMPTS && current !== void 0; attempt += 1) {
+    if (current.marker?.attemptId !== attemptId || current.state !== "paying") {
+      break;
+    }
+    const ended = await deps.store.clearMarker(
+      current.orderId,
+      current.version,
+      attemptId,
+      "ended-unpaid",
+      "rejected"
+    );
+    if (ended.ok) {
+      return refusal("rejected", ended.record);
+    }
+    if (ended.reason !== "conflict") {
+      break;
+    }
+    current = await deps.store.get(record.orderId);
+  }
+  return refusal("conflict", current ?? record);
+}
+function isUserRejection(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === 4001;
+}
+async function payWithTempo(record, wallet, fresh, deps) {
+  const target = tempoTargetOf(record);
+  const payer = wallet.address.toLowerCase();
+  if (target === void 0 || !EVM_ADDRESS_RE.test(payer)) {
+    return refusal("not_payable", record);
+  }
+  const head = await readFinalizedBlock(deps.client);
+  if (head === null) {
+    return refusal("rpc_error", record);
+  }
+  const failed = await checkBeforeTempoPaying(record, payer, fresh, target, head, deps);
+  if (failed !== void 0) {
+    return failed;
+  }
+  const composed = await requestFor(record, target, head, deps);
+  if (isRefusal(composed)) {
+    return composed;
+  }
+  const { request } = composed;
+  let current = composed.record;
+  if (head.timestamp + MIN_PAY_WINDOW_SECS > request.created_at + request.expiry_secs) {
+    return refusal("too_late", await endNothingRequested(current, deps));
+  }
+  let calls;
+  try {
+    calls = buildTempoPaymentCalls(request, payer);
+  } catch {
+    return refusal("unpayable", await endNothingRequested(current, deps));
+  }
+  const call = calls.calls[0];
+  if (calls.calls.length !== 1 || call === void 0) {
+    return refusal("not_payable", current);
+  }
+  const now = (deps.now ?? nowSecs)();
+  const attemptId = (deps.newAttemptId ?? (() => crypto.randomUUID()))();
+  const marked = await deps.store.setMarker(
+    current.orderId,
+    current.version,
+    { rail: "tempo", attemptId, setAt: now, floorBlock: String(head.number) },
+    now
+  );
+  if (!marked.ok) {
+    return storeRefusal2(marked, current);
+  }
+  current = marked.record;
+  const walletChain = await wallet.chainId().catch(() => void 0);
+  if (walletChain !== target.chain.evmChainId) {
+    const cleared = await deps.store.clearMarker(
+      current.orderId,
+      current.version,
+      attemptId,
+      "ordered"
+    );
+    return refusal("wrong_chain", cleared.ok ? cleared.record : current);
+  }
+  let returned;
+  try {
+    returned = await wallet.sendCall({
+      from: payer,
+      to: call.to,
+      data: call.data,
+      chainId: calls.chainId
+    });
+  } catch (error) {
+    if (isUserRejection(error)) {
+      return await endRejected(current, attemptId, deps);
+    }
+    return refusal("wallet_failed", current);
+  }
+  const hash = readTxHash(returned);
+  if (hash === null) {
+    return refusal("wallet_failed", current);
+  }
+  const saved = await saveTempoHash(current, attemptId, hash, deps);
+  current = saved.record;
+  if (!saved.saved) {
+    return { ok: true, record: current, hash, hashUnsaved: true };
+  }
+  const receipt = await sendReceipt(current, hash, (deps.now ?? nowSecs)(), deps);
+  return { ok: true, record: receipt.ok ? receipt.record : current, hash };
+}
+async function recordTempoPaid(record, hash, deps) {
+  let current = record;
+  if (current.receiptWrap === void 0) {
+    const receipt = await sendReceipt(current, hash, (deps.now ?? nowSecs)(), deps);
+    if (receipt.ok) {
+      current = receipt.record;
+    }
+  }
+  for (let attempt = 0; attempt < STORE_WRITE_ATTEMPTS && current !== void 0; attempt += 1) {
+    if (current.paidTx !== void 0 || isTerminal(current)) {
+      return current;
+    }
+    const written = await deps.store.update(current.orderId, current.version, {
+      state: "paid",
+      paidTx: hash,
+      paidAt: (deps.now ?? nowSecs)()
+    });
+    if (written.ok) {
+      return written.record;
+    }
+    if (written.reason !== "conflict") {
+      return current;
+    }
+    current = await deps.store.get(record.orderId);
+  }
+  return current ?? record;
+}
+async function recordBlocked(record, deps) {
+  const written = await deps.store.update(record.orderId, record.version, { state: "blocked" });
+  return written.ok ? written.record : record;
+}
+async function watchTempoPayment(record, deps, options = {}) {
+  if (isTerminal(record)) {
+    return { state: "closed", record };
+  }
+  if (record.paidTx !== void 0) {
+    return { state: "paid", record: await recordTempoPaid(record, record.paidTx, deps) };
+  }
+  const request = storedTempoRequest(record);
+  if (record.marker?.rail !== "tempo" || request === void 0) {
+    return { state: "waiting", record };
+  }
+  let current = record;
+  if (options.pendingHash !== void 0 && record.marker.txHash === void 0 && record.state === "paying") {
+    current = (await saveTempoHash(record, record.marker.attemptId, options.pendingHash, deps)).record;
+  }
+  const marker = current.marker?.rail === "tempo" ? current.marker : record.marker;
+  const hash = marker.txHash ?? options.pendingHash;
+  const result = await verifyTempoPayment(deps.client, request, {
+    ...hash === void 0 ? {} : { txSignature: hash },
+    fromBlock: Number(marker.floorBlock),
+    pollBudgetMs: 0
+  });
+  switch (result.outcome) {
+    case "verified":
+      return {
+        state: "paid",
+        record: await recordTempoPaid(current, result.providerLeg.transactionHash, deps)
+      };
+    case "none": {
+      const held = hash !== void 0 || options.callPending === true || marker.bundleId !== void 0;
+      if (!held && current.state === "paying") {
+        return { state: "over", record: current };
+      }
+      return { state: "waiting", record: current, pastDeadline: hash !== void 0 };
+    }
+    case "refused":
+      switch (result.code) {
+        case "provider_leg_blocked":
+          return { state: "blocked", record: await recordBlocked(current, deps) };
+        case "wrong_chain":
+        case "unknown_asset":
+        case "unreadable_receipt":
+        case "reverted":
+        case "no_provider_leg":
+        case "fee_leg_missing":
+        case "fee_leg_blocked":
+          return { state: "unsure", record: current };
+      }
+      return { state: "unsure", record: current };
+    case "inconclusive":
+      switch (result.reason) {
+        case "not_yet_due":
+        case "not_finalized":
+        case "no_receipt":
+        case "chain_unreadable":
+          return { state: "waiting", record: current };
+        case "incomplete_scan":
+        case "control_failed":
+          return { state: "unsure", record: current };
+      }
+      return { state: "unsure", record: current };
+  }
+}
+function tempoLateDeadline(request) {
+  return request.created_at + request.expiry_secs + EVM_LATE_PAYMENT_GRACE_SECS;
+}
+async function endTempoOrder(record, deps, options = {}) {
+  if (record.state === "ordered" && record.marker === void 0) {
+    const ended = await endNothingRequested(record, deps);
+    return { ended: ended.state === "ended-unpaid", record: ended };
+  }
+  if (record.state !== "paying" || record.marker?.rail !== "tempo") {
+    return { ended: false, record };
+  }
+  const watch = await watchTempoPayment(record, deps, options);
+  if (watch.state !== "over" || watch.record.marker === void 0) {
+    return { ended: false, record: watch.record };
+  }
+  const written = await deps.store.clearMarker(
+    watch.record.orderId,
+    watch.record.version,
+    watch.record.marker.attemptId,
+    "ended-unpaid",
+    "over"
+  );
+  return written.ok ? { ended: true, record: written.record } : { ended: false, record: watch.record };
+}
+function mayStillBePaid(record, now) {
+  return record.state === "ended-unpaid" && record.payout.caip19.startsWith("eip155:") && (record.endedBy === "over" || record.endedBy === void 0) && now - record.createdAt <= MERCHANT_CATCH_UP_SECS + MAX_CLOCK_SKEW_SECS;
+}
 
 // src/buyer/purchase.ts
 function cancelledUnpaid(record) {
@@ -1572,12 +2035,17 @@ async function endOrder(record, deps) {
   if (record.state === "created") {
     return { ended: true, record };
   }
-  if (deps.rpc !== void 0) {
+  if (record.payout.caip19.startsWith("eip155:") && deps.tempo !== void 0) {
+    return await endTempoOrder(record, { ...deps, client: deps.tempo });
+  }
+  if (deps.rpc !== void 0 && !record.payout.caip19.startsWith("eip155:")) {
     return await endSolanaOrder(record, { ...deps, rpc: deps.rpc });
   }
   if (record.state === "ordered" && record.marker === void 0) {
     const written = await deps.store.update(record.orderId, record.version, {
-      state: "ended-unpaid"
+      state: "ended-unpaid",
+      // Nothing was requested: no Tempo prompt can be open for it.
+      ...record.payout.caip19.startsWith("eip155:") ? { endedBy: "nothing" } : {}
     });
     return written.ok ? { ended: true, record: written.record } : { ended: false, record };
   }
@@ -1794,6 +2262,6 @@ function createRelayClient(options = {}) {
   };
 }
 
-export { CONFIRM_WARNINGS, DEFAULT_RELAYS, MAX_CLOCK_SKEW_SECS, MAX_RELAY_URL_LENGTH, MERCHANT_CATCH_UP_SECS, MemoryOrderBackend, OFFER_SNAPSHOT_MAX_AGE_SECS, ORDER_ACK_TARGET, OrderStore, PAYMENT_SCAN_MARGIN_SECS, PAY_CUTOFF_SECS, RELAY_CONNECT_MAX_WAIT_MS, RELAY_PUBLISH_DEADLINE_MS, RELAY_QUERY_DEADLINE_MS, RELAY_QUERY_MAX_WAIT_MS, SOLANA_COMPUTE_UNIT_LIMIT, STORE_RELAY_CAP, STORE_WRITE_ATTEMPTS, SUBSCRIBE_RETRY_MAX_MS, SUBSCRIBE_RETRY_MS, SUBSCRIBE_STABLE_MS, TERMINAL_STATES, WRAP_BACKDATE_SECS, applyStatus, cancelledUnpaid, checkBeforePaying, checkSignedTransaction, clockAgrees, compareOffers, composeOrderPayment, createPool, createRelayClient, deliveryLink, endOrder, endSolanaOrder, gone, holdsPayExclusion, isEventShaped, isGenuineEvent, isPageOrigin, isSnapshotStale, isTerminal, judgeAdd, judgeClearMarker, judgeSetMarker, judgeUpdate, judgeUpdateMarker, listenForStatus, loadOffer, loadOfferForAgent, localSolanaWallet, mediumOf, mergePins, newestGenuine, newestStoreInbox, normalizeRelayUrl, nowSecs, onOtherTerms, payWithSolana, placeOrder, readChainTime, readRelays, readStoreInbox, recordToShow, relayHost, resumeOrder, retryWithSolana, sendReceipt, statusFor, storeRelays, storedSolanaRequest, uniqueRelays, watchSolanaPayment };
+export { CONFIRM_WARNINGS, DEFAULT_RELAYS, MAX_CLOCK_SKEW_SECS, MAX_RELAY_URL_LENGTH, MERCHANT_CATCH_UP_SECS, MemoryOrderBackend, OFFER_SNAPSHOT_MAX_AGE_SECS, ORDER_ACK_TARGET, OrderStore, PAYMENT_SCAN_MARGIN_SECS, PAY_CUTOFF_SECS, RELAY_CONNECT_MAX_WAIT_MS, RELAY_PUBLISH_DEADLINE_MS, RELAY_QUERY_DEADLINE_MS, RELAY_QUERY_MAX_WAIT_MS, SOLANA_COMPUTE_UNIT_LIMIT, STORE_RELAY_CAP, STORE_WRITE_ATTEMPTS, SUBSCRIBE_RETRY_MAX_MS, SUBSCRIBE_RETRY_MS, SUBSCRIBE_STABLE_MS, TERMINAL_STATES, WRAP_BACKDATE_SECS, applyStatus, cancelledUnpaid, checkBeforePaying, checkSignedTransaction, clockAgrees, compareOffers, composeOrderPayment, createPool, createRelayClient, deliveryLink, endOrder, endSolanaOrder, endTempoOrder, gone, holdsPayExclusion, isEventShaped, isGenuineEvent, isPageOrigin, isSnapshotStale, isTerminal, judgeAdd, judgeClearMarker, judgeSetMarker, judgeUpdate, judgeUpdateMarker, listenForStatus, loadOffer, loadOfferForAgent, localSolanaWallet, mayStillBePaid, mediumOf, mergePins, newestGenuine, newestStoreInbox, normalizeRelayUrl, nowSecs, onOtherTerms, payWithSolana, payWithTempo, placeOrder, readChainTime, readRelays, readStoreInbox, readTempoChainTime, recordToShow, relayHost, resumeOrder, retryWithSolana, saveTempoHash, sendReceipt, statusFor, storeRelays, storedSolanaRequest, storedTempoRequest, tempoFeeMargin, tempoLateDeadline, uniqueRelays, watchSolanaPayment, watchTempoPayment };
 //# sourceMappingURL=buyer.js.map
 //# sourceMappingURL=buyer.js.map