@elisym/commerce 0.2.0 → 0.3.0

package/dist/buyer.js

@@ -0,0 +1,1799 @@
+import { MAX_FUTURE_SKEW_SECS, isPublicHostname, KIND_INBOX_RELAYS, decodeProductNaddr, verifyOffer, priceInSubunits, productAddress, deriveOrderPaymentReference, buildOrderMessage, wrapOrderMessage, unwrapOrderMessage, KIND_GIFT_WRAP, isOfferPayout, parseCaip19 } from './chunk-DYXVY6VD.js';
+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 { TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda } from '@solana-program/token';
+import { SimplePool } from 'nostr-tools/pool';
+
+// src/buyer/constants.ts
+var DEFAULT_RELAYS = [
+  "wss://relay.elisym.network",
+  "wss://relay.damus.io",
+  "wss://nos.lol",
+  "wss://relay.nostr.band"
+];
+var STORE_RELAY_CAP = 8;
+var MAX_RELAY_URL_LENGTH = 256;
+var OFFER_SNAPSHOT_MAX_AGE_SECS = 120;
+var ORDER_ACK_TARGET = 2;
+var RELAY_QUERY_MAX_WAIT_MS = 4e3;
+var RELAY_QUERY_DEADLINE_MS = 15e3;
+var RELAY_CONNECT_MAX_WAIT_MS = 6e3;
+var RELAY_PUBLISH_DEADLINE_MS = 2e4;
+var SUBSCRIBE_RETRY_MAX_MS = 6e4;
+var SUBSCRIBE_RETRY_MS = [1e3, 5e3, 15e3, SUBSCRIBE_RETRY_MAX_MS];
+var SUBSCRIBE_STABLE_MS = 3e4;
+var STORE_WRITE_ATTEMPTS = 5;
+var MAX_CLOCK_SKEW_SECS = 5 * 60;
+var WRAP_BACKDATE_SECS = 2 * 24 * 60 * 60;
+var MERCHANT_CATCH_UP_SECS = 3 * 24 * 60 * 60;
+var PAY_CUTOFF_SECS = 60 * 60;
+var PAYMENT_SCAN_MARGIN_SECS = 30 * 60;
+var SOLANA_COMPUTE_UNIT_LIMIT = 2e5;
+function isEventShaped(event) {
+  if (typeof event !== "object" || event === null) {
+    return false;
+  }
+  const record = { ...event };
+  const { id, pubkey, created_at: createdAt, kind, tags, content, sig } = record;
+  return typeof id === "string" && typeof pubkey === "string" && typeof createdAt === "number" && Number.isInteger(createdAt) && typeof kind === "number" && Number.isInteger(kind) && typeof content === "string" && typeof sig === "string" && Array.isArray(tags) && tags.every((tag) => Array.isArray(tag) && tag.every((item) => typeof item === "string"));
+}
+function isGenuineEvent(event) {
+  if (!isEventShaped(event)) {
+    return false;
+  }
+  return verifyEvent({
+    id: event.id,
+    pubkey: event.pubkey,
+    created_at: event.created_at,
+    kind: event.kind,
+    tags: event.tags,
+    content: event.content,
+    sig: event.sig
+  });
+}
+function newestGenuine(events, kind, author, now) {
+  let newest;
+  for (const event of events) {
+    if (!isEventShaped(event) || event.kind !== kind || event.pubkey !== author || event.created_at > now + MAX_FUTURE_SKEW_SECS || !isGenuineEvent(event)) {
+      continue;
+    }
+    if (newest === void 0 || event.created_at > newest.created_at || event.created_at === newest.created_at && event.id < newest.id) {
+      newest = event;
+    }
+  }
+  return newest;
+}
+function nowSecs() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// src/buyer/relays.ts
+function normalizeRelayUrl(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > MAX_RELAY_URL_LENGTH) {
+    return void 0;
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return void 0;
+  }
+  if (url.protocol !== "wss:" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !isPublicHostname(url.hostname)) {
+    return void 0;
+  }
+  const path = url.pathname.replace(/\/+/g, "/").replace(/\/$/, "");
+  return `wss://${url.host}${path}`;
+}
+function relayHost(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+function uniqueRelays(values) {
+  const relays = [];
+  for (const value of values) {
+    const relay = normalizeRelayUrl(value);
+    if (relay !== void 0 && !relays.includes(relay)) {
+      relays.push(relay);
+    }
+  }
+  return relays;
+}
+function storeRelays(sources) {
+  return uniqueRelays([
+    ...sources.inbox ?? [],
+    ...sources.acknowledged ?? [],
+    ...sources.hints ?? []
+  ]).slice(0, STORE_RELAY_CAP);
+}
+function readRelays(sources) {
+  const named = storeRelays(sources);
+  return [...DEFAULT_RELAYS, ...named.filter((relay) => !DEFAULT_RELAYS.includes(relay))];
+}
+
+// src/buyer/inbox.ts
+function newestStoreInbox(events, storePubkey, now = nowSecs()) {
+  const event = newestGenuine(events, KIND_INBOX_RELAYS, storePubkey, now);
+  if (event === void 0) {
+    return void 0;
+  }
+  const relays = uniqueRelays(
+    event.tags.filter((tag) => tag[0] === "relay").map((tag) => tag[1])
+  ).slice(0, STORE_RELAY_CAP);
+  return relays.length === 0 ? void 0 : { relays, event };
+}
+async function readStoreInbox(client, sources, storePubkey, now) {
+  const events = await client.query(readRelays(sources), [
+    { kinds: [KIND_INBOX_RELAYS], authors: [storePubkey] }
+  ]);
+  return newestStoreInbox(events, storePubkey, now);
+}
+function localSolanaWallet(signer) {
+  return {
+    address: signer.address,
+    async signTransaction(bytes) {
+      const decoded = getTransactionDecoder().decode(bytes);
+      const signed = await partiallySignTransaction([signer.keyPair], decoded);
+      return new Uint8Array(getTransactionEncoder().encode(signed));
+    }
+  };
+}
+async function readChainTime(rpc) {
+  const slot = await rpc.getSlot({ commitment: "finalized" }).send();
+  for (let back = 0n; back < 5n; back += 1n) {
+    const time = await rpc.getBlockTime(slot - back).send();
+    if (time !== null) {
+      return Number(time);
+    }
+  }
+  throw new Error("no block time");
+}
+
+// src/buyer/offer.ts
+var CONFIRM_WARNINGS = [
+  "payout_recently_changed",
+  "payout_changed"
+];
+function isPageOrigin(value) {
+  if (typeof value !== "string" || value === "null") {
+    return false;
+  }
+  try {
+    const url = new URL(value);
+    return (url.protocol === "https:" || url.protocol === "http:") && url.origin === value;
+  } catch {
+    return false;
+  }
+}
+function isSnapshotStale(snapshotAt, now = nowSecs()) {
+  return now - snapshotAt > OFFER_SNAPSHOT_MAX_AGE_SECS;
+}
+function refuse(refusal, message) {
+  return { ok: false, refusal, message };
+}
+async function loadOffer(naddr, options) {
+  if (!isPageOrigin(options.pageOrigin)) {
+    return refuse("bad_page_origin", "The page embedding the checkout has no usable origin");
+  }
+  return loadVerified(naddr, options, options.pageOrigin);
+}
+function loadOfferForAgent(naddr, options) {
+  return loadVerified(naddr, options, void 0);
+}
+async function loadVerified(naddr, options, pageOrigin) {
+  const pointer = decodeProductNaddr(naddr);
+  if (pointer === void 0) {
+    return refuse("bad_pointer", "Not a product naddr");
+  }
+  const now = options.now ?? nowSecs();
+  const hints = uniqueRelays(pointer.relays);
+  const relays = readRelays({ hints });
+  const verification = await verifyOffer(
+    naddr,
+    {
+      fetchEvents: (filters) => options.client.query(relays, filters),
+      ...options.fetch === void 0 ? {} : { fetch: options.fetch },
+      ...options.resolveDomain === void 0 ? {} : { resolveDomain: options.resolveDomain }
+    },
+    {
+      now,
+      ...pageOrigin === void 0 ? {} : { pageOrigin },
+      ...options.strictOrigin === true ? { strictOrigin: true } : {},
+      ...options.pins?.pinnedOwnerPubkey === void 0 ? {} : { pinnedOwnerPubkey: options.pins.pinnedOwnerPubkey },
+      ...options.pins?.knownPayouts === void 0 ? {} : { knownPayouts: options.pins.knownPayouts }
+    }
+  );
+  if (!verification.ok) {
+    return refuse(verification.refusal, verification.message);
+  }
+  const { offer } = verification;
+  if (offer.warnings.includes("origin_mismatch")) {
+    return refuse("origin_mismatch", "This store does not sell on this site");
+  }
+  const payouts = [];
+  for (const target of offer.payouts) {
+    const { chain, asset } = target.caip19;
+    if (!options.families.includes(chain.family)) {
+      continue;
+    }
+    if (options.network !== void 0 && chain.network !== options.network) {
+      continue;
+    }
+    let amount;
+    try {
+      amount = priceInSubunits(offer.product.price, asset);
+    } catch {
+      continue;
+    }
+    if (amount > 0n) {
+      payouts.push({ target, amount });
+    }
+  }
+  if (payouts.length === 0) {
+    return refuse("no_payable_payout", "This product cannot be paid here");
+  }
+  return {
+    ok: true,
+    offer,
+    productAddress: productAddress(offer.product),
+    payouts,
+    confirm: offer.warnings.filter((warning) => CONFIRM_WARNINGS.includes(warning)),
+    notices: offer.warnings.filter((warning) => !CONFIRM_WARNINGS.includes(warning)),
+    hints,
+    relays,
+    snapshotAt: now
+  };
+}
+
+// src/buyer/order-record.ts
+var TERMINAL_STATES = ["completed", "refunded"];
+function isTerminal(record) {
+  return TERMINAL_STATES.includes(record.state);
+}
+function holdsPayExclusion(record) {
+  if (isTerminal(record)) {
+    return false;
+  }
+  if (record.state === "paid" || record.paidTx !== void 0) {
+    return true;
+  }
+  if (record.state === "ended-unpaid" || record.state === "blocked") {
+    return false;
+  }
+  return record.marker !== void 0;
+}
+function showRank(record) {
+  if (isTerminal(record)) {
+    return 2;
+  }
+  if (record.state === "ended-unpaid") {
+    return 3;
+  }
+  if (record.state === "paid" || record.state === "blocked" || record.paidTx !== void 0) {
+    return 0;
+  }
+  const cancelled = record.status?.status === "cancelled";
+  return record.status !== void 0 && (!cancelled || holdsPayExclusion(record)) ? 0 : 1;
+}
+function newer(left, right) {
+  if (left.createdAt !== right.createdAt) {
+    return left.createdAt > right.createdAt ? left : right;
+  }
+  return left.orderId < right.orderId ? left : right;
+}
+function recordToShow(records) {
+  let shown;
+  for (const record of records) {
+    if (shown === void 0 || showRank(record) < showRank(shown)) {
+      shown = record;
+    } else if (showRank(record) === showRank(shown)) {
+      shown = newer(shown, record);
+    }
+  }
+  return shown;
+}
+
+// src/buyer/order-flow.ts
+function mediumOf(chain) {
+  if (chain.network === "mainnet") {
+    return chain.slug;
+  }
+  return chain.slug === "tempo" ? "tempo-moderato" : `${chain.slug}-${chain.network}`;
+}
+function clockAgrees(chainTime, deviceTime) {
+  return Math.abs(chainTime - deviceTime) <= MAX_CLOCK_SKEW_SECS;
+}
+function compareOffers(shown, confirmed, fresh) {
+  const match = fresh.payouts.find(
+    (payout) => payout.target.caip19.id === shown.target.caip19.id && payout.target.address === shown.target.address
+  );
+  if (match === void 0) {
+    return "gone";
+  }
+  if (match.amount !== shown.amount) {
+    return "changed";
+  }
+  return fresh.confirm.every((warning) => confirmed.includes(warning)) ? "same" : "changed";
+}
+async function placeOrder(input, deps) {
+  const { offer, payout } = input;
+  if (!clockAgrees(input.chainTime, input.deviceTime)) {
+    return { ok: false, reason: "clock_skew" };
+  }
+  const offered = offer.payouts.some(
+    (candidate) => candidate.target.caip19.id === payout.target.caip19.id && candidate.target.address === payout.target.address && candidate.amount === payout.amount
+  );
+  if (isSnapshotStale(offer.snapshotAt, input.deviceTime) || !offered) {
+    return { ok: false, reason: "stale_offer" };
+  }
+  const storePubkey = offer.offer.storePubkey;
+  const inbox = await readStoreInbox(
+    deps.readClient,
+    { hints: offer.hints },
+    storePubkey,
+    input.deviceTime
+  );
+  if (inbox === void 0) {
+    return { ok: false, reason: "no_store_inbox" };
+  }
+  const buyerKey = generateSecretKey();
+  const buyerPubkey = getPublicKey(buyerKey);
+  const orderId = crypto.randomUUID();
+  const reference = deriveOrderPaymentReference({ storePubkey, buyerPubkey, orderId });
+  const rumor = buildOrderMessage(
+    {
+      type: "order",
+      storePubkey,
+      orderId,
+      items: [{ product: offer.productAddress, quantity: 1 }],
+      total: {
+        amount: offer.offer.product.price.amount,
+        currency: offer.offer.product.price.currency
+      },
+      ...input.email === void 0 ? {} : { email: input.email }
+    },
+    input.chainTime
+  );
+  const wrapped = wrapOrderMessage(rumor, buyerKey, storePubkey);
+  const chain = payout.target.caip19.chain;
+  const record = {
+    orderId,
+    productAddress: offer.productAddress,
+    storePubkey,
+    buyerSecretKey: bytesToHex(buyerKey),
+    buyerPubkey,
+    createdAt: input.chainTime,
+    version: 1,
+    state: "created",
+    payout: { caip19: payout.target.caip19.id, address: payout.target.address },
+    amount: payout.amount.toString(),
+    medium: mediumOf(chain),
+    reference: chain.family === "solana" ? reference.solana : reference.tempo,
+    offer: offer.offer,
+    // Kept before it is sent: a crash in between is resumed by sending the same wrap.
+    orderWrap: wrapped.recipientWrap,
+    inboxRelays: inbox.relays,
+    acknowledgedRelays: []
+  };
+  await deps.store.add(record);
+  return acknowledge(record, inbox.relays, inbox.relays, deps);
+}
+async function acknowledge(record, sendTo, inbox, deps) {
+  if (record.orderWrap === void 0) {
+    return { ok: false, reason: "not_acknowledged", record };
+  }
+  const client = deps.clientFor(hexToBytes(record.buyerSecretKey));
+  try {
+    const sent = await client.publish(sendTo, record.orderWrap);
+    let current = record;
+    for (let attempt = 0; attempt < STORE_WRITE_ATTEMPTS; attempt += 1) {
+      const acknowledged = [.../* @__PURE__ */ new Set([...current.acknowledgedRelays, ...sent.accepted])];
+      const written = await deps.store.update(current.orderId, current.version, {
+        state: "ordered",
+        inboxRelays: [...inbox],
+        acknowledgedRelays: acknowledged
+      });
+      if (written.ok) {
+        return { ok: true, record: await settleHeldStatus(deps.store, written.record) };
+      }
+      if (written.reason !== "conflict") {
+        const kept = await deps.store.update(current.orderId, current.version, {
+          inboxRelays: [...inbox],
+          acknowledgedRelays: acknowledged
+        });
+        if (kept.ok) {
+          return { ok: false, reason: "not_acknowledged", record: kept.record };
+        }
+        if (kept.reason !== "conflict") {
+          return { ok: false, reason: "not_acknowledged", record: current };
+        }
+      }
+      const stored = await deps.store.get(current.orderId);
+      if (stored === void 0) {
+        return { ok: false, reason: "not_acknowledged", record: current };
+      }
+      if (stored.state !== "created") {
+        return { ok: true, record: stored };
+      }
+      current = stored;
+    }
+    return { ok: false, reason: "not_acknowledged", record: current };
+  } finally {
+    client.close();
+  }
+}
+async function sendReceipt(record, tx, createdAt, deps) {
+  const buyerKey = hexToBytes(record.buyerSecretKey);
+  const rumor = buildOrderMessage(
+    {
+      type: "receipt",
+      storePubkey: record.storePubkey,
+      orderId: record.orderId,
+      payment: { medium: record.medium, reference: record.reference, tx }
+    },
+    createdAt
+  );
+  const wrapped = wrapOrderMessage(rumor, buyerKey, record.storePubkey);
+  const written = await deps.store.update(record.orderId, record.version, {
+    receiptWrap: wrapped.recipientWrap
+  });
+  if (written.ok) {
+    const client = deps.clientFor(buyerKey);
+    try {
+      await client.publish(record.inboxRelays, wrapped.recipientWrap);
+    } finally {
+      client.close();
+    }
+  }
+  return written;
+}
+async function resumeOrder(record, deps, now) {
+  const fresh = await readStoreInbox(
+    deps.readClient,
+    { acknowledged: record.acknowledgedRelays },
+    record.storePubkey,
+    now
+  );
+  const relays = storeRelays({
+    inbox: fresh?.relays ?? record.inboxRelays,
+    acknowledged: record.acknowledgedRelays
+  });
+  if (record.state === "created") {
+    if (fresh === void 0) {
+      return { record, relays };
+    }
+    const placed = await acknowledge(record, relays, fresh.relays, deps);
+    return { record: placed.record ?? record, relays };
+  }
+  const client = deps.clientFor(hexToBytes(record.buyerSecretKey));
+  try {
+    for (const wrap of [record.orderWrap, record.receiptWrap]) {
+      if (wrap !== void 0) {
+        await client.publish(relays, wrap);
+      }
+    }
+  } finally {
+    client.close();
+  }
+  const sameInbox = fresh !== void 0 && fresh.relays.length === record.inboxRelays.length && fresh.relays.every((relay, index) => record.inboxRelays[index] === relay);
+  if (fresh !== void 0 && !sameInbox && !isTerminal(record)) {
+    const moved = await deps.store.update(record.orderId, record.version, {
+      inboxRelays: fresh.relays
+    });
+    if (moved.ok) {
+      return { record: moved.record, relays };
+    }
+  }
+  return { record, relays };
+}
+function statusFor(record, wrap) {
+  const unwrapped = unwrapOrderMessage(wrap, hexToBytes(record.buyerSecretKey));
+  if (unwrapped === void 0 || unwrapped.senderPubkey !== record.storePubkey || unwrapped.message.type !== "status" || unwrapped.message.orderId !== record.orderId || unwrapped.message.buyerPubkey !== record.buyerPubkey) {
+    return void 0;
+  }
+  return unwrapped.message;
+}
+function deliveryLink(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" ? url.href : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function settledState(message) {
+  if (message.status === "completed") {
+    return "completed";
+  }
+  if (message.status === "cancelled" && message.refund !== void 0) {
+    return "refunded";
+  }
+  return void 0;
+}
+async function rememberDelivery(store, record) {
+  await store.rememberDelivery(
+    record.storePubkey,
+    record.offer.ownerPubkey,
+    record.offer.payouts.map((target) => ({ caip19: target.caip19.id, address: target.address }))
+  );
+}
+async function settleHeldStatus(store, record) {
+  const held = record.status;
+  let settles;
+  if (held?.status === "completed") {
+    settles = "completed";
+  } else if (held?.status === "cancelled" && held.refunded === true) {
+    settles = "refunded";
+  }
+  if (settles === void 0) {
+    return record;
+  }
+  const settled = await store.update(record.orderId, record.version, { state: settles });
+  if (!settled.ok) {
+    return record;
+  }
+  if (settles === "completed") {
+    await rememberDelivery(store, settled.record);
+  }
+  return settled.record;
+}
+async function applyStatus(store, orderId, message, at) {
+  const status = {
+    status: message.status,
+    at,
+    ...message.delivery === void 0 ? {} : { delivery: message.delivery.value },
+    ...message.refund === void 0 ? {} : { refunded: true }
+  };
+  for (let attempt = 0; attempt < STORE_WRITE_ATTEMPTS; attempt += 1) {
+    const current = await store.get(orderId);
+    if (current === void 0) {
+      return void 0;
+    }
+    const settles = settledState(message);
+    const heardBefore = current.status?.status === status.status && current.status.delivery === status.delivery && current.status.refunded === status.refunded;
+    if (heardBefore && (settles === void 0 || current.state === settles)) {
+      return current;
+    }
+    const withState = await store.update(orderId, current.version, {
+      status,
+      ...settles === void 0 ? {} : { state: settles }
+    });
+    if (withState.ok) {
+      if (settles === "completed") {
+        await rememberDelivery(store, withState.record);
+      }
+      return withState.record;
+    }
+    if (withState.reason === "conflict") {
+      continue;
+    }
+    if (heardBefore) {
+      return current;
+    }
+    const alone = await store.update(orderId, current.version, { status });
+    if (alone.ok) {
+      return alone.record;
+    }
+    if (alone.reason !== "conflict") {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function listenForStatus(record, relays, deps, onStatus) {
+  const client = deps.clientFor(hexToBytes(record.buyerSecretKey));
+  const subscription = client.subscribe(
+    relays,
+    {
+      kinds: [KIND_GIFT_WRAP],
+      "#p": [record.buyerPubkey],
+      since: record.createdAt - WRAP_BACKDATE_SECS - MAX_FUTURE_SKEW_SECS
+    },
+    (wrap) => {
+      const status = statusFor(record, wrap);
+      if (status !== void 0) {
+        onStatus(status);
+      }
+    }
+  );
+  return {
+    close() {
+      subscription.close();
+      client.close();
+    }
+  };
+}
+
+// src/buyer/order-store.ts
+var PATCH_KEYS = [
+  "state",
+  "paymentRequest",
+  "orderWrap",
+  "receiptWrap",
+  "inboxRelays",
+  "acknowledgedRelays",
+  "paidTx",
+  "status"
+];
+var STATUS_SUCCESSORS = {
+  pending: ["pending", "confirmed", "completed", "cancelled"],
+  confirmed: ["confirmed", "completed", "cancelled"],
+  cancelled: ["cancelled", "completed"],
+  completed: ["completed"]
+};
+var PAID_STATES = ["paid", "completed", "refunded"];
+var NEXT_STATES = {
+  created: ["ordered"],
+  ordered: ["paid", "completed", "refunded", "ended-unpaid"],
+  paying: ["paid", "completed", "refunded", "blocked"],
+  paid: ["completed", "refunded"],
+  "ended-unpaid": ["paid", "completed", "refunded", "blocked"],
+  blocked: ["paid", "completed", "refunded"],
+  completed: [],
+  refunded: []
+};
+function patchRefusal(current, patch) {
+  if (isTerminal(current)) {
+    return "not_ready";
+  }
+  if (patch.state !== void 0 && patch.state !== current.state && !NEXT_STATES[current.state].includes(patch.state)) {
+    return "not_ready";
+  }
+  const nextState = patch.state ?? current.state;
+  if (patch.paymentRequest !== void 0 && (current.paymentRequest !== void 0 || nextState !== "ordered")) {
+    return "not_ready";
+  }
+  if (patch.state === "blocked" && current.state !== "blocked" && !current.payout.caip19.startsWith("eip155:")) {
+    return "not_ready";
+  }
+  if (patch.paidTx !== void 0 && (current.paidTx !== void 0 || !PAID_STATES.includes(nextState))) {
+    return "not_ready";
+  }
+  if (patch.receiptWrap !== void 0 && current.receiptWrap !== void 0 && current.state !== "paying") {
+    return "not_ready";
+  }
+  if (patch.status !== void 0 && current.status !== void 0) {
+    const allowed = STATUS_SUCCESSORS[current.status.status];
+    if (!allowed.includes(patch.status.status)) {
+      return "not_ready";
+    }
+    if (current.status.refunded === true && patch.status.refunded !== true) {
+      return "not_ready";
+    }
+  }
+  if (patch.state === "ordered" && current.state === "created") {
+    const inbox = patch.inboxRelays ?? current.inboxRelays;
+    const inboxHosts = new Set(inbox.map(relayHost));
+    const acknowledgedHosts = new Set(
+      (patch.acknowledgedRelays ?? current.acknowledgedRelays).filter((relay) => inbox.includes(relay)).map(relayHost)
+    );
+    const wrap = patch.orderWrap ?? current.orderWrap;
+    if (wrap === void 0 || !isGenuineEvent(wrap) || inboxHosts.size === 0 || acknowledgedHosts.size < Math.min(ORDER_ACK_TARGET, inboxHosts.size)) {
+      return "not_ready";
+    }
+  }
+  if (patch.orderWrap !== void 0 && current.orderWrap !== void 0) {
+    return "not_ready";
+  }
+  return void 0;
+}
+function storeClosed(record) {
+  return record.status?.status === "cancelled" || record.status?.status === "completed";
+}
+function railOf(record) {
+  return record.payout.caip19.startsWith("eip155:") ? "tempo" : "solana";
+}
+function markerEvidence(marker) {
+  return marker.rail === "solana" ? [marker.signature ?? "", marker.signedTransaction ?? ""] : [marker.txHash ?? "", marker.bundleId ?? ""];
+}
+function holdsEvidence(marker) {
+  return markerEvidence(marker).some((value) => value !== "");
+}
+function keepsEvidence(current, next) {
+  const before = markerEvidence(current);
+  const after = markerEvidence(next);
+  return before.every((value, index) => value === "" || value === after[index]);
+}
+function refused(reason, holder) {
+  return { result: holder === void 0 ? { ok: false, reason } : { ok: false, reason, holder } };
+}
+function accepted(record) {
+  return { result: { ok: true, record }, write: [record] };
+}
+function exclusionHolder(records, current) {
+  return records.find(
+    (sibling) => sibling.orderId !== current.orderId && holdsPayExclusion(sibling)
+  );
+}
+function judgedRecord(records, orderId, expectedVersion) {
+  const current = records.find((record) => record.orderId === orderId);
+  if (current === void 0) {
+    return refused("missing");
+  }
+  if (current.version !== expectedVersion) {
+    return refused("conflict");
+  }
+  return current;
+}
+function isJudged(value) {
+  return "result" in value;
+}
+function judgeAdd(records, record) {
+  if (record.state !== "created" || record.version !== 1 || record.marker !== void 0) {
+    throw new Error("A new order record starts as created, at version 1, with no marker");
+  }
+  if (records.some((existing) => existing.orderId === record.orderId)) {
+    throw new Error("An order record with this id already exists");
+  }
+  return { result: { ok: true, record }, write: [record] };
+}
+function judgeUpdate(records, orderId, expectedVersion, patch) {
+  const current = judgedRecord(records, orderId, expectedVersion);
+  if (isJudged(current)) {
+    return current;
+  }
+  const defined = {};
+  for (const key of PATCH_KEYS) {
+    if (patch[key] !== void 0) {
+      Object.assign(defined, { [key]: patch[key] });
+    }
+  }
+  const refusal = patchRefusal(current, defined);
+  if (refusal !== void 0) {
+    return refused(refusal);
+  }
+  return accepted({ ...current, ...defined, version: current.version + 1 });
+}
+function judgeSetMarker(records, orderId, expectedVersion, marker) {
+  const current = judgedRecord(records, orderId, expectedVersion);
+  if (isJudged(current)) {
+    return current;
+  }
+  if (current.state !== "ordered" || current.marker !== void 0 || current.paymentRequest === void 0 || storeClosed(current) || marker.rail !== railOf(current)) {
+    return refused("not_ready");
+  }
+  const holder = exclusionHolder(records, current);
+  if (holder !== void 0) {
+    return refused("exclusion", holder.orderId);
+  }
+  return accepted({ ...current, marker, state: "paying", version: current.version + 1 });
+}
+function judgeUpdateMarker(records, orderId, expectedVersion, attemptId, next) {
+  const current = records.find((record) => record.orderId === orderId);
+  if (current === void 0) {
+    return refused("missing");
+  }
+  if (current.version !== expectedVersion || current.marker?.attemptId !== attemptId || current.marker.rail !== next.rail) {
+    return refused("conflict");
+  }
+  if (current.state !== "paying") {
+    return refused("not_ready");
+  }
+  const retry = next.attemptId !== attemptId;
+  const windowMoved = current.marker.rail === "solana" && next.rail === "solana" ? next.blockhash !== current.marker.blockhash || next.lastValidBlockHeight !== current.marker.lastValidBlockHeight || next.slot !== current.marker.slot : current.marker.rail === "tempo" && next.rail === "tempo" && next.floorBlock !== current.marker.floorBlock;
+  if (retry && next.rail === "tempo" || !retry && !keepsEvidence(current.marker, next) || !retry && windowMoved) {
+    return refused("not_ready");
+  }
+  if (retry && storeClosed(current)) {
+    return refused("not_ready");
+  }
+  if (retry) {
+    const holder = exclusionHolder(records, current);
+    if (holder !== void 0) {
+      return refused("exclusion", holder.orderId);
+    }
+  }
+  return accepted({ ...current, marker: next, version: current.version + 1 });
+}
+function judgeClearMarker(records, orderId, expectedVersion, attemptId, nextState) {
+  const current = records.find((record) => record.orderId === orderId);
+  if (current === void 0) {
+    return refused("missing");
+  }
+  if (current.version !== expectedVersion || current.marker?.attemptId !== attemptId) {
+    return refused("conflict");
+  }
+  if (current.state !== "paying") {
+    return refused("not_ready");
+  }
+  if (nextState === "ended-unpaid" && current.marker?.rail === "tempo" && current.marker.bundleId !== void 0) {
+    return refused("not_ready");
+  }
+  if (nextState === "ordered" && current.marker !== void 0 && holdsEvidence(current.marker)) {
+    return refused("not_ready");
+  }
+  if (nextState === "ordered") {
+    const { marker: _removed, ...rest } = current;
+    return accepted({ ...rest, state: nextState, version: current.version + 1 });
+  }
+  return accepted({ ...current, state: nextState, version: current.version + 1 });
+}
+function mergePins(current, storePubkey, ownerPubkey, payouts) {
+  if (current !== void 0 && current.pinnedOwnerPubkey !== ownerPubkey) {
+    return { result: current };
+  }
+  const known = [...current?.knownPayouts ?? []];
+  for (const payout of payouts) {
+    if (!known.some((entry) => entry.caip19 === payout.caip19 && entry.address === payout.address)) {
+      known.push({ caip19: payout.caip19, address: payout.address });
+    }
+  }
+  const record = {
+    storePubkey,
+    pinnedOwnerPubkey: ownerPubkey,
+    knownPayouts: known
+  };
+  return { write: record, result: record };
+}
+var OrderStore = class {
+  constructor(backend) {
+    this.backend = backend;
+  }
+  /** Add a new order: `created`, version 1, no marker. Anything else is refused. */
+  async add(record) {
+    await this.backend.transactProduct(
+      record.productAddress,
+      (records) => judgeAdd(records, record)
+    );
+  }
+  get(orderId) {
+    return this.backend.read(orderId);
+  }
+  /** Every record for a product, oldest first. */
+  async forProduct(productAddress2) {
+    const records = await this.backend.forProduct(productAddress2);
+    return [...records].sort((left, right) => left.createdAt - right.createdAt);
+  }
+  /** Run a rule on the product of `orderId` (it never changes), in one transaction. */
+  async judge(orderId, rule) {
+    const known = await this.backend.read(orderId);
+    if (known === void 0) {
+      return { ok: false, reason: "missing" };
+    }
+    return this.backend.transactProduct(known.productAddress, rule);
+  }
+  /** Change plain fields of the record the caller judged at `expectedVersion`. */
+  update(orderId, expectedVersion, patch) {
+    return this.judge(orderId, (records) => judgeUpdate(records, orderId, expectedVersion, patch));
+  }
+  /** See `judgeSetMarker`. */
+  setMarker(orderId, expectedVersion, marker) {
+    return this.judge(
+      orderId,
+      (records) => judgeSetMarker(records, orderId, expectedVersion, marker)
+    );
+  }
+  /** See `judgeUpdateMarker`. */
+  updateMarker(orderId, expectedVersion, attemptId, next) {
+    return this.judge(
+      orderId,
+      (records) => judgeUpdateMarker(records, orderId, expectedVersion, attemptId, next)
+    );
+  }
+  /** See `judgeClearMarker`. */
+  clearMarker(orderId, expectedVersion, attemptId, nextState) {
+    return this.judge(
+      orderId,
+      (records) => judgeClearMarker(records, orderId, expectedVersion, attemptId, nextState)
+    );
+  }
+  pins(storePubkey) {
+    return this.backend.readPins(storePubkey);
+  }
+  /** See `mergePins`. */
+  rememberDelivery(storePubkey, ownerPubkey, payouts) {
+    return this.backend.transactPins(
+      storePubkey,
+      (current) => mergePins(current, storePubkey, ownerPubkey, payouts)
+    );
+  }
+};
+var MemoryOrderBackend = class {
+  orders = /* @__PURE__ */ new Map();
+  stores = /* @__PURE__ */ new Map();
+  async read(orderId) {
+    return structuredClone(this.orders.get(orderId));
+  }
+  snapshot(productAddress2) {
+    return [...this.orders.values()].filter((record) => record.productAddress === productAddress2).map((record) => structuredClone(record));
+  }
+  async forProduct(productAddress2) {
+    return this.snapshot(productAddress2);
+  }
+  // Read, rule and write run with no await between them: no other call can interleave.
+  async transactProduct(productAddress2, fn) {
+    const { write, result } = fn(this.snapshot(productAddress2));
+    for (const record of write ?? []) {
+      this.orders.set(record.orderId, structuredClone(record));
+    }
+    return result;
+  }
+  async readPins(storePubkey) {
+    return structuredClone(this.stores.get(storePubkey));
+  }
+  async transactPins(storePubkey, fn) {
+    const { write, result } = fn(structuredClone(this.stores.get(storePubkey)));
+    if (write !== void 0) {
+      this.stores.set(storePubkey, structuredClone(write));
+    }
+    return result;
+  }
+};
+var SYSTEM_PROGRAM = "11111111111111111111111111111111";
+var COMPUTE_BUDGET_PROGRAM = "ComputeBudget111111111111111111111111111111";
+var SET_COMPUTE_UNIT_LIMIT = 2;
+var SET_COMPUTE_UNIT_PRICE = 3;
+var BASE_FEE_LAMPORTS = 5000n;
+var SIGNATURE_PAGE_LIMIT = 1e3;
+var MAX_SIGNATURE_PAGES = 10;
+var EXPIRY_SETTLE_BLOCKS = 32n;
+var ADVANCE_NONCE_DISCRIMINATOR = 4;
+var MAX_REFERENCE_CANDIDATES = 100;
+var UNSURE_VERDICTS = ["rpc_error", "unreadable", "not_found", "bad_request"];
+function storedSolanaRequest(record) {
+  if (record.paymentRequest === void 0) {
+    return void 0;
+  }
+  const parsed = parsePaymentRequest(record.paymentRequest);
+  return parsed.ok ? parsed.data : void 0;
+}
+function solanaAssetOf(record) {
+  const caip19 = parseCaip19(record.payout.caip19);
+  if (caip19 === void 0 || caip19.chain.family !== "solana") {
+    return void 0;
+  }
+  return { asset: caip19.asset, network: caip19.chain.network };
+}
+async function composeOrderPayment(record, store) {
+  if (record.paymentRequest !== void 0) {
+    return { ok: true, record };
+  }
+  const coin = solanaAssetOf(record);
+  if (coin === void 0) {
+    return { ok: false, reason: "not_ready" };
+  }
+  let request;
+  try {
+    request = composeSolanaPaymentRequest({
+      recipient: record.payout.address,
+      amount: BigInt(record.amount),
+      asset: coin.asset,
+      network: coin.network,
+      reference: record.reference,
+      createdAt: record.createdAt
+    });
+  } catch {
+    return { ok: false, reason: "not_ready" };
+  }
+  const written = await store.update(record.orderId, record.version, {
+    paymentRequest: JSON.stringify(request)
+  });
+  if (!written.ok && written.reason === "conflict") {
+    const current = await store.get(record.orderId);
+    if (current?.paymentRequest !== void 0) {
+      return { ok: true, record: current };
+    }
+  }
+  return written;
+}
+function requestMatches(request, record, coin) {
+  return request.recipient === record.payout.address && request.reference === record.reference && BigInt(request.amount) === BigInt(record.amount) && (request.network ?? "devnet") === coin.network && request.asset?.mint === coin.asset.mint && (request.fee_amount ?? 0) === 0 && request.fee_address === void 0;
+}
+async function checkBeforePaying(record, payer, input, deps) {
+  const request = storedSolanaRequest(record);
+  const coin = solanaAssetOf(record);
+  if (request === void 0 || coin === void 0 || !isAddress(payer) || !requestMatches(request, record, coin)) {
+    return { ok: false, reason: "not_payable", record };
+  }
+  if (isSnapshotStale(input.fresh.snapshotAt, (deps.now ?? nowSecs)())) {
+    return { ok: false, reason: "stale_offer", record };
+  }
+  const match = input.fresh.payouts.find(
+    (payout) => payout.target.caip19.id === record.payout.caip19 && payout.target.address === record.payout.address
+  );
+  if (input.fresh.productAddress !== record.productAddress || !isOfferPayout(input.fresh.offer, record.payout.caip19, record.payout.address) || match === void 0 || match.amount !== BigInt(record.amount)) {
+    return { ok: false, reason: "offer_changed", record };
+  }
+  if (input.chainTime > record.createdAt + MERCHANT_CATCH_UP_SECS - PAY_CUTOFF_SECS) {
+    return { ok: false, reason: "too_late", record };
+  }
+  if (payer === record.payout.address) {
+    return { ok: false, reason: "self_payment", record };
+  }
+  const funds = await checkFunds(deps.rpc, request, payer, coin);
+  if (!funds.ok) {
+    return { ...funds, record };
+  }
+  return { ok: true, request, asset: coin.asset, network: coin.network, funds: funds.funds };
+}
+async function assetAccounts(payer, recipient, asset) {
+  if (asset.mint === void 0) {
+    return { payer, payee: recipient };
+  }
+  const tokenProgram = address(asset.tokenProgram ?? TOKEN_PROGRAM_ADDRESS);
+  const mint = address(asset.mint);
+  const [payerAccount] = await findAssociatedTokenPda({
+    owner: address(payer),
+    mint,
+    tokenProgram
+  });
+  const [payeeAccount] = await findAssociatedTokenPda({
+    owner: address(recipient),
+    mint,
+    tokenProgram
+  });
+  return { payer: payerAccount, payee: payeeAccount };
+}
+async function tokenBalance(rpc, account) {
+  const info = await rpc.getAccountInfo(address(account), { commitment: "confirmed", encoding: "base64" }).send();
+  if (info.value === null) {
+    return 0n;
+  }
+  const balance = await rpc.getTokenAccountBalance(address(account), { commitment: "confirmed" }).send();
+  return BigInt(balance.value.amount);
+}
+async function checkFunds(rpc, request, payer, coin) {
+  try {
+    const amount = BigInt(request.amount);
+    const accounts = await assetAccounts(payer, request.recipient, coin.asset);
+    const priceMicroLamports = await estimatePriorityFeeMicroLamports(rpc, {
+      network: coin.network,
+      accounts: [address(accounts.payer), address(accounts.payee)]
+    });
+    const fees = await estimateSolFeeLamports(rpc, request, payer, coin.network, {
+      computeUnitLimit: SOLANA_COMPUTE_UNIT_LIMIT,
+      priorityFeeMicroLamports: priceMicroLamports
+    });
+    const rentFloor = await rpc.getMinimumBalanceForRentExemption(0n).send();
+    const lamports = (await rpc.getBalance(address(payer), { commitment: "confirmed" }).send()).value;
+    const otherLamports = fees.rentLamports + fees.assetStatsRentLamports + rentFloor + (coin.asset.mint === void 0 ? amount : 0n);
+    const feeLamports = fees.baseFeeLamports + fees.priorityFeeLamports;
+    if (coin.asset.mint !== void 0) {
+      const tokens = await tokenBalance(rpc, accounts.payer);
+      if (tokens < amount) {
+        return { ok: false, reason: "insufficient_token", needed: amount, available: tokens };
+      }
+    }
+    if (lamports < otherLamports + feeLamports) {
+      return {
+        ok: false,
+        reason: "insufficient_sol",
+        needed: otherLamports + feeLamports,
+        available: lamports
+      };
+    }
+    const costs = {
+      asset: coin.asset,
+      tokenAmount: coin.asset.mint === void 0 ? 0n : amount,
+      lamports: fees.rentLamports + fees.assetStatsRentLamports + feeLamports + (coin.asset.mint === void 0 ? amount : 0n),
+      feeLamports
+    };
+    return { ok: true, funds: { lamports, otherLamports, priceMicroLamports, costs } };
+  } catch {
+    return { ok: false, reason: "rpc_error" };
+  }
+}
+async function unsignedPayment(rpc, checked, payer) {
+  const payerAddress = address(payer);
+  const instructions = await buildPaymentInstructions(
+    checked.request,
+    createNoopSigner(payerAddress),
+    { programId: getProtocolProgramId(checked.network) }
+  );
+  const { context, value: latest } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
+  const message = pipe(
+    createTransactionMessage({ version: 0 }),
+    (draft) => setTransactionMessageFeePayer(payerAddress, draft),
+    (draft) => setTransactionMessageLifetimeUsingBlockhash(latest, draft),
+    (draft) => setTransactionMessageComputeUnitLimit(SOLANA_COMPUTE_UNIT_LIMIT, draft),
+    (draft) => setTransactionMessageComputeUnitPrice(checked.funds.priceMicroLamports, draft),
+    (draft) => appendTransactionMessageInstructions(
+      // pay-core types its instructions loosely; the same cast its own builder uses.
+      instructions,
+      draft
+    )
+  );
+  return {
+    bytes: new Uint8Array(getTransactionEncoder().encode(compileTransaction(message))),
+    blockhash: latest.blockhash,
+    lastValidBlockHeight: latest.lastValidBlockHeight,
+    slot: BigInt(context.slot)
+  };
+}
+function transactionFee(instructions, signatures) {
+  let limit;
+  let price = 0n;
+  let limits = 0;
+  let prices = 0;
+  let others = 0;
+  for (const instruction of instructions) {
+    if (instruction.program !== COMPUTE_BUDGET_PROGRAM) {
+      others += 1;
+      continue;
+    }
+    const view = new DataView(
+      instruction.data.buffer,
+      instruction.data.byteOffset,
+      instruction.data.byteLength
+    );
+    if (instruction.data[0] === SET_COMPUTE_UNIT_LIMIT && instruction.data.length === 5) {
+      limits += 1;
+      limit = BigInt(view.getUint32(1, true));
+    } else if (instruction.data[0] === SET_COMPUTE_UNIT_PRICE && instruction.data.length === 9) {
+      prices += 1;
+      price = view.getBigUint64(1, true);
+    }
+  }
+  if (limits > 1 || prices > 1) {
+    return void 0;
+  }
+  const units = limit ?? BigInt(Math.min(others * 2e5, 14e5));
+  return BASE_FEE_LAMPORTS * BigInt(signatures) + (price * units + 999999n) / 1000000n;
+}
+async function checkSignedTransaction(bytes, expected) {
+  let transaction;
+  let message;
+  let instructions;
+  try {
+    transaction = getTransactionDecoder().decode(bytes);
+    message = getCompiledTransactionMessageDecoder().decode(transaction.messageBytes);
+    instructions = directInstructionsFromCompiledMessage(message);
+  } catch {
+    return { ok: false, reason: "unreadable" };
+  }
+  const first = instructions[0];
+  const durableNonce = first !== void 0 && first.program === SYSTEM_PROGRAM && first.data.length >= 4 && new DataView(first.data.buffer, first.data.byteOffset, 4).getUint32(0, true) === ADVANCE_NONCE_DISCRIMINATOR;
+  if (message.lifetimeToken !== expected.blockhash || durableNonce) {
+    return { ok: false, reason: "lifetime_changed" };
+  }
+  if (String(message.staticAccounts[0]) !== expected.payer) {
+    return { ok: false, reason: "wrong_payer" };
+  }
+  const signatures = Object.entries(transaction.signatures);
+  if (signatures.length === 0) {
+    return { ok: false, reason: "unsigned" };
+  }
+  for (const [signer, signature] of signatures) {
+    let valid = false;
+    try {
+      valid = signature !== null && await verifySignature(
+        await getPublicKeyFromAddress(address(signer)),
+        signature,
+        transaction.messageBytes
+      );
+    } catch {
+      valid = false;
+    }
+    if (!valid) {
+      return { ok: false, reason: "unsigned" };
+    }
+  }
+  const payerSignature = transaction.signatures[address(expected.payer)] ?? null;
+  const feeLamports = transactionFee(instructions, signatures.length);
+  if (feeLamports === void 0) {
+    return { ok: false, reason: "duplicate_compute_budget" };
+  }
+  const bound = await boundTransferAmount(instructions, {
+    reference: expected.request.reference,
+    recipient: expected.request.recipient,
+    asset: expected.asset
+  });
+  if (payerSignature === null || bound !== BigInt(expected.request.amount)) {
+    return { ok: false, reason: payerSignature === null ? "unsigned" : "not_bound" };
+  }
+  return {
+    ok: true,
+    signature: getBase58Decoder().decode(payerSignature),
+    wire: getBase64Decoder().decode(bytes),
+    feeLamports
+  };
+}
+async function broadcast(rpc, wire) {
+  try {
+    await rpc.sendTransaction(wire, {
+      encoding: "base64",
+      skipPreflight: true
+    }).send();
+  } catch {
+  }
+}
+async function signAndSend(record, marker, unsigned, wallet, checked, deps) {
+  let signedBytes;
+  try {
+    signedBytes = await wallet.signTransaction(unsigned.bytes);
+  } catch {
+    return { ok: false, reason: "wallet_failed", record };
+  }
+  const signed = await checkSignedTransaction(signedBytes, {
+    payer: wallet.address,
+    blockhash: unsigned.blockhash,
+    request: checked.request,
+    asset: checked.asset
+  });
+  if (!signed.ok) {
+    return { ok: false, reason: "wallet_unsupported", record, detail: signed.reason };
+  }
+  const needed = checked.funds.otherLamports + signed.feeLamports;
+  if (checked.funds.lamports < needed) {
+    deps.release?.(marker.attemptId);
+    return {
+      ok: false,
+      reason: "insufficient_sol",
+      record,
+      needed,
+      available: checked.funds.lamports
+    };
+  }
+  let current = record;
+  for (let attempt = 0; attempt < STORE_WRITE_ATTEMPTS && current !== void 0; attempt += 1) {
+    if (current.marker?.attemptId !== marker.attemptId) {
+      deps.release?.(marker.attemptId);
+      return { ok: false, reason: "conflict", record: current };
+    }
+    const written = await deps.store.updateMarker(
+      current.orderId,
+      current.version,
+      marker.attemptId,
+      { ...marker, signature: signed.signature, signedTransaction: signed.wire }
+    );
+    if (written.ok) {
+      await broadcast(deps.rpc, signed.wire);
+      const receipt = await sendReceipt(
+        written.record,
+        signed.signature,
+        (deps.now ?? nowSecs)(),
+        deps
+      );
+      return {
+        ok: true,
+        record: receipt.ok ? receipt.record : written.record,
+        signature: signed.signature
+      };
+    }
+    if (written.reason !== "conflict") {
+      deps.release?.(marker.attemptId);
+      return { ok: false, reason: "conflict", record: current };
+    }
+    current = await deps.store.get(record.orderId);
+  }
+  deps.release?.(marker.attemptId);
+  return { ok: false, reason: "conflict", ...current === void 0 ? {} : { record: current } };
+}
+function storeRefusal(written, record) {
+  if (written.reason === "exclusion") {
+    return {
+      ok: false,
+      reason: "exclusion",
+      record,
+      ...written.holder === void 0 ? {} : { holder: written.holder }
+    };
+  }
+  return { ok: false, reason: written.reason === "conflict" ? "conflict" : "not_payable", record };
+}
+async function withReleaseOnThrow(attemptId, deps, write) {
+  try {
+    return await write();
+  } catch (error) {
+    deps.release?.(attemptId);
+    throw error;
+  }
+}
+function reserveCosts(costs, attemptId, deps) {
+  if (deps.reserve === void 0) {
+    return true;
+  }
+  try {
+    deps.reserve(costs, attemptId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function newMarker(unsigned, deps) {
+  return {
+    rail: "solana",
+    attemptId: (deps.newAttemptId ?? (() => crypto.randomUUID()))(),
+    setAt: (deps.now ?? nowSecs)(),
+    blockhash: unsigned.blockhash,
+    lastValidBlockHeight: unsigned.lastValidBlockHeight.toString(),
+    slot: unsigned.slot.toString()
+  };
+}
+async function payWithSolana(record, wallet, input, deps) {
+  if (record.state !== "ordered" || record.marker !== void 0) {
+    return { ok: false, reason: "not_payable", record };
+  }
+  const checked = await checkBeforePaying(record, wallet.address, input, deps);
+  if (!checked.ok) {
+    return checked;
+  }
+  let unsigned;
+  try {
+    unsigned = await unsignedPayment(deps.rpc, checked, wallet.address);
+  } catch {
+    return { ok: false, reason: "rpc_error", record };
+  }
+  const marker = newMarker(unsigned, deps);
+  if (!reserveCosts(checked.funds.costs, marker.attemptId, deps)) {
+    return { ok: false, reason: "spend_limit", record };
+  }
+  const marked = await withReleaseOnThrow(
+    marker.attemptId,
+    deps,
+    () => deps.store.setMarker(record.orderId, record.version, marker)
+  );
+  if (!marked.ok) {
+    deps.release?.(marker.attemptId);
+    return storeRefusal(marked, record);
+  }
+  return signAndSend(marked.record, marker, unsigned, wallet, checked, deps);
+}
+async function listReference(rpc, reference, notBefore, minContextSlot) {
+  const signatures = [];
+  let before;
+  for (let page = 0; page < MAX_SIGNATURE_PAGES; page += 1) {
+    const rows = await rpc.getSignaturesForAddress(address(reference), {
+      limit: SIGNATURE_PAGE_LIMIT,
+      commitment: "confirmed",
+      ...minContextSlot === void 0 ? {} : { minContextSlot },
+      ...before === void 0 ? {} : { before }
+    }).send();
+    let reachedFloor = false;
+    for (const row of rows) {
+      signatures.push({ signature: row.signature, failed: row.err !== null });
+      if (row.blockTime !== null && Number(row.blockTime) < notBefore) {
+        reachedFloor = true;
+      }
+    }
+    const last = rows[rows.length - 1];
+    if (reachedFloor || rows.length < SIGNATURE_PAGE_LIMIT || last === void 0) {
+      return { signatures, complete: true };
+    }
+    before = last.signature;
+  }
+  return { signatures, complete: false };
+}
+async function searchPayment(record, request, rpc, minContextSlot) {
+  const own = record.marker?.rail === "solana" ? record.marker.signature : void 0;
+  const candidates = own === void 0 ? [] : [own];
+  const listed = /* @__PURE__ */ new Set();
+  let unsure = false;
+  try {
+    const listing = await listReference(
+      rpc,
+      request.reference,
+      record.createdAt - PAYMENT_SCAN_MARGIN_SECS,
+      minContextSlot
+    );
+    unsure = !listing.complete;
+    for (const entry of listing.signatures) {
+      listed.add(entry.signature);
+      if (!entry.failed && !candidates.includes(entry.signature)) {
+        candidates.push(entry.signature);
+      }
+    }
+  } catch {
+    unsure = true;
+  }
+  if (candidates.length > MAX_REFERENCE_CANDIDATES) {
+    unsure = true;
+  }
+  for (const signature of candidates.slice(0, MAX_REFERENCE_CANDIDATES)) {
+    let verdict;
+    try {
+      verdict = await verifyDirectSolanaPayment(rpc, request, signature);
+    } catch {
+      unsure = true;
+      continue;
+    }
+    if (verdict.verified) {
+      return { found: signature };
+    }
+    if (!UNSURE_VERDICTS.includes(verdict.reason)) {
+      continue;
+    }
+    if (verdict.reason === "not_found" && !listed.has(signature) && (signature !== own || minContextSlot === void 0 || !await statusKnown(rpc, signature, minContextSlot))) {
+      continue;
+    }
+    unsure = true;
+  }
+  return unsure ? "unsure" : "none";
+}
+async function statusKnown(rpc, signature, minContextSlot) {
+  try {
+    const statuses = await rpc.getSignatureStatuses([signature], { searchTransactionHistory: true }).send();
+    const status = statuses.value[0];
+    return BigInt(statuses.context.slot) < minContextSlot || status !== null && status !== void 0;
+  } catch {
+    return true;
+  }
+}
+async function recordPaid(record, signature, deps) {
+  let current = record;
+  const own = record.marker?.rail === "solana" ? record.marker.signature : void 0;
+  if (current.receiptWrap === void 0 || current.state === "paying" && own !== signature) {
+    const receipt = await sendReceipt(current, signature, (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) {
+      return current;
+    }
+    const written = await deps.store.update(current.orderId, current.version, {
+      state: "paid",
+      paidTx: signature
+    });
+    if (written.ok) {
+      return written.record;
+    }
+    if (written.reason !== "conflict") {
+      return current;
+    }
+    current = await deps.store.get(record.orderId);
+  }
+  return current ?? record;
+}
+async function ledgerReaches(rpc, slot) {
+  if (slot === void 0) {
+    return false;
+  }
+  try {
+    return BigInt(await rpc.getFirstAvailableBlock().send()) <= BigInt(slot);
+  } catch {
+    return false;
+  }
+}
+async function watchSolanaPayment(record, deps) {
+  if (isTerminal(record)) {
+    return { state: "closed", record };
+  }
+  if (record.paidTx !== void 0) {
+    if (record.receiptWrap === void 0) {
+      const receipt = await sendReceipt(record, record.paidTx, (deps.now ?? nowSecs)(), deps);
+      return { state: "paid", record: receipt.ok ? receipt.record : record };
+    }
+    return { state: "paid", record };
+  }
+  const marker = record.marker;
+  const request = storedSolanaRequest(record);
+  if (marker?.rail !== "solana" || request === void 0) {
+    return { state: "waiting", record };
+  }
+  let expired = false;
+  let settledAt;
+  try {
+    const epoch = await deps.rpc.getEpochInfo({ commitment: "finalized" }).send();
+    const lastValid = BigInt(marker.lastValidBlockHeight);
+    expired = BigInt(epoch.blockHeight) > lastValid;
+    if (BigInt(epoch.blockHeight) > lastValid + EXPIRY_SETTLE_BLOCKS) {
+      settledAt = BigInt(epoch.absoluteSlot);
+    }
+  } catch {
+    expired = false;
+  }
+  if (settledAt !== void 0 && !await ledgerReaches(deps.rpc, marker.slot)) {
+    settledAt = void 0;
+  }
+  const search = await searchPayment(record, request, deps.rpc, settledAt);
+  if (search !== "none" && search !== "unsure") {
+    return { state: "paid", record: await recordPaid(record, search.found, deps) };
+  }
+  if (!expired) {
+    if (marker.signedTransaction !== void 0) {
+      await broadcast(deps.rpc, marker.signedTransaction);
+    }
+    return { state: "waiting", record };
+  }
+  return search === "none" && settledAt !== void 0 && deps.canProveOver !== false ? { state: "over", record } : { state: "waiting", record };
+}
+async function retryWithSolana(record, wallet, input, deps) {
+  if (record.state !== "paying" || record.marker?.rail !== "solana") {
+    return { ok: false, reason: "not_payable", record };
+  }
+  const watch = await watchSolanaPayment(record, deps);
+  if (watch.state !== "over") {
+    const reasons = {
+      paid: "already_paid",
+      waiting: "still_waiting",
+      closed: "not_payable"
+    };
+    return { ok: false, reason: reasons[watch.state], record: watch.record };
+  }
+  const judged = watch.record;
+  const previous = judged.marker;
+  if (previous === void 0) {
+    return { ok: false, reason: "not_payable", record: judged };
+  }
+  const checked = await checkBeforePaying(judged, wallet.address, input, deps);
+  if (!checked.ok) {
+    return checked;
+  }
+  let unsigned;
+  try {
+    unsigned = await unsignedPayment(deps.rpc, checked, wallet.address);
+  } catch {
+    return { ok: false, reason: "rpc_error", record: judged };
+  }
+  const marker = newMarker(unsigned, deps);
+  if (!reserveCosts(checked.funds.costs, marker.attemptId, deps)) {
+    return { ok: false, reason: "spend_limit", record: judged };
+  }
+  const replaced = await withReleaseOnThrow(
+    marker.attemptId,
+    deps,
+    () => deps.store.updateMarker(judged.orderId, judged.version, previous.attemptId, marker)
+  );
+  if (!replaced.ok) {
+    deps.release?.(marker.attemptId);
+    return storeRefusal(replaced, judged);
+  }
+  return signAndSend(replaced.record, marker, unsigned, wallet, checked, deps);
+}
+async function endSolanaOrder(record, deps) {
+  if (record.state === "ordered" && record.marker === void 0) {
+    const written2 = await deps.store.update(record.orderId, record.version, {
+      state: "ended-unpaid"
+    });
+    return written2.ok ? { ended: true, record: written2.record } : { ended: false, record };
+  }
+  if (record.state !== "paying" || record.marker === void 0) {
+    return { ended: false, record };
+  }
+  const watch = await watchSolanaPayment(record, deps);
+  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"
+  );
+  return written.ok ? { ended: true, record: written.record } : { ended: false, record: watch.record };
+}
+
+// src/buyer/purchase.ts
+function cancelledUnpaid(record) {
+  return record.status?.status === "cancelled" && record.paidTx === void 0 && (record.state === "created" || record.state === "ordered");
+}
+function gone(record) {
+  return record.state === "ended-unpaid" && record.paidTx === void 0;
+}
+function onOtherTerms(record, payout) {
+  return cancelledUnpaid(record) || record.payout.caip19 !== payout.target.caip19.id || record.payout.address !== payout.target.address || record.amount !== payout.amount.toString();
+}
+async function endOrder(record, deps) {
+  if (record.state === "created") {
+    return { ended: true, record };
+  }
+  if (deps.rpc !== void 0) {
+    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"
+    });
+    return written.ok ? { ended: true, record: written.record } : { ended: false, record };
+  }
+  return { ended: false, record };
+}
+function withDeadline(promise, ms) {
+  let timer;
+  const deadline = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error("timed out")), ms);
+  });
+  return Promise.race([promise, deadline]).finally(() => clearTimeout(timer));
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createPool() {
+  return new SimplePool();
+}
+function createRelayClient(options = {}) {
+  const pool = options.pool ?? createPool();
+  function queryRelay(relay, filter) {
+    return new Promise((resolve) => {
+      const events = [];
+      let subscription;
+      const deadline = setTimeout(() => {
+        subscription?.close("deadline");
+        resolve(events);
+      }, RELAY_QUERY_DEADLINE_MS);
+      try {
+        subscription = pool.subscribeEose([relay], filter, {
+          maxWait: RELAY_QUERY_MAX_WAIT_MS,
+          ...options.auth === void 0 ? {} : { onauth: options.auth },
+          onevent: (event) => events.push(event),
+          onclose: () => {
+            clearTimeout(deadline);
+            resolve(events);
+          }
+        });
+      } catch (error) {
+        clearTimeout(deadline);
+        throw error;
+      }
+    });
+  }
+  async function publishOne(url, event) {
+    const relay = await pool.ensureRelay(url, { connectionTimeout: RELAY_CONNECT_MAX_WAIT_MS });
+    try {
+      return await relay.publish(event);
+    } catch (error) {
+      if (options.auth !== void 0 && errorText(error).startsWith("auth-required")) {
+        await relay.auth(options.auth);
+        return relay.publish(event);
+      }
+      throw error;
+    }
+  }
+  function publishWithDeadline(url, event) {
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => reject(new Error("timed out")), RELAY_PUBLISH_DEADLINE_MS);
+    });
+    return Promise.race([publishOne(url, event), deadline]).finally(() => clearTimeout(timer));
+  }
+  const liveClosers = /* @__PURE__ */ new Set();
+  function listenOn(url, filter, onEvent) {
+    let closed = false;
+    let attempt = 0;
+    let authenticatedOn;
+    let current;
+    let timer;
+    const again = () => {
+      if (closed) {
+        return;
+      }
+      const pause = SUBSCRIBE_RETRY_MS[Math.min(attempt, SUBSCRIBE_RETRY_MS.length - 1)] ?? SUBSCRIBE_RETRY_MAX_MS;
+      attempt += 1;
+      timer = setTimeout(() => void open(), pause);
+    };
+    const open = async () => {
+      if (closed) {
+        return;
+      }
+      let relay;
+      try {
+        relay = await pool.ensureRelay(url, { connectionTimeout: RELAY_CONNECT_MAX_WAIT_MS });
+      } catch {
+        again();
+        return;
+      }
+      if (closed) {
+        return;
+      }
+      let liveSince;
+      const subscription = relay.subscribe([filter], {
+        onevent: onEvent,
+        // nostr-tools also fires this on its own EOSE timeout, even after a CLOSED:
+        // only a subscription still open counts.
+        oneose: () => {
+          if (current === subscription) {
+            liveSince = Date.now();
+          }
+        },
+        onclose: (reason) => {
+          if (current === subscription) {
+            current = void 0;
+            if (liveSince !== void 0 && Date.now() - liveSince >= SUBSCRIBE_STABLE_MS) {
+              attempt = 0;
+            }
+          }
+          if (closed) {
+            return;
+          }
+          if (options.auth !== void 0 && authenticatedOn !== relay && reason.startsWith("auth-required")) {
+            authenticatedOn = relay;
+            withDeadline(relay.auth(options.auth), RELAY_PUBLISH_DEADLINE_MS).then(
+              () => void open(),
+              () => again()
+            );
+            return;
+          }
+          again();
+        }
+      });
+      current = subscription;
+    };
+    void open();
+    return () => {
+      closed = true;
+      clearTimeout(timer);
+      current?.close("closed by caller");
+    };
+  }
+  return {
+    subscribe(relays, filter, onEvent) {
+      const seen = /* @__PURE__ */ new Set();
+      const handOn = (event) => {
+        if (!seen.has(event.id) && isGenuineEvent(event)) {
+          seen.add(event.id);
+          onEvent(event);
+        }
+      };
+      const closers = relays.map((relay) => listenOn(relay, filter, handOn));
+      const closeAll = () => {
+        for (const close of closers) {
+          close();
+        }
+        liveClosers.delete(closeAll);
+      };
+      liveClosers.add(closeAll);
+      return { close: closeAll };
+    },
+    async query(relays, filters) {
+      if (relays.length === 0) {
+        return [];
+      }
+      const seen = /* @__PURE__ */ new Map();
+      const batches = await Promise.allSettled(
+        filters.flatMap((filter) => relays.map((relay) => queryRelay(relay, filter)))
+      );
+      for (const batch of batches) {
+        if (batch.status !== "fulfilled") {
+          continue;
+        }
+        for (const event of batch.value) {
+          if (!seen.has(event.id) && isGenuineEvent(event)) {
+            seen.set(event.id, event);
+          }
+        }
+      }
+      return [...seen.values()];
+    },
+    async publish(relays, event) {
+      const byConnection = /* @__PURE__ */ new Map();
+      const unusable = [];
+      for (const relay of relays) {
+        let connection;
+        try {
+          connection = normalizeURL(relay);
+        } catch {
+          unusable.push(relay);
+          continue;
+        }
+        if (!byConnection.has(connection)) {
+          byConnection.set(connection, relay);
+        }
+      }
+      const targets = [...byConnection.values()];
+      const results = await Promise.allSettled(
+        targets.map((relay) => publishWithDeadline(relay, event))
+      );
+      const outcome = {
+        accepted: [],
+        failed: unusable.map((relay) => ({ relay, reason: "not a relay URL" }))
+      };
+      results.forEach((result, index) => {
+        const relay = targets[index];
+        if (relay === void 0) {
+          return;
+        }
+        if (result.status === "fulfilled") {
+          outcome.accepted.push(relay);
+        } else {
+          outcome.failed.push({ relay, reason: errorText(result.reason) });
+        }
+      });
+      return outcome;
+    },
+    close() {
+      for (const close of [...liveClosers]) {
+        close();
+      }
+      pool.destroy();
+    }
+  };
+}
+
+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 };
+//# sourceMappingURL=buyer.js.map
+//# sourceMappingURL=buyer.js.map