uvd-x402-sdk 2.104.1 → 2.104.2

package/dist/backend/index.js

@@ -4,6 +4,11 @@ var ed25519 = require('@noble/curves/ed25519');
 var sha256 = require('@noble/hashes/sha256');
 var utils = require('@noble/hashes/utils');
 var ethers = require('ethers');
+var aes = require('@noble/ciphers/aes');
+var secp256k1 = require('@noble/curves/secp256k1');
+var hkdf = require('@noble/hashes/hkdf');
+var sha3 = require('@noble/hashes/sha3');
+var sha2 = require('@noble/hashes/sha2');
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -1594,6 +1599,9 @@ var CHAIN_ALIASES = {
   // Renamed in 2.85.0: the facilitator advertises the mainnet as `xrpl`.
   "xrpl-mainnet": "xrpl"
 };
+function getChainById(chainId) {
+  return Object.values(SUPPORTED_CHAINS).find((chain) => chain.chainId === chainId);
+}
 function getChainByName(name) {
   const key = name.toLowerCase();
   return SUPPORTED_CHAINS[key] ?? SUPPORTED_CHAINS[CHAIN_ALIASES[key] ?? ""];
@@ -1936,15 +1944,6 @@ var DEFAULT_MIN_FEE_BPS = 0;
 var DEFAULT_MAX_FEE_BPS = OPERATOR_FEE_BPS + MAX_PROTOCOL_FEE_BPS;
 var REVIEW_WINDOW_SEC = 7 * 24 * 3600;
 var REFUND_WINDOW_SEC = 7 * 24 * 3600;
-Object.freeze(
-  Object.fromEntries(
-    ["arc", "arc-testnet"].map((network) => {
-      const chain = getChainByName(network);
-      if (!chain) throw new Error(`The chain registry has no '${network}'.`);
-      return [chain.chainId, Object.freeze({ name: chain.usdc.name, version: chain.usdc.version })];
-    })
-  )
-);
 var LIFECYCLE_DOMAIN_NAME = "x402 escrow lifecycle";
 var LIFECYCLE_DOMAIN_VERSION = "1";
 var LIFECYCLE_MAX_DEADLINE_SECS = 900;
@@ -2045,7 +2044,7 @@ function toUintString(value, field) {
 }
 function buildLifecycleTypedData(params) {
   const { action, paymentInfo, payer, amount, chainId } = params;
-  const { deadline, nonce } = resolveOrderTiming(params);
+  const { deadline: deadline2, nonce } = resolveOrderTiming(params);
   if (!LIFECYCLE_ACTIONS.includes(action)) {
     throw new X402Error(
       `unknown lifecycle action ${String(action)}; the facilitator only signs ${LIFECYCLE_ACTIONS.join(", ")}`,
@@ -2072,7 +2071,7 @@ function buildLifecycleTypedData(params) {
     message: {
       action,
       amount: amountBig.toString(),
-      deadline: toUintString(deadline, "deadline"),
+      deadline: toUintString(deadline2, "deadline"),
       nonce: nonceToBytes32(nonce),
       paymentInfo: {
         operator: ethers.ethers.getAddress(paymentInfo.operator),
@@ -2286,8 +2285,668 @@ async function facilitatorFetch(url, init, options) {
     await sleep((error.retryAfterSeconds ?? DEFAULT_RETRY_AFTER_SECONDS) * 1e3);
   }
 }
+var EVIDENCE_HEADER = "X-Durable-Evidence";
+var MAGIC = new Uint8Array([68, 88, 52, 48, 50]);
+var FORMAT_V1 = 1;
+var FORMAT_V2 = 2;
+var ROLE_NAMES = ["payer", "seller", "auditor"];
+var NONCE_LEN = 12;
+var CEK_LEN = 32;
+var HKDF_INFO = new TextEncoder().encode("DX402-v1-wrap");
+var DX402Error = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DX402Error";
+  }
+};
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  try {
+    return utils.hexToBytes(clean);
+  } catch (e) {
+    throw new DX402Error(`invalid hex: ${e.message}`);
+  }
+}
+function contentHash(body) {
+  return "0x" + utils.bytesToHex(sha3.keccak_256(body));
+}
+function paymentId(caip2Network, txHash) {
+  const enc = new TextEncoder();
+  const clean = txHash.startsWith("0x") ? txHash.slice(2) : txHash;
+  const preimage = new Uint8Array([...enc.encode(caip2Network), ...enc.encode(clean)]);
+  return "0x" + utils.bytesToHex(sha3.keccak_256(preimage));
+}
+var ANCHOR_DOMAIN_NAME = "DX402 Anchor";
+var ANCHOR_DOMAIN_VERSION = "1";
+var ANCHOR_TYPE = "Dx402AnchorAuthorization(bytes32 paymentId,bytes32 contentHash,string pointer,address payee)";
+var EIP712_DOMAIN_TYPE = "EIP712Domain(string name,string version,uint256 chainId)";
+var ZERO_ADDRESS = "0x" + "00".repeat(20);
+function concatBytes(...parts) {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const p of parts) {
+    out.set(p, pos);
+    pos += p.length;
+  }
+  return out;
+}
+function uint256(n) {
+  const out = new Uint8Array(32);
+  let v = BigInt(n);
+  for (let i = 31; i >= 0 && v > 0n; i--) {
+    out[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return out;
+}
+function anchorDigest(paymentId2, contentHash2, pointer, payee, chainId) {
+  const b32 = (value, field) => {
+    const raw = hexToBytes(value);
+    if (raw.length !== 32) throw new DX402Error(`${field} must be 32 bytes, got ${raw.length}`);
+    return raw;
+  };
+  const addr = hexToBytes(payee);
+  if (addr.length !== 20) {
+    throw new DX402Error(`payee must be a 20-byte address, got ${addr.length}`);
+  }
+  const enc = new TextEncoder();
+  const domainSeparator = sha3.keccak_256(
+    concatBytes(
+      sha3.keccak_256(enc.encode(EIP712_DOMAIN_TYPE)),
+      sha3.keccak_256(enc.encode(ANCHOR_DOMAIN_NAME)),
+      sha3.keccak_256(enc.encode(ANCHOR_DOMAIN_VERSION)),
+      uint256(chainId)
+    )
+  );
+  const structHash = sha3.keccak_256(
+    concatBytes(
+      sha3.keccak_256(enc.encode(ANCHOR_TYPE)),
+      b32(paymentId2, "paymentId"),
+      b32(contentHash2, "contentHash"),
+      sha3.keccak_256(enc.encode(pointer)),
+      new Uint8Array(12),
+      addr
+    )
+  );
+  return sha3.keccak_256(concatBytes(new Uint8Array([25, 1]), domainSeparator, structHash));
+}
+function sealEvidenceTo(body, recipients, paymentIdValue) {
+  if (recipients.length === 0) {
+    throw new DX402Error("an envelope with no recipients could never be opened");
+  }
+  const aad = new TextEncoder().encode(paymentIdValue);
+  const cek = utils.randomBytes(CEK_LEN);
+  const bodyNonce = utils.randomBytes(NONCE_LEN);
+  const ciphertext = aes.gcm(cek, bodyNonce, aad).encrypt(body);
+  const wrapped = recipients.map(({ role, key }) => {
+    let algByte;
+    let ephemeral;
+    let shared;
+    if (key.length === 33) {
+      algByte = 1;
+      const priv = secp256k1.secp256k1.utils.randomPrivateKey();
+      ephemeral = secp256k1.secp256k1.getPublicKey(priv, true);
+      shared = secp256k1.secp256k1.getSharedSecret(priv, key, true).subarray(1);
+    } else if (key.length === 32) {
+      algByte = 2;
+      const priv = utils.randomBytes(32);
+      ephemeral = ed25519.x25519.getPublicKey(priv);
+      shared = ed25519.x25519.getSharedSecret(priv, key);
+      if (shared.every((b) => b === 0)) {
+        throw new DX402Error("degenerate ECDH result (small-order public key)");
+      }
+    } else {
+      throw new DX402Error(
+        `public key must be 33 bytes (secp256k1) or 32 (X25519), got ${key.length}`
+      );
+    }
+    const wrapKey = hkdf.hkdf(sha2.sha256, shared, aad, HKDF_INFO, 32);
+    const cekNonce = utils.randomBytes(NONCE_LEN);
+    return {
+      role,
+      algByte,
+      ephemeral,
+      cekNonce,
+      wrappedCek: aes.gcm(wrapKey, cekNonce, aad).encrypt(cek)
+    };
+  });
+  const singlePayer = wrapped.length === 1 && wrapped[0].role === "payer";
+  const parts = [MAGIC, new Uint8Array([singlePayer ? FORMAT_V1 : FORMAT_V2])];
+  if (!singlePayer) parts.push(new Uint8Array([wrapped.length]));
+  for (const r of wrapped) {
+    if (!singlePayer) parts.push(new Uint8Array([ROLE_NAMES.indexOf(r.role)]));
+    parts.push(new Uint8Array([r.algByte, r.ephemeral.length]));
+    parts.push(r.ephemeral, r.cekNonce);
+    parts.push(new Uint8Array([r.wrappedCek.length >> 8 & 255, r.wrappedCek.length & 255]));
+    parts.push(r.wrappedCek);
+  }
+  parts.push(bodyNonce, ciphertext);
+  return concatBytes(...parts);
+}
+function isEvmAddress(value) {
+  return /^0x[0-9a-fA-F]{40}$/.test((value ?? "").trim());
+}
+function chainIdFor(network) {
+  const raw = network ?? "";
+  if (raw.toLowerCase().startsWith("eip155:")) {
+    const tail = raw.slice("eip155:".length);
+    if (/^\d+$/.test(tail)) return Number(tail);
+  }
+  const name = raw.includes(":") ? raw.split(":")[1] ?? "" : raw;
+  const byId = Number(name);
+  if (Number.isFinite(byId) && byId > 0) return getChainById(byId)?.chainId;
+  return getChainByName(name)?.chainId;
+}
+function sellerDigestFor(paymentId2, contentHash2, payee, network, pointer = "") {
+  if (isEvmAddress(payee)) {
+    const chainId = chainIdFor(network);
+    if (!chainId) return void 0;
+    return anchorDigest(paymentId2, contentHash2, pointer, payee, chainId);
+  }
+  return anchorDigest(paymentId2, contentHash2, pointer, ZERO_ADDRESS, 0);
+}
+var ANCHOR_MAX_REQUEST_BYTES = 64 * 1024;
+function toBase64(bytes) {
+  let out = "";
+  const CHUNK = 32768;
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    out += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(out);
+}
+function backendForPointer(pointer) {
+  if (pointer.startsWith("ipfs://")) return "ipfs";
+  if (pointer.startsWith("ar://")) return "arweave";
+  return "s3";
+}
+async function anchorEvidence(body, opts) {
+  try {
+    const recipients = [
+      { role: "payer", key: opts.payerKey }
+    ];
+    if (opts.sellerEncryptionKey) {
+      recipients.push({ role: "seller", key: opts.sellerEncryptionKey });
+    }
+    const blob = sealEvidenceTo(body, recipients, opts.paymentId);
+    const hash = contentHash(body);
+    let pointer;
+    if (opts.upload) {
+      try {
+        pointer = await opts.upload(blob);
+      } catch {
+        return { v: 1, skipped: "anchor_failed", stage: "upload" };
+      }
+      if (typeof pointer !== "string" || pointer.trim() === "") {
+        return { v: 1, skipped: "anchor_failed", stage: "upload" };
+      }
+      pointer = pointer.trim();
+    }
+    const payload = {
+      paymentId: opts.paymentId,
+      network: opts.network,
+      txHash: opts.txHash,
+      payer: opts.payer,
+      payee: opts.payee,
+      // Exactly one of these. The facilitator dispatches on their presence:
+      // `sealed` -> it hosts and derives the pointer; `pointer` alone -> it uses
+      // yours; neither -> error (x402-rs `dx402/service.rs`).
+      ...pointer !== void 0 ? { pointer } : { sealed: toBase64(blob) },
+      // Declared, not measured. Since x402-rs 2.3.0 the facilitator records
+      // the store that ACTUALLY took the bytes and returns that, so a response
+      // may name a different backend than the request did -- `ipfs` where you
+      // said `s3`, because a deployment whose primary is Pinata wrote there.
+      // That is the facilitator correcting the record, not a mismatch to
+      // assert on.
+      backend: opts.backend ?? (pointer !== void 0 ? backendForPointer(pointer) : "s3"),
+      contentHash: hash,
+      keyAlg: opts.payerKey.length === 32 ? "ECIES-X25519" : "ECIES-secp256k1",
+      mode: "direct",
+      retention: opts.retention ?? "90d"
+    };
+    let unsigned;
+    if (opts.proofOfPayment) {
+      payload.proofOfPayment = opts.proofOfPayment;
+    }
+    if (opts.storage) {
+      payload.storage = opts.storage;
+    }
+    if (opts.sign) {
+      const digest2 = sellerDigestFor(opts.paymentId, hash, opts.payee, opts.network, pointer ?? "");
+      if (digest2 === void 0) {
+        unsigned = "unknown_chain_id";
+      } else {
+        payload.sellerSignature = await opts.sign(digest2);
+      }
+    }
+    const wire = JSON.stringify(payload);
+    if (pointer === void 0 && new TextEncoder().encode(wire).length > ANCHOR_MAX_REQUEST_BYTES) {
+      return { v: 1, skipped: "too_large" };
+    }
+    const base = (opts.facilitator ?? "https://facilitator.ultravioletadao.xyz").replace(
+      /\/+$/,
+      ""
+    );
+    const owner = {};
+    bindStackKey(owner, opts);
+    const res = await stackKeyFetch(owner, `${base}/dx402/anchor`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: wire
+    }, opts.fetch);
+    if (!res.ok) {
+      let error;
+      try {
+        error = (await res.json()).error;
+      } catch {
+      }
+      return { v: 1, skipped: "anchor_failed", status: res.status, error };
+    }
+    const out = await res.json();
+    if (unsigned) out.unsigned = unsigned;
+    return out;
+  } catch (error) {
+    if (error instanceof StackKeyRedirectError) {
+      return { v: 1, skipped: "anchor_failed", status: error.status, error: error.message };
+    }
+    return { v: 1, skipped: "anchor_failed" };
+  }
+}
+function evidenceHeader(evidence) {
+  const bytes = new TextEncoder().encode(JSON.stringify(evidence));
+  return toBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/backend/durable.ts
+var DURABLE_DEFAULT_TIMEOUT_MS = 5e3;
+var MAX_TIMEOUT_MS = 2 ** 31 - 1;
+var skip = (reason) => ({ v: 1, skipped: reason });
+function createDurableAnchorer(durable, paywall) {
+  if (durable === void 0) return void 0;
+  if (durable === null || typeof durable !== "object" || typeof durable.payerKey !== "function") {
+    throw new TypeError("durable.payerKey must be a function");
+  }
+  const maxBodyBytes = durable.maxBodyBytes ?? ANCHOR_MAX_REQUEST_BYTES;
+  if (!Number.isSafeInteger(maxBodyBytes) || maxBodyBytes <= 0) {
+    throw new TypeError("durable.maxBodyBytes must be a positive integer");
+  }
+  const timeoutMs = durable.timeoutMs ?? DURABLE_DEFAULT_TIMEOUT_MS;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMEOUT_MS) {
+    throw new TypeError(`durable.timeoutMs must be an integer from 1 to ${MAX_TIMEOUT_MS}`);
+  }
+  const facilitator = durable.facilitator ?? paywall.facilitator;
+  return {
+    maxBodyBytes,
+    timeoutMs,
+    anchor: async (body, payment, settle, signal) => {
+      try {
+        const txHash = settle.transactionHash;
+        const network = chainToCAIP2(settle.network || payment.requirements.network);
+        let payerKey;
+        try {
+          payerKey = await durable.payerKey({ payment, settle });
+        } catch {
+          return skip("no_payer_key");
+        }
+        if (!(payerKey instanceof Uint8Array) || payerKey.length === 0) return skip("no_payer_key");
+        if (signal.aborted) return skip("timeout");
+        const baseFetch = durable.fetch ?? fetch;
+        const boundFetch = (input, init) => {
+          if (signal.aborted) return Promise.reject(new Error("durable evidence deadline passed"));
+          return baseFetch(input, { ...init, signal });
+        };
+        return await anchorEvidence(body, {
+          paymentId: paymentId(network, txHash),
+          network,
+          txHash,
+          payer: settle.payer || payment.verifyResult.payer || "",
+          payee: payment.requirements.payTo,
+          payerKey,
+          sellerEncryptionKey: durable.sellerEncryptionKey,
+          proofOfPayment: settle.proofOfPayment,
+          sign: durable.sign,
+          upload: durable.upload,
+          backend: durable.backend,
+          retention: durable.retention,
+          storage: durable.storage,
+          facilitator,
+          stackKey: paywall.stackKey,
+          stackKeyHosts: paywall.stackKeyHosts,
+          fetch: boundFetch
+        });
+      } catch {
+        return skip("anchor_failed");
+      }
+    }
+  };
+}
+var UNCONFIRMED_RECEIPT = /* @__PURE__ */ new Set(["pending", "unknown", "rejected"]);
+function settledForEvidence(settle) {
+  return settle?.success === true && settle.replayed !== true && typeof settle.transactionHash === "string" && settle.transactionHash !== "" && !UNCONFIRMED_RECEIPT.has(String(settle.receipt?.status ?? ""));
+}
+function deadline(ms) {
+  const controller = new AbortController();
+  let release = () => {
+  };
+  const expired = new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      controller.abort();
+      resolve();
+    }, ms);
+    release = () => clearTimeout(timer);
+  });
+  return { signal: controller.signal, expired, clear: release };
+}
+async function anchorWithin(anchorer, body, payment, settle, clock) {
+  if (clock.signal.aborted) return skip("timeout");
+  return Promise.race([
+    anchorer.anchor(body, payment, settle, clock.signal),
+    clock.expired.then(() => skip("timeout"))
+  ]);
+}
+function concat(chunks, size) {
+  const out = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+function isEventStream(contentType) {
+  return (contentType ?? "").split(";")[0].trim().toLowerCase() === "text/event-stream";
+}
+function wantsEvidence(run, status, hasHeader) {
+  if (!settledForEvidence(run.settled)) return false;
+  if (status < 200 || status > 299) return false;
+  if ((run.method ?? "").toUpperCase() === "HEAD") return false;
+  return !hasHeader;
+}
+function rebuilt(response, body, evidence) {
+  const headers = new Headers(response.headers);
+  headers.set(EVIDENCE_HEADER, evidenceHeader(evidence));
+  return new Response(body, { status: response.status, statusText: response.statusText, headers });
+}
+function resumed(chunks, reader, pending) {
+  let next = pending;
+  return new ReadableStream({
+    async pull(controller) {
+      const head = chunks.shift();
+      if (head) {
+        controller.enqueue(head);
+        return;
+      }
+      const read = next ?? reader.read();
+      next = void 0;
+      try {
+        const { done, value } = await read;
+        if (done) controller.close();
+        else controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+async function withDurableEvidence(response, run) {
+  if (!wantsEvidence(run, response.status, response.headers.has(EVIDENCE_HEADER))) return response;
+  const { anchorer } = run;
+  const body = response.body;
+  if (body === null || response.bodyUsed || body.locked || isEventStream(response.headers.get("content-type"))) {
+    return response.bodyUsed || body?.locked ? response : rebuilt(response, body, skip("not_capturable"));
+  }
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > anchorer.maxBodyBytes) {
+    return rebuilt(response, body, skip("too_large"));
+  }
+  const clock = deadline(anchorer.timeoutMs);
+  const reader = body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const read = reader.read();
+      const step = await Promise.race([read, clock.expired.then(() => "timeout")]);
+      if (step === "timeout") {
+        return rebuilt(response, resumed(chunks, reader, read), skip("timeout"));
+      }
+      if (step.done) break;
+      const chunk = step.value instanceof Uint8Array ? step.value : new Uint8Array(step.value);
+      chunks.push(chunk);
+      size += chunk.length;
+      if (size > anchorer.maxBodyBytes) {
+        clock.clear();
+        return rebuilt(response, resumed(chunks, reader, void 0), skip("too_large"));
+      }
+    }
+  } catch (error) {
+    const failed = new ReadableStream({
+      pull(controller) {
+        const head = chunks.shift();
+        if (head) controller.enqueue(head);
+        else controller.error(error);
+      }
+    });
+    clock.clear();
+    return rebuilt(response, failed, skip("not_capturable"));
+  }
+  const bytes = concat(chunks, size);
+  try {
+    const evidence = await anchorWithin(anchorer, bytes, run.payment, run.settled, clock);
+    return rebuilt(response, bytes, evidence);
+  } finally {
+    clock.clear();
+  }
+}
+function isDurableNodeResponse(res) {
+  const r = res;
+  return !!r && typeof r.write === "function" && typeof r.end === "function" && typeof r.setHeader === "function" && typeof r.getHeader === "function";
+}
+var headersSentError = () => Object.assign(new Error("Cannot set headers after they are sent to the client"), { code: "ERR_HTTP_HEADERS_SENT" });
+function sealEnded(res) {
+  const target = res;
+  const refuse = { value: () => {
+    throw headersSentError();
+  } };
+  const overrides = {
+    headersSent: { get: () => true },
+    writableEnded: { get: () => true },
+    setHeader: refuse,
+    removeHeader: refuse,
+    writeHead: refuse
+  };
+  const saved = [];
+  for (const [key, descriptor] of Object.entries(overrides)) {
+    const own = Object.getOwnPropertyDescriptor(target, key);
+    try {
+      Object.defineProperty(target, key, { ...descriptor, configurable: true });
+      saved.push([key, own]);
+    } catch {
+    }
+  }
+  let close;
+  const socket = res.socket;
+  const writable = () => !socket || socket.destroyed !== true && socket.writable !== false;
+  const destroySocket = socket && typeof socket.destroy === "function" ? socket.destroy : void 0;
+  const closers = [];
+  for (const holder of [target, socket]) {
+    if (!holder || typeof holder.destroy !== "function") continue;
+    const original = holder.destroy;
+    const own = Object.getOwnPropertyDescriptor(holder, "destroy");
+    try {
+      Object.defineProperty(holder, "destroy", {
+        configurable: true,
+        writable: true,
+        value: (...args) => {
+          if (args[0] !== void 0 && args[0] !== null || !writable()) return original.apply(holder, args);
+          if (!close) {
+            let ran = false;
+            close = () => {
+              if (ran) return;
+              ran = true;
+              if (destroySocket) destroySocket.call(socket);
+              else original.call(holder);
+            };
+          }
+          return holder;
+        }
+      });
+      closers.push([holder, own]);
+    } catch {
+    }
+  }
+  return {
+    restore: () => {
+      for (const [key, own] of saved) {
+        if (own) Object.defineProperty(target, key, own);
+        else delete target[key];
+      }
+      for (const [holder, own] of closers) {
+        if (own) Object.defineProperty(holder, "destroy", own);
+        else delete holder.destroy;
+      }
+    },
+    close: () => close,
+    writable
+  };
+}
+function toBytes(chunk, encoding) {
+  if (chunk === void 0 || chunk === null) return new Uint8Array();
+  if (typeof chunk === "string") {
+    return Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
+  }
+  if (chunk instanceof Uint8Array) return chunk;
+  return void 0;
+}
+function captureNodeResponse(res, anchorer, payment, settled, method) {
+  const write = res.write.bind(res);
+  const end = res.end.bind(res);
+  let state = "capturing";
+  const lateEnds = [];
+  const chunks = [];
+  let size = 0;
+  let clock;
+  const run = () => ({ anchorer, payment, settled: settled(), method });
+  const eligible = () => !res.headersSent && wantsEvidence(run(), res.statusCode ?? 200, res.getHeader(EVIDENCE_HEADER) !== void 0);
+  const note = (reason) => {
+    try {
+      if (eligible()) res.setHeader(EVIDENCE_HEADER, evidenceHeader(skip(reason)));
+    } catch {
+    }
+  };
+  const passThrough = (reason) => {
+    if (state !== "capturing") return;
+    state = "passing";
+    clock?.clear();
+    note(reason);
+    if (size > 0) write(concat(chunks, size));
+    chunks.length = 0;
+  };
+  const callbackOf = (args) => {
+    const last = args[args.length - 1];
+    return typeof last === "function" ? last : void 0;
+  };
+  const hold = (chunk, encoding) => {
+    if (res.headersSent) {
+      passThrough("not_capturable");
+      return false;
+    }
+    if (isEventStream(String(res.getHeader("content-type") ?? ""))) {
+      passThrough("not_capturable");
+      return false;
+    }
+    const bytes = toBytes(chunk, encoding);
+    if (bytes === void 0) {
+      passThrough("not_capturable");
+      return false;
+    }
+    if (size + bytes.length > anchorer.maxBodyBytes) {
+      passThrough("too_large");
+      return false;
+    }
+    if (!clock) {
+      clock = deadline(anchorer.timeoutMs);
+      void clock.expired.then(() => passThrough("timeout"));
+    }
+    if (bytes.length > 0) {
+      chunks.push(bytes);
+      size += bytes.length;
+    }
+    return true;
+  };
+  res.write = (...args) => {
+    if (state === "ending") {
+      const cb = callbackOf(args.slice(1));
+      const error = Object.assign(new Error("write after end"), { code: "ERR_STREAM_WRITE_AFTER_END" });
+      if (cb) queueMicrotask(() => cb(error));
+      return false;
+    }
+    if (state === "capturing" && hold(args[0], typeof args[1] === "function" ? void 0 : args[1])) {
+      const cb = callbackOf(args.slice(1));
+      if (cb) queueMicrotask(() => cb());
+      return true;
+    }
+    return write(...args);
+  };
+  res.end = (...args) => {
+    if (state === "ending") {
+      const cb2 = callbackOf(args);
+      if (cb2) lateEnds.push(cb2);
+      return res;
+    }
+    if (state !== "capturing") return end(...args);
+    const chunk = typeof args[0] === "function" ? void 0 : args[0];
+    const encoding = typeof args[1] === "function" ? void 0 : args[1];
+    const cb = callbackOf(args);
+    if (!hold(chunk, encoding)) return end(...args);
+    const bytes = concat(chunks, size);
+    chunks.length = 0;
+    if (!eligible()) {
+      state = "done";
+      clock?.clear();
+      return cb ? end(bytes, cb) : end(bytes);
+    }
+    state = "ending";
+    const statusCode = res.statusCode;
+    const sealed = sealEnded(res);
+    const finish = (evidence) => {
+      clock?.clear();
+      sealed.restore();
+      if (statusCode !== void 0) res.statusCode = statusCode;
+      try {
+        if (!res.headersSent) res.setHeader(EVIDENCE_HEADER, evidenceHeader(evidence));
+      } catch {
+      }
+      state = "done";
+      const close = sealed.close();
+      const done = close ? (error) => {
+        if (cb) cb(error);
+        close();
+      } : cb;
+      const ended = done ? end(bytes, done) : end(bytes);
+      for (const late of lateEnds.splice(0)) end(late);
+      if (close && !sealed.writable()) close();
+      return ended;
+    };
+    const current = run();
+    const timer = clock ?? deadline(anchorer.timeoutMs);
+    clock = timer;
+    anchorWithin(anchorer, bytes, payment, current.settled, timer).then(finish, () => finish(skip("anchor_failed")));
+    return res;
+  };
+}
 
 // src/backend/index.ts
+function durableAnchorerFor(options) {
+  return createDurableAnchorer(options.durable, {
+    facilitator: options.facilitatorUrl || options.baseUrl || "https://facilitator.ultravioletadao.xyz",
+    stackKey: options.stackKey,
+    stackKeyHosts: options.stackKeyHosts
+  });
+}
 function parsePaymentHeader(headerValue) {
   if (!headerValue) {
     return null;
@@ -3290,6 +3949,7 @@ function createPaymentMiddleware(getRequirements, options = {}) {
     stackKeyHosts: options.stackKeyHosts
   });
   const settlementStrategy = options.settlementStrategy || "before-handler";
+  const anchorer = durableAnchorerFor(options);
   return async (req, res, next) => {
     const payment = extractPaymentFromHeaders(req.headers);
     if (!payment) {
@@ -3332,13 +3992,17 @@ function createPaymentMiddleware(getRequirements, options = {}) {
       });
       return;
     }
+    let settled;
     req.x402 = createVerifiedPaymentState(
       client,
       payment,
       requirements,
       verifyResult,
       binding,
-      (result) => setExpressPaymentHeaders(res, result)
+      (result) => {
+        settled = result;
+        setExpressPaymentHeaders(res, result);
+      }
     );
     if (settlementStrategy === "before-handler") {
       const settleResult = await req.x402.settle();
@@ -3356,6 +4020,9 @@ function createPaymentMiddleware(getRequirements, options = {}) {
         return;
       }
     }
+    if (anchorer && isDurableNodeResponse(res) && (req.method ?? "").toUpperCase() !== "HEAD") {
+      captureNodeResponse(res, anchorer, req.x402, () => settled, req.method);
+    }
     next();
   };
 }
@@ -3382,7 +4049,8 @@ function setHonoPaymentHeaders(c, result) {
     c.header(name, value);
   }
 }
-function createAcceptsPaymentGate(options) {
+function createAcceptsPaymentGate(input) {
+  const options = input.discoverable === void 0 ? input : { ...input, accepts: discoverableAccepts(input.accepts, input.discoverable) };
   const client = new FacilitatorClient({
     baseUrl: options.facilitatorUrl || options.baseUrl,
     timeout: options.timeout,
@@ -3462,7 +4130,10 @@ function createAcceptsPaymentGate(options) {
       requirement,
       verifyResult,
       binding,
-      hooks.onResult
+      (result) => {
+        hooks.onSettled?.(result);
+        hooks.onResult(result);
+      }
     );
     hooks.onVerified?.(verifiedPayment);
     if (settlementStrategy === "before-handler") {
@@ -3479,15 +4150,68 @@ function createAcceptsPaymentGate(options) {
     return { payment: verifiedPayment };
   };
 }
+function isLiteralObject(value) {
+  if (!isObject(value) || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function withDiscoverable(accept, discoverable = true) {
+  if (typeof discoverable !== "boolean") {
+    throw new Error(`discoverable must be true or false, got ${describeValue(discoverable)}`);
+  }
+  if (!isLiteralObject(accept)) {
+    throw new Error(`discoverable: an accept must be an object, got ${describeValue(accept)}`);
+  }
+  if (typeof accept.network !== "string") {
+    throw new Error(`discoverable: the accept has no network, got ${describeValue(accept.network)}`);
+  }
+  if (isNativeHedera(accept.network)) {
+    throw new Error(`discoverable: a native Hedera accept (${accept.network}) carries only feePayer in extra`);
+  }
+  if (accept.extra !== void 0 && !isLiteralObject(accept.extra)) {
+    throw new Error(`discoverable: extra must be a plain object to carry discoverable, got ${describeValue(accept.extra)}`);
+  }
+  return { ...accept, extra: { ...accept.extra ?? {}, discoverable } };
+}
+function describeValue(value) {
+  if (Array.isArray(value)) return "an array";
+  if (value === null) return "null";
+  if (typeof value === "object") return isLiteralObject(value) ? "an object" : "an object that is not plain";
+  if (typeof value === "string") return JSON.stringify(value);
+  return `${typeof value} ${String(value)}`;
+}
+function isNativeHedera(network) {
+  return getChainByName(parseNetworkIdentifier(network))?.networkType === "hedera";
+}
+function discoverableAccepts(accepts, discoverable) {
+  if (typeof discoverable !== "boolean") {
+    throw new Error(`discoverable must be true or false, got ${describeValue(discoverable)}`);
+  }
+  if (!Array.isArray(accepts)) return accepts;
+  return accepts.map((accept) => isLiteralObject(accept) && typeof accept.network === "string" && isNativeHedera(accept.network) ? accept : withDiscoverable(accept, discoverable));
+}
 function createHonoMiddleware(options) {
   const gate = createAcceptsPaymentGate(options);
+  const anchorer = durableAnchorerFor(options);
   return async (c, next) => {
+    let settled;
     const outcome = await gate(c.req, {
       onResult: (result) => setHonoPaymentHeaders(c, result),
-      onVerified: (payment) => c.set?.("x402", payment)
+      onVerified: (payment) => c.set?.("x402", payment),
+      onSettled: (result) => {
+        settled = result;
+      }
     });
     if ("reply" in outcome) return respondHono(c, outcome.reply);
     await next();
+    if (anchorer && c.res instanceof Response) {
+      c.res = await withDurableEvidence(c.res, {
+        anchorer,
+        payment: outcome.payment,
+        settled,
+        method: c.req.method || c.req.raw?.method
+      });
+    }
   };
 }
 function isRequestLike(value) {
@@ -3512,9 +4236,11 @@ function withPaymentHeaders(response, result) {
 }
 function createFetchPaywall(options) {
   const gate = createAcceptsPaymentGate(options);
+  const anchorer = durableAnchorerFor(options);
   return (handler) => async (input, ...rest) => {
     const request = requestOf(input);
     let receipted;
+    let settled;
     const outcome = await gate(
       { header: (name) => request.headers.get(name) ?? void 0, url: request.url, method: request.method, raw: request },
       {
@@ -3522,19 +4248,23 @@ function createFetchPaywall(options) {
           if (!result.receipt) return;
           paymentResponseHeaders(propagatedResult(result));
           receipted = result;
+        },
+        onSettled: (result) => {
+          settled = result;
         }
       }
     );
     if ("reply" in outcome) {
       const { status, headers, body } = outcome.reply;
-      const response = new Response(JSON.stringify(body), {
+      const response2 = new Response(JSON.stringify(body), {
         status,
         headers: { "Content-Type": "application/json", ...headers }
       });
-      return withPaymentHeaders(response, receipted);
+      return withPaymentHeaders(response2, receipted);
     }
+    let response;
     try {
-      return withPaymentHeaders(await handler(input, outcome.payment, ...rest), receipted);
+      response = withPaymentHeaders(await handler(input, outcome.payment, ...rest), receipted);
     } catch (error) {
       if (!receipted) throw error;
       if (error instanceof Response) throw withPaymentHeaders(error, receipted);
@@ -3545,6 +4275,8 @@ function createFetchPaywall(options) {
         headers: { "Content-Type": "text/plain; charset=UTF-8" }
       }), receipted);
     }
+    if (!anchorer) return response;
+    return withDurableEvidence(response, { anchorer, payment: outcome.payment, settled, method: request.method });
   };
 }
 var MAX_SEARCH_LEN = 128;
@@ -5615,13 +6347,13 @@ var Erc8004Client = class {
   async waitForRegistration(jobId, options) {
     const pollIntervalMs = options?.pollIntervalMs ?? 2e3;
     const timeoutMs = options?.timeoutMs ?? 3e5;
-    const deadline = Date.now() + timeoutMs;
+    const deadline2 = Date.now() + timeoutMs;
     for (; ; ) {
       const job = await this.getRegisterStatus(jobId);
       if (isRegisterJobTerminal(job)) {
         return job;
       }
-      if (Date.now() >= deadline) {
+      if (Date.now() >= deadline2) {
         throw new RegistrationPendingError(jobId, job.status, timeoutMs);
       }
       await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
@@ -5722,7 +6454,7 @@ function buildErc8004PaymentRequirements(options) {
   };
 }
 var PAYMENT_INFO_TYPEHASH = "0xae68ac7ce30c86ece8196b61a7c486d8f0061f575037fbd34e7fe4e2820c6591";
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var DEPOSIT_LIMIT_USDC = "100000000";
 var ESCROW_TIMEOUT_MS = {
   1: 96e4,
@@ -6003,7 +6735,7 @@ var AdvancedEscrowClient = class {
         PAYMENT_INFO_TYPEHASH,
         [
           paymentInfo.operator,
-          ZERO_ADDRESS,
+          ZERO_ADDRESS2,
           // payer = 0 for payer-agnostic hash
           paymentInfo.receiver,
           paymentInfo.token,
@@ -6664,7 +7396,7 @@ var AdvancedEscrowClient = class {
         return await this.sendV3OperatorCall(ethers5, this.v3Provider(ethers5), "refund", [
           tuple,
           amt,
-          tokenCollector || ZERO_ADDRESS,
+          tokenCollector || ZERO_ADDRESS2,
           collectorData || "0x"
         ]);
       }
@@ -6673,7 +7405,7 @@ var AdvancedEscrowClient = class {
           return iface.encodeFunctionData("refundPostEscrow", [
             tuple,
             amt,
-            tokenCollector || ZERO_ADDRESS,
+            tokenCollector || ZERO_ADDRESS2,
             collectorData || "0x"
           ]);
         });
@@ -6682,7 +7414,7 @@ var AdvancedEscrowClient = class {
       const tx = await contract.refundPostEscrow(
         tuple,
         amt,
-        tokenCollector || ZERO_ADDRESS,
+        tokenCollector || ZERO_ADDRESS2,
         collectorData || "0x",
         { gasLimit: this.gasLimit }
       );
@@ -6837,6 +7569,7 @@ exports.DEFAULT_FACILITATOR_RETRIES = DEFAULT_FACILITATOR_RETRIES;
 exports.DEFAULT_MAX_SEARCH_LEN = DEFAULT_MAX_SEARCH_LEN;
 exports.DEFAULT_RETRY_AFTER_SECONDS = DEFAULT_RETRY_AFTER_SECONDS;
 exports.DEPOSIT_LIMIT_USDC = DEPOSIT_LIMIT_USDC;
+exports.DURABLE_DEFAULT_TIMEOUT_MS = DURABLE_DEFAULT_TIMEOUT_MS;
 exports.ERC8004_CONTRACTS = ERC8004_CONTRACTS;
 exports.ERC8004_EXTENSION_ID = ERC8004_EXTENSION_ID;
 exports.ESCROW_CONTRACTS = ESCROW_CONTRACTS;
@@ -6876,7 +7609,7 @@ exports.USDC_DOMAIN_NAME = USDC_DOMAIN_NAME;
 exports.WRITER_LEASE_REASONS = WRITER_LEASE_REASONS;
 exports.X402_CORS_HEADERS = X402_CORS_HEADERS;
 exports.X402_HEADER_NAMES = X402_HEADER_NAMES;
-exports.ZERO_ADDRESS = ZERO_ADDRESS;
+exports.ZERO_ADDRESS = ZERO_ADDRESS2;
 exports.bazaarExtension = bazaarExtension;
 exports.buildErc8004PaymentRequirements = buildErc8004PaymentRequirements;
 exports.buildPaymentConflictResponse = buildPaymentConflictResponse;
@@ -6937,5 +7670,6 @@ exports.toResourceInfoV2 = toResourceInfoV2;
 exports.validatePurchaseContext = validatePurchaseContext;
 exports.verifyFacilitatorReceipt = verifyFacilitatorReceipt;
 exports.wireNetwork = wireNetwork;
+exports.withDiscoverable = withDiscoverable;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map