@tollstile/mpp 0.1.0

package/dist/index.js

@@ -0,0 +1,1455 @@
+// src/stripe-rail.ts
+import {
+  TollstileError as TollstileError4,
+  toAssetUnits
+} from "tollstile";
+
+// src/challenge.ts
+import { TollstileError as TollstileError2 } from "tollstile";
+
+// src/encoding.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8", { fatal: true });
+function utf8(input) {
+  return encoder.encode(input);
+}
+function fromUtf8(bytes) {
+  try {
+    return decoder.decode(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function base64url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64url(input) {
+  if (!/^[A-Za-z0-9_-]*$/.test(input) || input.length % 4 === 1) return void 0;
+  const padded = input.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(input.length / 4) * 4, "=");
+  return Uint8Array.from(atob(padded), (character) => character.charCodeAt(0));
+}
+function toHex(bytes) {
+  return `0x${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function fromHex(input) {
+  if (!/^0x([0-9a-fA-F]{2})*$/.test(input)) return void 0;
+  const bytes = new Uint8Array((input.length - 2) / 2);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(input.slice(2 + index * 2, 4 + index * 2), 16);
+  }
+  return bytes;
+}
+function concat(...parts) {
+  const result = new Uint8Array(parts.reduce((length, part) => length + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}
+function toBigInt(bytes) {
+  let value = 0n;
+  for (const byte of bytes) value = value << 8n | BigInt(byte);
+  return value;
+}
+function fromBigInt(value, size) {
+  const bytes = new Uint8Array(size);
+  let rest = value;
+  for (let index = size - 1; index >= 0; index -= 1) {
+    bytes[index] = Number(rest & 0xffn);
+    rest >>= 8n;
+  }
+  return bytes;
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let difference = 0;
+  for (let index = 0; index < a.length; index += 1) difference |= (a[index] ?? 0) ^ (b[index] ?? 0);
+  return difference === 0;
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIntegerString(value) {
+  return typeof value === "string" && /^(0|[1-9]\d*)$/.test(value);
+}
+
+// src/jcs.ts
+import { TollstileError } from "tollstile";
+function canonicalize(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TollstileError("UNREACHABLE", "JCS cannot represent a non-finite number.");
+    return JSON.stringify(value);
+  }
+  if (isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalize(value[key] ?? null)}`).join(",")}}`;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+
+// src/challenge.ts
+var QUOTE_OPAQUE_KEY = "tollstile_quote";
+var MIN_SECRET_LENGTH = 32;
+function challengeSecrets(secret, rail) {
+  const secrets = typeof secret === "string" ? [secret] : secret;
+  const [first, ...rest] = secrets;
+  if (first === void 0 || secrets.some((value) => value.length < MIN_SECRET_LENGTH)) {
+    throw new TollstileError2(
+      "CONFIG_INVALID",
+      `Rail "${rail}" needs \`secret\` of at least ${String(MIN_SECRET_LENGTH)} characters to bind MPP challenge ids. Pass a list to rotate: the first signs, all verify.`
+    );
+  }
+  return [first, ...rest];
+}
+async function issueChallenge(secrets, input) {
+  const id = await computeChallengeId(secrets[0], bindingSlots(input));
+  return { id, ...input };
+}
+function bindingSlots(input) {
+  return {
+    realm: input.realm,
+    method: input.method,
+    intent: input.intent,
+    request: encodeJson(input.request),
+    expires: input.expires,
+    digest: "",
+    opaque: Object.keys(input.opaque).length === 0 ? "" : encodeJson(input.opaque)
+  };
+}
+async function computeChallengeId(secret, slots) {
+  const input = [slots.realm, slots.method, slots.intent, slots.request, slots.expires, slots.digest, slots.opaque].join("|");
+  const key = await crypto.subtle.importKey("raw", utf8(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return base64url(new Uint8Array(await crypto.subtle.sign("HMAC", key, utf8(input))));
+}
+function encodeJson(value) {
+  return base64url(utf8(canonicalize(value)));
+}
+function challengeHeader(challenge) {
+  const slots = bindingSlots(challenge);
+  const parameters = [
+    ["id", challenge.id],
+    ["realm", challenge.realm],
+    ["method", challenge.method],
+    ["intent", challenge.intent],
+    ["request", slots.request],
+    ["expires", challenge.expires]
+  ];
+  if (slots.opaque !== "") parameters.push(["opaque", slots.opaque]);
+  return ["www-authenticate", `Payment ${parameters.map(([name, value]) => `${name}="${quoted(value)}"`).join(", ")}`];
+}
+function mcpChallenge(challenge) {
+  const slots = bindingSlots(challenge);
+  return {
+    id: challenge.id,
+    realm: challenge.realm,
+    method: challenge.method,
+    intent: challenge.intent,
+    request: challenge.request,
+    expires: challenge.expires,
+    ...slots.opaque === "" ? {} : { opaque: slots.opaque }
+  };
+}
+async function quoteChallenge(secrets, input, quote, quoteToken) {
+  const challenge = await issueChallenge(secrets, {
+    ...input,
+    expires: rfc3339(quote.expiresAt),
+    opaque: { [QUOTE_OPAQUE_KEY]: quoteToken }
+  });
+  const native = mcpChallenge(challenge);
+  return { headers: [challengeHeader(challenge)], accepts: native, mcp: { style: "mpp", challenge: native } };
+}
+function asciiRealm(realm) {
+  if (!/^[\x21-\x7e]([\x20-\x7e]*[\x21-\x7e])?$/.test(realm) || realm.includes('"') || realm.includes("\\")) {
+    throw new TollstileError2("CONFIG_INVALID", `MPP realm "${realm}" must be printable ASCII without quotes, e.g. "api.example.com".`);
+  }
+  return realm;
+}
+function rfc3339(date) {
+  return `${date.toISOString().slice(0, 19)}Z`;
+}
+function quoted(value) {
+  if (/[\r\n]/.test(value)) throw new TollstileError2("CONFIG_INVALID", "Challenge parameters cannot contain line breaks.");
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+// src/credential.ts
+var CREDENTIAL_META = "org.paymentauth/credential";
+var HTTP_CREDENTIAL = /^Payment\s+([A-Za-z0-9_-]+)\s*$/i;
+async function readCredential(context, expected) {
+  const raw = rawCredential(context);
+  if (raw === void 0) return { status: "absent" };
+  if (!isObject(raw) || !isObject(raw.challenge)) return invalid("malformed_credential");
+  const { challenge, payload, source } = raw;
+  if (challenge.method !== expected.method || challenge.intent !== expected.intent) return { status: "absent" };
+  if (typeof challenge.id !== "string" || challenge.id === "" || challenge.realm !== expected.realm) {
+    return invalid("challenge_invalid");
+  }
+  if (challenge.digest !== void 0 || challenge.header !== void 0) return invalid("challenge_invalid");
+  if (typeof challenge.expires !== "string") return invalid("challenge_expires_missing");
+  const expires = Date.parse(challenge.expires);
+  if (Number.isNaN(expires)) return invalid("malformed_credential");
+  const request = decodeObject(challenge.request);
+  const opaque = challenge.opaque === void 0 ? {} : decodeObject(challenge.opaque);
+  if (request === void 0 || opaque === void 0 || !isStringMap(opaque)) return invalid("malformed_credential");
+  const issued = {
+    id: challenge.id,
+    realm: expected.realm,
+    method: expected.method,
+    intent: expected.intent,
+    request,
+    expires: challenge.expires,
+    opaque
+  };
+  if (!await isBound(issued, expected.secrets)) return invalid("challenge_invalid");
+  if (expires <= expected.now.getTime()) return { status: "invalid", reason: "challenge_expired", challengeId: issued.id };
+  if (!isObject(payload)) return invalid("invalid_payload");
+  return {
+    status: "present",
+    credential: { challenge: issued, payload, source: typeof source === "string" ? source : null }
+  };
+}
+async function chargeTerms(credential, terms, rail) {
+  const token = credential.challenge.opaque[QUOTE_OPAQUE_KEY];
+  if (token === void 0) {
+    if (terms.price === null) return { status: "invalid", reason: "quote_required" };
+    return { status: "ok", quote: null, price: terms.price, offer: null };
+  }
+  const quote = await terms.openQuote(token);
+  if (quote === void 0) return { status: "invalid", reason: "quote_invalid", challengeId: credential.challenge.id };
+  const offer = quote.offers.find((candidate) => candidate.rail === rail);
+  if (offer === void 0) return { status: "invalid", reason: "quote_offer_missing" };
+  return { status: "ok", quote, price: quote.price, offer };
+}
+function sameRequest(credential, expected) {
+  return canonicalize(credential.challenge.request) === canonicalize(expected);
+}
+function rawCredential(context) {
+  if (context.transport === "mcp") return context.mcp?.meta[CREDENTIAL_META];
+  const header2 = context.request?.headers.get("authorization");
+  if (header2 === null || header2 === void 0) return void 0;
+  if (!/^Payment\s/i.test(header2)) return void 0;
+  const match = HTTP_CREDENTIAL.exec(header2);
+  const bytes = match?.[1] === void 0 ? void 0 : fromBase64url(match[1]);
+  const text = bytes === void 0 ? void 0 : fromUtf8(bytes);
+  return text === void 0 ? null : parseJson(text) ?? null;
+}
+function decodeObject(value) {
+  if (isObject(value)) return value;
+  if (typeof value !== "string") return void 0;
+  const bytes = fromBase64url(value);
+  const text = bytes === void 0 ? void 0 : fromUtf8(bytes);
+  const parsed = text === void 0 ? void 0 : parseJson(text);
+  return isObject(parsed) ? parsed : void 0;
+}
+function isStringMap(value) {
+  return Object.values(value).every((entry) => typeof entry === "string");
+}
+async function isBound(challenge, secrets) {
+  const slots = bindingSlots(challenge);
+  const presented = utf8(challenge.id);
+  let bound = false;
+  for (const secret of secrets) {
+    if (constantTimeEqual(presented, utf8(await computeChallengeId(secret, slots)))) bound = true;
+  }
+  return bound;
+}
+function rejected(result) {
+  return result.challengeId === void 0 ? { status: "invalid", reason: result.reason } : { status: "invalid", reason: result.reason, proofId: result.challengeId };
+}
+function invalid(reason) {
+  return { status: "invalid", reason };
+}
+
+// src/receipt.ts
+var RECEIPT_META = "org.paymentauth/receipt";
+function paymentReceipt(context, fields) {
+  const receipt = {
+    ...fields.extra,
+    status: "success",
+    method: fields.method,
+    timestamp: rfc3339(fields.settledAt),
+    reference: fields.reference,
+    challengeId: fields.challengeId
+  };
+  if (context.transport === "mcp") return { headers: [], meta: { [RECEIPT_META]: receipt } };
+  return {
+    headers: [
+      ["payment-receipt", base64url(utf8(canonicalize(receipt)))],
+      ["cache-control", "private"]
+    ],
+    meta: {}
+  };
+}
+
+// src/stripe-api.ts
+import { TollstileError as TollstileError3 } from "tollstile";
+async function stripeCall(config, call) {
+  const mutation = call.method === "POST";
+  const headers = new Headers({
+    authorization: `Bearer ${config.secretKey}`,
+    "stripe-version": config.apiVersion
+  });
+  if (call.body !== void 0) headers.set("content-type", "application/x-www-form-urlencoded");
+  if (call.idempotencyKey !== void 0) headers.set("idempotency-key", call.idempotencyKey);
+  let response;
+  try {
+    response = await config.fetch(`${config.apiBase}${call.path}`, {
+      method: call.method,
+      headers,
+      ...call.body === void 0 ? {} : { body: call.body },
+      signal: call.signal
+    });
+  } catch (error) {
+    throw failure(mutation, `Stripe ${call.method} ${routeOf(call.path)} did not complete.`, error);
+  }
+  const body = await readJson(response);
+  const code = errorCode(body);
+  if (response.ok) {
+    if (body === void 0) throw failure(mutation, `Stripe ${call.method} ${routeOf(call.path)} returned an unreadable body.`);
+    return { ok: true, body, replayed: response.headers.get("idempotent-replayed") === "true" };
+  }
+  if (response.status >= 500) throw failure(mutation, `Stripe answered ${String(response.status)} for ${routeOf(call.path)}.`);
+  if (response.status === 429 || response.status === 401 || response.status === 403) {
+    throw new TollstileError3("PROVIDER_UNAVAILABLE", `Stripe refused ${routeOf(call.path)} with ${String(response.status)}. Check the API key and rate limits.`);
+  }
+  if (response.status === 409 || code === "idempotency_key_in_use" || errorType(body) === "idempotency_error") {
+    throw new TollstileError3("PROVIDER_TIMEOUT", `Stripe reported an idempotency conflict for ${routeOf(call.path)}.`);
+  }
+  return { ok: false, status: response.status, code: code ?? errorType(body) ?? `http_${String(response.status)}` };
+}
+function parsePaymentIntent(body) {
+  const { id, status, amount, currency } = body;
+  if (typeof id !== "string" || typeof status !== "string" || typeof amount !== "number" || typeof currency !== "string") {
+    return void 0;
+  }
+  return { id, status, amount, currency };
+}
+function parseRefund(body) {
+  const { id, status, charge } = body;
+  if (typeof id !== "string" || typeof status !== "string") return void 0;
+  return { id, status, charge: typeof charge === "string" ? charge : null };
+}
+function listData(body) {
+  const { data } = body;
+  if (!Array.isArray(data)) return void 0;
+  const items = data.filter(isObject);
+  return items.length === data.length ? items : void 0;
+}
+function metadataOf(body) {
+  return isObject(body.metadata) ? body.metadata : {};
+}
+async function readJson(response) {
+  try {
+    const parsed = await response.json();
+    return isObject(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function errorCode(body) {
+  const error = body?.error;
+  if (!isObject(error)) return void 0;
+  if (typeof error.decline_code === "string") return error.decline_code;
+  return typeof error.code === "string" ? error.code : void 0;
+}
+function errorType(body) {
+  const error = body?.error;
+  return isObject(error) && typeof error.type === "string" ? error.type : void 0;
+}
+function routeOf(path) {
+  return path.replace(/\?.*$/, "").replace(/\/(pi|re|ch)_[A-Za-z0-9]+/g, "/:id");
+}
+function failure(mutation, message, cause) {
+  return new TollstileError3(mutation ? "PROVIDER_TIMEOUT" : "PROVIDER_UNAVAILABLE", message, cause === void 0 ? void 0 : { cause });
+}
+
+// src/stripe-rail.ts
+var NAME = "mpp-stripe";
+var METHOD = "stripe";
+var INTENT = "charge";
+var IDEMPOTENCY_PREFIX = "tollstile_mpp_";
+var CURRENCIES = {
+  USD: { scale: 2, minimum: 50n },
+  EUR: { scale: 2, minimum: 50n },
+  GBP: { scale: 2, minimum: 30n },
+  CAD: { scale: 2, minimum: 50n },
+  AUD: { scale: 2, minimum: 50n },
+  NZD: { scale: 2, minimum: 50n },
+  CHF: { scale: 2, minimum: 50n },
+  SGD: { scale: 2, minimum: 50n },
+  HKD: { scale: 2, minimum: 400n },
+  SEK: { scale: 2, minimum: 300n },
+  NOK: { scale: 2, minimum: 300n },
+  DKK: { scale: 2, minimum: 250n },
+  MXN: { scale: 2, minimum: 1000n },
+  JPY: { scale: 0, minimum: 50n }
+};
+var IN_FLIGHT = /* @__PURE__ */ new Set(["processing", "requires_capture"]);
+function mppStripe(options) {
+  const secrets = challengeSecrets(options.secret, NAME);
+  const realm = asciiRealm(options.realm);
+  const clock = options.clock ?? { now: () => /* @__PURE__ */ new Date() };
+  const searchLagMs = options.searchLagMs ?? 10 * 6e4;
+  const sptParameter = options.sptParameter ?? "shared_payment_granted_token";
+  const paymentMethodTypes = options.paymentMethodTypes ?? ["card"];
+  const stripe = {
+    secretKey: options.secretKey,
+    apiBase: options.apiBase ?? "https://api.stripe.com",
+    apiVersion: options.apiVersion ?? "2026-07-29.preview",
+    fetch: options.fetch ?? ((input, init) => fetch(input, init))
+  };
+  if (options.networkId.length === 0) {
+    throw new TollstileError4("CONFIG_INVALID", "mppStripe() needs `networkId`, your Stripe Business Network Profile id.");
+  }
+  const tokens = /* @__PURE__ */ new Map();
+  const request = (amount, currency) => ({
+    amount: amount.toString(),
+    currency: currency.toLowerCase(),
+    methodDetails: { networkId: options.networkId, paymentMethodTypes }
+  });
+  return {
+    name: NAME,
+    livemode: true,
+    capabilities: {
+      flows: ["upfront"],
+      authorization: "single",
+      variableAmount: false,
+      quotes: true,
+      refund: true,
+      partialRefund: true,
+      lookup: true
+    },
+    offer({ price }) {
+      const minor = minorUnits(price);
+      if (minor === void 0) return Promise.resolve(null);
+      return Promise.resolve({
+        rail: NAME,
+        asset: { code: price.currency, network: "stripe", scale: minor.scale },
+        amount: minor.amount.toString(),
+        basis: "par",
+        details: { method: METHOD, intent: INTENT }
+      });
+    },
+    challenge(quote, token, offer) {
+      return quoteChallenge(
+        secrets,
+        { realm, method: METHOD, intent: INTENT, request: request(BigInt(offer.amount), offer.asset.code) },
+        quote,
+        token
+      );
+    },
+    async verify(context, terms) {
+      const now = clock.now();
+      for (const [id, entry] of tokens) if (entry.expiresAt <= now.getTime()) tokens.delete(id);
+      const read = await readCredential(context, { realm, method: METHOD, intent: INTENT, secrets, now });
+      if (read.status === "absent") return read;
+      if (read.status === "invalid") return rejected(read);
+      const { credential } = read;
+      const resolved = await chargeTerms(credential, terms, NAME);
+      if (resolved.status === "invalid") return rejected(resolved);
+      const minor = resolved.offer === null ? minorUnits(resolved.price) : { amount: BigInt(resolved.offer.amount) };
+      if (minor === void 0) return { status: "invalid", reason: "price_not_payable" };
+      if (!sameRequest(credential, request(minor.amount, resolved.price.currency))) {
+        return { status: "invalid", reason: "challenge_terms_mismatch" };
+      }
+      const { spt } = credential.payload;
+      if (typeof spt !== "string" || !/^spt_[A-Za-z0-9_]+$/.test(spt)) return { status: "invalid", reason: "invalid_payload" };
+      const challengeId = credential.challenge.id;
+      tokens.set(context.requestId, { spt, expiresAt: Date.parse(credential.challenge.expires) });
+      return {
+        status: "valid",
+        proofId: challengeId,
+        // An SPT does not identify the payer before it is charged; the challenge is the only stable handle.
+        payer: `stripe:${challengeId}`,
+        quote: resolved.quote,
+        limit: resolved.price,
+        expiresAt: new Date(Date.parse(credential.challenge.expires)),
+        data: { challengeId, amount: minor.amount.toString(), currency: resolved.price.currency.toLowerCase() },
+        // A challenge is issued for one 402 and paid once: every retry of that credential is the same
+        // logical request, the same key Stripe deduplicates the PaymentIntent on.
+        idempotencyKey: challengeId
+      };
+    },
+    async settle(authorization, charge, operation) {
+      const data = stripeData(authorization);
+      const entry = tokens.get(charge.requestId);
+      if (entry === void 0) {
+        throw new TollstileError4(
+          "PROVIDER_UNAVAILABLE",
+          `The shared payment token for ${authorization.id} is not held by this process, so ${charge.id} cannot be settled here. Reconciliation will look it up.`
+        );
+      }
+      const body = new URLSearchParams({
+        amount: data.amount,
+        currency: data.currency,
+        confirm: "true",
+        "automatic_payment_methods[enabled]": "true",
+        "automatic_payment_methods[allow_redirects]": "never",
+        "metadata[challenge_id]": data.challengeId,
+        "metadata[tollstile_authorization]": authorization.id
+      });
+      body.set(sptParameter, entry.spt);
+      const response = await stripeCall(stripe, {
+        method: "POST",
+        path: "/v1/payment_intents",
+        body,
+        // One key per challenge, not per charge: a retry of the same credential after a released
+        // charge must replay the PaymentIntent, never create a second one.
+        idempotencyKey: `${IDEMPOTENCY_PREFIX}${data.challengeId}`,
+        signal: operation.signal
+      });
+      if (!response.ok) return { status: "rejected", reason: response.code };
+      const intent = parsePaymentIntent(response.body);
+      if (intent === void 0) throw new TollstileError4("PROVIDER_TIMEOUT", "Stripe returned a PaymentIntent without id or status.");
+      if (IN_FLIGHT.has(intent.status)) {
+        throw new TollstileError4("PROVIDER_TIMEOUT", `PaymentIntent for ${charge.id} is ${intent.status}; its outcome is not final yet.`);
+      }
+      if (intent.status !== "succeeded") return { status: "rejected", reason: `payment_intent_${intent.status}` };
+      if (String(intent.amount) !== data.amount || intent.currency !== data.currency) {
+        throw new TollstileError4("LEDGER_INCONSISTENT", `PaymentIntent ${intent.id} does not match the amount recorded for ${charge.id}.`);
+      }
+      return settled(intent, response.replayed);
+    },
+    async refund(authorization, charge, operation) {
+      const data = stripeData(authorization);
+      const paymentIntent = charge.settlement?.reference;
+      if (paymentIntent === void 0) {
+        throw new TollstileError4("LEDGER_INCONSISTENT", `Charge ${charge.id} has no PaymentIntent to refund.`);
+      }
+      const response = await stripeCall(stripe, {
+        method: "POST",
+        path: "/v1/refunds",
+        body: new URLSearchParams({
+          payment_intent: paymentIntent,
+          amount: data.amount,
+          "metadata[tollstile_charge]": charge.id,
+          "metadata[challenge_id]": data.challengeId
+        }),
+        idempotencyKey: operation.key,
+        signal: operation.signal
+      });
+      if (!response.ok) return { status: "rejected", reason: response.code };
+      const refund = parseRefund(response.body);
+      if (refund === void 0) throw new TollstileError4("PROVIDER_TIMEOUT", "Stripe returned a refund without id or status.");
+      return refund.status === "succeeded" || refund.status === "pending" ? { status: "refunded", reference: refund.id } : { status: "rejected", reason: `refund_${refund.status}` };
+    },
+    release(_authorization, charge) {
+      tokens.delete(charge.requestId);
+      return Promise.resolve();
+    },
+    async lookup(authorization, charge, operation) {
+      const data = stripeData(authorization);
+      const intent = await findPaymentIntent(stripe, data, charge, operation.signal);
+      if (intent === void 0) {
+        if (clock.now().getTime() - charge.updatedAt.getTime() < searchLagMs) {
+          throw new TollstileError4(
+            "PROVIDER_TIMEOUT",
+            `No PaymentIntent is searchable yet for ${charge.id}; Stripe Search can lag, so the answer waits until ${String(searchLagMs)}ms have passed.`
+          );
+        }
+        return { status: "none" };
+      }
+      if (IN_FLIGHT.has(intent.status)) {
+        throw new TollstileError4("PROVIDER_TIMEOUT", `PaymentIntent for ${charge.id} is still ${intent.status}.`);
+      }
+      if (intent.status !== "succeeded") return { status: "none" };
+      return await findRefund(stripe, intent, charge, operation.signal) ?? settled(intent, false);
+    },
+    receipt(authorization, charge, context) {
+      return paymentReceipt(context, {
+        method: METHOD,
+        reference: charge.settlement?.reference ?? charge.id,
+        settledAt: charge.updatedAt,
+        challengeId: stripeData(authorization).challengeId
+      });
+    }
+  };
+}
+async function findPaymentIntent(stripe, data, charge, signal) {
+  const known = charge.settlement?.reference;
+  if (known !== void 0) {
+    const response2 = await stripeCall(stripe, { method: "GET", path: `/v1/payment_intents/${encodeURIComponent(known)}`, signal });
+    if (!response2.ok) throw new TollstileError4("PROVIDER_UNAVAILABLE", `Stripe could not return the PaymentIntent of ${charge.id} (${response2.code}).`);
+    return readIntent(response2.body);
+  }
+  const query = new URLSearchParams({ query: `metadata['challenge_id']:'${data.challengeId}'`, limit: "10" });
+  const response = await stripeCall(stripe, { method: "GET", path: `/v1/payment_intents/search?${query.toString()}`, signal });
+  if (!response.ok) throw new TollstileError4("PROVIDER_UNAVAILABLE", `Stripe Search failed for ${charge.id} (${response.code}).`);
+  const items = listData(response.body);
+  if (items === void 0) throw new TollstileError4("PROVIDER_UNAVAILABLE", "Stripe Search returned an unexpected shape.");
+  const intents = items.map(readIntent).filter((intent) => metadataMatches(items, intent, data.challengeId));
+  return intents.find((intent) => intent.status === "succeeded") ?? intents[0];
+}
+async function findRefund(stripe, intent, charge, signal) {
+  const query = new URLSearchParams({ payment_intent: intent.id, limit: "100" });
+  const response = await stripeCall(stripe, { method: "GET", path: `/v1/refunds?${query.toString()}`, signal });
+  if (!response.ok) throw new TollstileError4("PROVIDER_UNAVAILABLE", `Stripe could not list refunds for ${charge.id} (${response.code}).`);
+  const items = listData(response.body);
+  if (items === void 0) throw new TollstileError4("PROVIDER_UNAVAILABLE", "Stripe returned an unexpected refund list.");
+  for (const item of items) {
+    const refund = parseRefund(item);
+    if (refund === void 0 || metadataOf(item).tollstile_charge !== charge.id) continue;
+    if (refund.status === "succeeded" || refund.status === "pending") return { status: "refunded", reference: refund.id };
+  }
+  return void 0;
+}
+function readIntent(body) {
+  const intent = parsePaymentIntent(body);
+  if (intent === void 0) throw new TollstileError4("PROVIDER_UNAVAILABLE", "Stripe returned a PaymentIntent without id or status.");
+  return intent;
+}
+function metadataMatches(items, intent, challengeId) {
+  const item = items.find((candidate) => candidate.id === intent.id);
+  return item !== void 0 && metadataOf(item).challenge_id === challengeId;
+}
+function settled(intent, replayed) {
+  return {
+    status: "settled",
+    reference: intent.id,
+    details: { paymentIntent: intent.id, amount: intent.amount, currency: intent.currency, replayed }
+  };
+}
+function minorUnits(price) {
+  const currency = CURRENCIES[price.currency];
+  if (currency === void 0) return void 0;
+  const divisor = 10n ** BigInt(6 - currency.scale);
+  if (price.micros % divisor !== 0n) return void 0;
+  const amount = toAssetUnits(price, currency.scale);
+  return amount < currency.minimum ? void 0 : { amount, scale: currency.scale };
+}
+function stripeData(authorization) {
+  const { data } = authorization;
+  if (!isObject(data) || typeof data.challengeId !== "string" || !isIntegerString(data.amount) || typeof data.currency !== "string") {
+    throw new TollstileError4("LEDGER_INCONSISTENT", `Authorization ${authorization.id} does not hold mpp-stripe data.`);
+  }
+  return { challengeId: data.challengeId, amount: data.amount, currency: data.currency };
+}
+
+// src/tempo-rail.ts
+import {
+  TollstileError as TollstileError6,
+  toAssetUnits as toAssetUnits2
+} from "tollstile";
+
+// src/evm.ts
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+var HALF_ORDER = 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0n;
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function keccak256(bytes) {
+  return keccak_256(bytes);
+}
+function selector(signature) {
+  return toHex(keccak256(utf8(signature)).subarray(0, 4));
+}
+function parseAddress(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]{40}$/.test(value) ? value.toLowerCase() : void 0;
+}
+function parseBytes32(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value) ? value.toLowerCase() : void 0;
+}
+function recoverAddress(digest, signature) {
+  let r;
+  let s;
+  let recovery;
+  if (signature.length === 65) {
+    r = toBigInt(signature.subarray(0, 32));
+    s = toBigInt(signature.subarray(32, 64));
+    const v = signature[64] ?? 0;
+    recovery = v >= 27 ? v - 27 : v;
+  } else if (signature.length === 64) {
+    r = toBigInt(signature.subarray(0, 32));
+    const yParityAndS = toBigInt(signature.subarray(32, 64));
+    recovery = Number(yParityAndS >> 255n);
+    s = yParityAndS & (1n << 255n) - 1n;
+  } else {
+    return void 0;
+  }
+  if (recovery !== 0 && recovery !== 1) return void 0;
+  if (r === 0n || s === 0n || s > HALF_ORDER || r >= secp256k1.Point.CURVE().n) return void 0;
+  try {
+    const point = new secp256k1.Signature(r, s, recovery).recoverPublicKey(digest);
+    return publicKeyAddress(point.toBytes(false));
+  } catch {
+    return void 0;
+  }
+}
+function publicKeyAddress(uncompressed) {
+  return toHex(keccak256(uncompressed.subarray(1)).subarray(12));
+}
+function word(value) {
+  return fromBigInt(value, 32);
+}
+function addressWord(address) {
+  return concat(new Uint8Array(12), fromHex(address) ?? new Uint8Array(20));
+}
+function wordAt(data, index) {
+  const slice = data.subarray(index * 32, index * 32 + 32);
+  return slice.length === 32 ? slice : void 0;
+}
+function addressAt(data, index) {
+  const slice = wordAt(data, index);
+  if (slice === void 0 || slice.subarray(0, 12).some((byte) => byte !== 0)) return void 0;
+  return toHex(slice.subarray(12));
+}
+
+// src/rlp.ts
+function decodeRlp(bytes) {
+  const result = decodeAt(bytes, 0);
+  return result === void 0 || result.end !== bytes.length ? void 0 : result.item;
+}
+function encodeRlp(item) {
+  if (item instanceof Uint8Array) {
+    if (item.length === 1 && (item[0] ?? 0) < 128) return item;
+    return concat(header(128, item.length), item);
+  }
+  const payload = concat(...item.map(encodeRlp));
+  return concat(header(192, payload.length), payload);
+}
+function rlpInteger(item) {
+  if (!(item instanceof Uint8Array) || item.length > 0 && item[0] === 0) return void 0;
+  return toBigInt(item);
+}
+function integerBytes(value) {
+  if (value === 0n) return new Uint8Array();
+  let size = 0;
+  for (let rest = value; rest > 0n; rest >>= 8n) size += 1;
+  return fromBigInt(value, size);
+}
+function header(offset, length) {
+  if (length <= 55) return Uint8Array.of(offset + length);
+  const size = integerBytes(BigInt(length));
+  return concat(Uint8Array.of(offset + 55 + size.length), size);
+}
+function decodeAt(bytes, start) {
+  const prefix = bytes[start];
+  if (prefix === void 0) return void 0;
+  if (prefix < 128) return { item: bytes.subarray(start, start + 1), end: start + 1 };
+  const isList = prefix >= 192;
+  const base = isList ? 192 : 128;
+  const short = prefix - base <= 55;
+  let length;
+  let offset;
+  if (short) {
+    length = prefix - base;
+    offset = start + 1;
+  } else {
+    const sizeOfLength = prefix - base - 55;
+    const encoded = bytes.subarray(start + 1, start + 1 + sizeOfLength);
+    if (encoded.length !== sizeOfLength || encoded[0] === 0) return void 0;
+    length = Number(toBigInt(encoded));
+    if (length <= 55) return void 0;
+    offset = start + 1 + sizeOfLength;
+  }
+  const end = offset + length;
+  if (end > bytes.length) return void 0;
+  if (!isList) {
+    const item = bytes.subarray(offset, end);
+    if (short && length === 1 && (item[0] ?? 0) < 128) return void 0;
+    return { item, end };
+  }
+  const items = [];
+  let cursor = offset;
+  while (cursor < end) {
+    const next = decodeAt(bytes.subarray(0, end), cursor);
+    if (next === void 0) return void 0;
+    items.push(next.item);
+    cursor = next.end;
+  }
+  return { item: items, end };
+}
+
+// src/tempo-transaction.ts
+var TEMPO_TX_TYPE = 118;
+function decodeTempoTransaction(serialized) {
+  const bytes = fromHex(serialized);
+  if (bytes === void 0 || bytes[0] !== TEMPO_TX_TYPE) return fail("transaction_malformed");
+  const fields = decodeRlp(bytes.subarray(1));
+  if (fields instanceof Uint8Array || fields === void 0) return fail("transaction_malformed");
+  if (fields.length !== 14) return fail("transaction_unsupported");
+  const [chainId, , , , calls, , nonceKey, nonce, validBefore, validAfter, , feePayer, authorizationList, signature] = fields;
+  const integers = [chainId, nonceKey, nonce, validBefore, validAfter].map(rlpInteger);
+  const [chain, lane, sequence, before, after] = integers;
+  if (chain === void 0 || lane === void 0 || sequence === void 0 || before === void 0 || after === void 0) {
+    return fail("transaction_malformed");
+  }
+  if (!(feePayer instanceof Uint8Array) || feePayer.length !== 0) return fail("fee_payer_unsupported");
+  if (!Array.isArray(authorizationList) || authorizationList.length !== 0) return fail("transaction_unsupported");
+  if (!(signature instanceof Uint8Array)) return fail("transaction_malformed");
+  const decodedCalls = decodeCalls(calls);
+  if (decodedCalls === void 0) return fail("transaction_malformed");
+  const unsigned = fields.slice(0, 13);
+  const digest = keccak256(concat(Uint8Array.of(TEMPO_TX_TYPE), encodeRlp(unsigned)));
+  const sender = recoverAddress(digest, signature);
+  if (sender === void 0 || signature.length !== 65) return fail("signature_invalid");
+  return {
+    ok: true,
+    transaction: {
+      chainId: chain,
+      calls: decodedCalls,
+      nonceKey: lane,
+      nonce: sequence,
+      validBefore: before === 0n ? null : before,
+      validAfter: after === 0n ? null : after,
+      sender,
+      hash: toHex(keccak256(bytes))
+    }
+  };
+}
+function decodeCalls(item) {
+  if (item === void 0 || item instanceof Uint8Array) return void 0;
+  const calls = [];
+  for (const call of item) {
+    if (call instanceof Uint8Array || call.length !== 3) return void 0;
+    const [to, value, data] = call;
+    const amount = rlpInteger(value);
+    if (!(to instanceof Uint8Array) || to.length !== 20 || amount === void 0 || !(data instanceof Uint8Array)) return void 0;
+    calls.push({ to: toHex(to), value: amount, data });
+  }
+  return calls;
+}
+function fail(reason) {
+  return { ok: false, reason };
+}
+
+// src/tempo-rpc.ts
+import { TollstileError as TollstileError5 } from "tollstile";
+async function rpcCall(config, method, params, options) {
+  const code = options.write ? "PROVIDER_TIMEOUT" : "PROVIDER_UNAVAILABLE";
+  let response;
+  try {
+    response = await config.fetch(config.url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+      signal: options.signal
+    });
+  } catch (error) {
+    throw new TollstileError5(code, `Tempo RPC ${method} did not complete.`, { cause: error });
+  }
+  if (!response.ok) throw new TollstileError5(code, `Tempo RPC answered HTTP ${String(response.status)} to ${method}.`);
+  let body;
+  try {
+    body = await response.json();
+  } catch (error) {
+    throw new TollstileError5(code, `Tempo RPC returned an unreadable body for ${method}.`, { cause: error });
+  }
+  if (!isObject(body)) throw new TollstileError5(code, `Tempo RPC returned an unexpected body for ${method}.`);
+  if (isObject(body.error)) {
+    return {
+      ok: false,
+      code: typeof body.error.code === "number" ? body.error.code : 0,
+      message: typeof body.error.message === "string" ? body.error.message : ""
+    };
+  }
+  if (!("result" in body)) throw new TollstileError5(code, `Tempo RPC returned neither result nor error for ${method}.`);
+  return { ok: true, result: body.result };
+}
+async function getReceipt(config, hash, signal) {
+  const answer = await rpcCall(config, "eth_getTransactionReceipt", [hash], { signal, write: false });
+  if (!answer.ok) throw new TollstileError5("PROVIDER_UNAVAILABLE", `Tempo RPC refused eth_getTransactionReceipt (${String(answer.code)}).`);
+  if (answer.result === null) return null;
+  const receipt = parseReceipt(answer.result);
+  if (receipt === void 0) throw new TollstileError5("PROVIDER_UNAVAILABLE", "Tempo RPC returned a malformed transaction receipt.");
+  return receipt;
+}
+function parseReceipt(value) {
+  if (!isObject(value)) return void 0;
+  const hash = parseBytes32(value.transactionHash);
+  const from = parseAddress(value.from);
+  const { status, blockNumber, logs } = value;
+  if (hash === void 0 || from === void 0 || typeof status !== "string" || typeof blockNumber !== "string" || !Array.isArray(logs)) {
+    return void 0;
+  }
+  const parsed = [];
+  for (const log of logs) {
+    if (!isObject(log)) return void 0;
+    const address = parseAddress(log.address);
+    const topics = Array.isArray(log.topics) ? log.topics.map(parseBytes32) : [];
+    if (address === void 0 || typeof log.data !== "string" || !/^0x([0-9a-fA-F]{2})*$/.test(log.data)) return void 0;
+    if (topics.some((topic) => topic === void 0)) return void 0;
+    parsed.push({ address, topics: topics.filter((topic) => topic !== void 0), data: log.data.toLowerCase() });
+  }
+  return { transactionHash: hash, success: status === "0x1", from, blockNumber, logs: parsed };
+}
+
+// src/tip20.ts
+var TRANSFER = selector("transfer(address,uint256)");
+var TRANSFER_WITH_MEMO = selector("transferWithMemo(address,uint256,bytes32)");
+var TRANSFER_EVENT = toHex(keccak256(utf8("Transfer(address,address,uint256)")));
+var TRANSFER_WITH_MEMO_EVENT = toHex(keccak256(utf8("TransferWithMemo(address,address,uint256,bytes32)")));
+function challengeMemo(realm, quote) {
+  return toHex(keccak256(utf8(`tollstile/mpp:${realm}:${quote.id}:${quote.nonce}`)));
+}
+function requiredTransfers(amount, recipient, memo, splits) {
+  const splitTotal = splits.reduce((total, split) => total + split.amount, 0n);
+  return [{ recipient, amount: amount - splitTotal, memo }, ...splits];
+}
+function requestTransfersJson(splits) {
+  return splits.map((split) => ({
+    amount: split.amount.toString(),
+    recipient: split.recipient,
+    ...split.memo === null ? {} : { memo: split.memo }
+  }));
+}
+function callsPay(calls, token, transfers) {
+  if (calls.length !== transfers.length) return false;
+  const remaining = [...transfers];
+  for (const call of calls) {
+    const decoded = decodeCall(call, token);
+    const index = decoded === void 0 ? -1 : remaining.findIndex((transfer) => sameTransfer(transfer, decoded));
+    if (index === -1) return false;
+    remaining.splice(index, 1);
+  }
+  return remaining.length === 0;
+}
+function logsPay(logs, token, transfers) {
+  const events = transferEvents(logs, token);
+  let sender;
+  for (const transfer of transfers) {
+    const index = events.findIndex((event2) => (sender === void 0 || event2.from === sender) && sameTransfer(transfer, event2));
+    const event = events[index];
+    if (event === void 0) return void 0;
+    sender = event.from;
+    events.splice(index, 1);
+  }
+  return sender;
+}
+function sameTransfer(expected, actual) {
+  if (expected.recipient !== actual.recipient || expected.amount !== actual.amount) return false;
+  return expected.memo === null || expected.memo === actual.memo;
+}
+function decodeCall(call, token) {
+  if (call.to !== token || call.value !== 0n) return void 0;
+  const method = toHex(call.data.subarray(0, 4));
+  const args = call.data.subarray(4);
+  if (method === TRANSFER && args.length === 64) return decodeArgs(args, null);
+  if (method === TRANSFER_WITH_MEMO && args.length === 96) {
+    const memo = wordAt(args, 2);
+    return memo === void 0 ? void 0 : decodeArgs(args, toHex(memo));
+  }
+  return void 0;
+}
+function decodeArgs(args, memo) {
+  const recipient = addressAt(args, 0);
+  const amount = wordAt(args, 1);
+  return recipient === void 0 || amount === void 0 ? void 0 : { recipient, amount: toBigInt(amount), memo };
+}
+function transferEvents(logs, token) {
+  const events = [];
+  for (const log of logs) {
+    if (log.address !== token) continue;
+    const [topic, from, to, memo] = log.topics;
+    const data = fromHex(log.data);
+    const amount = data === void 0 ? void 0 : wordAt(data, 0);
+    const sender = from === void 0 ? void 0 : addressAt(fromHex(from) ?? new Uint8Array(), 0);
+    const recipient = to === void 0 ? void 0 : addressAt(fromHex(to) ?? new Uint8Array(), 0);
+    if (amount === void 0 || sender === void 0 || recipient === void 0) continue;
+    if (topic === TRANSFER_EVENT && log.topics.length === 3) {
+      events.push({ kind: "plain", from: sender, recipient, amount: toBigInt(amount), memo: null });
+    } else if (topic === TRANSFER_WITH_MEMO_EVENT && memo !== void 0) {
+      events.push({ kind: "memo", from: sender, recipient, amount: toBigInt(amount), memo });
+    }
+  }
+  const memoEvents = events.filter((event) => event.kind === "memo");
+  const plain = events.filter((event) => event.kind === "plain");
+  for (const memoEvent of memoEvents) {
+    const twin = plain.findIndex((event) => event.from === memoEvent.from && event.recipient === memoEvent.recipient && event.amount === memoEvent.amount);
+    if (twin !== -1) plain.splice(twin, 1);
+  }
+  return [...memoEvents, ...plain];
+}
+
+// src/tempo-rail.ts
+var NAME2 = "mpp-tempo";
+var METHOD2 = "tempo";
+var INTENT2 = "charge";
+var TOKEN_SCALE = 6;
+function mppTempo(options) {
+  const secrets = challengeSecrets(options.secret, NAME2);
+  const realm = asciiRealm(options.realm);
+  const recipient = requireAddress(options.recipient, "recipient");
+  const token = requireAddress(options.token.address, "token.address");
+  const modes = options.modes ?? ["pull"];
+  if (modes.length === 0) {
+    throw new TollstileError6("CONFIG_INVALID", 'mppTempo() `modes` must list "pull", "push", or both.');
+  }
+  if (!Number.isSafeInteger(options.chainId) || options.chainId <= 0) {
+    throw new TollstileError6("CONFIG_INVALID", `mppTempo() \`chainId\` must be a positive integer, got ${String(options.chainId)}.`);
+  }
+  const clock = options.clock ?? { now: () => /* @__PURE__ */ new Date() };
+  const marginMs = options.validityMarginMs ?? 6e4;
+  const rpc = { url: options.rpcUrl, fetch: options.fetch ?? ((input, init) => fetch(input, init)) };
+  const splitsFor = (amount) => {
+    const splits = (options.splits?.(amount) ?? []).map((split) => ({
+      recipient: requireAddress(split.recipient, "splits[].recipient"),
+      amount: split.amount,
+      memo: split.memo === void 0 ? null : requireBytes32(split.memo)
+    }));
+    const total = splits.reduce((sum, split) => sum + split.amount, 0n);
+    return splits.some((split) => split.amount <= 0n) || total >= amount ? void 0 : splits;
+  };
+  const request = (amount, quote, splits) => ({
+    amount: amount.toString(),
+    currency: token,
+    recipient,
+    methodDetails: {
+      chainId: options.chainId,
+      memo: challengeMemo(realm, quote),
+      // The spec requires listing the modes only when not both are supported.
+      ...modes.includes("pull") && modes.includes("push") ? {} : { supportedModes: [...modes] },
+      ...splits.length === 0 ? {} : { splits: requestTransfersJson(splits) }
+    }
+  });
+  const expired = (data) => data.validBefore !== null && clock.now().getTime() > Number(data.validBefore) * 1e3 + marginMs;
+  const fromReceipt = (receipt, data) => receipt.success ? { status: "settled", reference: receipt.transactionHash, details: { mode: data.mode, blockNumber: receipt.blockNumber } } : { status: "rejected", reason: "transaction_reverted" };
+  return {
+    name: NAME2,
+    livemode: true,
+    capabilities: {
+      flows: ["authorization"],
+      authorization: "single",
+      variableAmount: false,
+      quotes: true,
+      refund: false,
+      partialRefund: false,
+      lookup: true
+    },
+    offer({ price }) {
+      if (price.currency !== options.denomination) return Promise.resolve(null);
+      const amount = toAssetUnits2(price, TOKEN_SCALE);
+      if (splitsFor(amount) === void 0) return Promise.resolve(null);
+      return Promise.resolve({
+        rail: NAME2,
+        asset: { code: options.token.code, network: `eip155:${String(options.chainId)}`, scale: TOKEN_SCALE },
+        amount: amount.toString(),
+        basis: "par",
+        details: { method: METHOD2, intent: INTENT2, token, recipient }
+      });
+    },
+    challenge(quote, quoteToken, offer) {
+      const amount = BigInt(offer.amount);
+      const splits = splitsFor(amount) ?? [];
+      return quoteChallenge(secrets, { realm, method: METHOD2, intent: INTENT2, request: request(amount, quote, splits) }, quote, quoteToken);
+    },
+    async verify(context, terms, operation) {
+      const now = clock.now();
+      const read = await readCredential(context, { realm, method: METHOD2, intent: INTENT2, secrets, now });
+      if (read.status === "absent") return read;
+      if (read.status === "invalid") return rejected(read);
+      const { credential } = read;
+      const resolved = await chargeTerms(credential, terms, NAME2);
+      if (resolved.status === "invalid") return rejected(resolved);
+      if (resolved.quote === null || resolved.offer === null) return { status: "invalid", reason: "quote_required" };
+      const { quote } = resolved;
+      const amount = BigInt(resolved.offer.amount);
+      const splits = splitsFor(amount);
+      if (splits === void 0 || !sameRequest(credential, request(amount, quote, splits))) {
+        return { status: "invalid", reason: "challenge_terms_mismatch" };
+      }
+      const transfers = requiredTransfers(amount, recipient, challengeMemo(realm, quote), splits);
+      const challengeId = credential.challenge.id;
+      const challengeExpires = new Date(Date.parse(credential.challenge.expires));
+      const { payload } = credential;
+      if (payload.type === "transaction" && modes.includes("pull")) {
+        if (typeof payload.signature !== "string") return { status: "invalid", reason: "invalid_payload" };
+        const decoded = decodeTempoTransaction(payload.signature);
+        if (!decoded.ok) return { status: "invalid", reason: decoded.reason };
+        const { transaction } = decoded;
+        if (transaction.chainId !== BigInt(options.chainId)) return { status: "invalid", reason: "chain_mismatch" };
+        if (transaction.validBefore === null) return { status: "invalid", reason: "valid_before_required" };
+        const validBeforeMs = Number(transaction.validBefore) * 1e3;
+        if (validBeforeMs > challengeExpires.getTime()) return { status: "invalid", reason: "valid_before_after_expiry" };
+        if (validBeforeMs <= now.getTime()) return { status: "invalid", reason: "transaction_expired", proofId: challengeId };
+        if (transaction.validAfter !== null && Number(transaction.validAfter) * 1e3 > now.getTime()) {
+          return { status: "invalid", reason: "transaction_not_yet_valid" };
+        }
+        if (!callsPay(transaction.calls, token, transfers)) return { status: "invalid", reason: "transfer_mismatch" };
+        return {
+          status: "valid",
+          proofId: challengeId,
+          payer: `did:pkh:eip155:${String(options.chainId)}:${transaction.sender}`,
+          quote,
+          limit: resolved.price,
+          expiresAt: new Date(validBeforeMs),
+          data: {
+            challengeId,
+            mode: "pull",
+            hash: transaction.hash,
+            transaction: payload.signature,
+            validBefore: transaction.validBefore.toString()
+          },
+          idempotencyKey: challengeId
+        };
+      }
+      if (payload.type === "hash" && modes.includes("push")) {
+        const hash = parseBytes32(payload.hash);
+        if (hash === void 0) return { status: "invalid", reason: "invalid_payload" };
+        const receipt = await getReceipt(rpc, hash, operation.signal);
+        if (receipt === null) return { status: "invalid", reason: "transaction_not_found" };
+        if (!receipt.success) return { status: "invalid", reason: "transaction_reverted" };
+        const sender = logsPay(receipt.logs, token, transfers);
+        if (sender === void 0) return { status: "invalid", reason: "transfer_mismatch" };
+        return {
+          status: "valid",
+          proofId: challengeId,
+          payer: `did:pkh:eip155:${String(options.chainId)}:${sender}`,
+          quote,
+          limit: resolved.price,
+          expiresAt: challengeExpires,
+          data: { challengeId, mode: "push", hash, transaction: null, validBefore: null },
+          settled: { reference: receipt.transactionHash, details: { mode: "push", blockNumber: receipt.blockNumber } },
+          idempotencyKey: challengeId
+        };
+      }
+      return { status: "invalid", reason: "mode_unsupported" };
+    },
+    async settle(authorization, _charge, operation) {
+      const data = tempoData(authorization);
+      if (data.mode === "push") {
+        return { status: "settled", reference: data.hash, details: { mode: "push" } };
+      }
+      const { transaction } = data;
+      if (transaction === null || expired(data)) {
+        const receipt2 = await getReceipt(rpc, data.hash, operation.signal);
+        if (receipt2 !== null) return fromReceipt(receipt2, data);
+        return { status: "rejected", reason: transaction === null ? "transaction_not_included" : "transaction_expired" };
+      }
+      const answer = await rpcCall(rpc, "eth_sendRawTransactionSync", [transaction], { signal: operation.signal, write: true });
+      const receipt = answer.ok ? parseReceipt(answer.result) : await getReceipt(rpc, data.hash, operation.signal);
+      if (receipt === void 0) throw new TollstileError6("PROVIDER_TIMEOUT", "Tempo RPC returned a malformed receipt from eth_sendRawTransactionSync.");
+      if (receipt !== null) {
+        if (receipt.transactionHash !== data.hash) throw new TollstileError6("PROVIDER_TIMEOUT", "Tempo RPC returned a receipt for another transaction.");
+        return fromReceipt(receipt, data);
+      }
+      if (expired(data)) return { status: "rejected", reason: `rpc_error_${String(answer.ok ? 0 : answer.code)}` };
+      throw new TollstileError6("PROVIDER_TIMEOUT", `Tempo RPC refused the transaction (${answer.ok ? "no receipt" : String(answer.code)}); it may still be included before it expires.`);
+    },
+    refund() {
+      return Promise.resolve({ status: "rejected", reason: "refund_unsupported" });
+    },
+    release() {
+      return Promise.resolve();
+    },
+    redact(data) {
+      return { ...data, transaction: null };
+    },
+    async lookup(authorization, _charge, operation) {
+      const data = tempoData(authorization);
+      const receipt = await getReceipt(rpc, data.hash, operation.signal);
+      if (receipt !== null) {
+        return receipt.success ? { status: "settled", reference: receipt.transactionHash, details: { mode: data.mode, blockNumber: receipt.blockNumber } } : { status: "none" };
+      }
+      if (data.mode === "pull") return { status: "none" };
+      throw new TollstileError6("PROVIDER_TIMEOUT", `Push transaction for ${authorization.id} was verified on-chain but has no receipt now.`);
+    },
+    receipt(authorization, charge, context) {
+      const data = tempoData(authorization);
+      return paymentReceipt(context, { method: METHOD2, reference: charge.settlement?.reference ?? data.hash, settledAt: charge.updatedAt, challengeId: data.challengeId });
+    }
+  };
+}
+function tempoData(authorization) {
+  const { data } = authorization;
+  if (!isObject(data) || typeof data.challengeId !== "string" || data.mode !== "pull" && data.mode !== "push" || typeof data.hash !== "string" || !(typeof data.transaction === "string" || data.transaction === null) || !(isIntegerString(data.validBefore) || data.validBefore === null)) {
+    throw inconsistent(authorization);
+  }
+  return { challengeId: data.challengeId, mode: data.mode, hash: data.hash, transaction: data.transaction, validBefore: data.validBefore };
+}
+function inconsistent(authorization) {
+  return new TollstileError6("LEDGER_INCONSISTENT", `Authorization ${authorization.id} does not hold mpp-tempo data.`);
+}
+function requireAddress(value, name) {
+  const address = parseAddress(value);
+  if (address === void 0) throw new TollstileError6("CONFIG_INVALID", `\`${name}\` must be a 0x-prefixed 20-byte address, got "${value}".`);
+  return address;
+}
+function requireBytes32(value) {
+  const bytes = parseBytes32(value);
+  if (bytes === void 0) throw new TollstileError6("CONFIG_INVALID", `Split memo must be a 0x-prefixed bytes32, got "${value}".`);
+  return bytes;
+}
+
+// src/tempo-session-rail.ts
+import {
+  TollstileError as TollstileError7,
+  money,
+  toAssetUnits as toAssetUnits3
+} from "tollstile";
+
+// src/tempo-channel.ts
+var TEMPO_CHANNEL_ESCROW = "0x4d50500000000000000000000000000000000000";
+var MAX_UINT96 = (1n << 96n) - 1n;
+var DOMAIN_TYPE = keccak256(utf8("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"));
+var DOMAIN_NAME = keccak256(utf8("TIP20 Channel Reserve"));
+var DOMAIN_VERSION = keccak256(utf8("1"));
+var VOUCHER_TYPE = keccak256(utf8("Voucher(bytes32 channelId,uint96 cumulativeAmount)"));
+var GET_CHANNEL_STATE = selector("getChannelState(bytes32)");
+var CLOSE = selector("close((address,address,address,address,bytes32,address,bytes32),uint96,uint96,bytes)");
+function parseDescriptor(value) {
+  if (!isObject(value)) return void 0;
+  const payer = parseAddress(value.payer);
+  const payee = parseAddress(value.payee);
+  const operator = parseAddress(value.operator);
+  const token = parseAddress(value.token);
+  const salt = parseBytes32(value.salt);
+  const authorizedSigner = parseAddress(value.authorizedSigner);
+  const expiringNonceHash = parseBytes32(value.expiringNonceHash);
+  if (payer === void 0 || payee === void 0 || operator === void 0 || token === void 0 || salt === void 0 || authorizedSigner === void 0 || expiringNonceHash === void 0) {
+    return void 0;
+  }
+  return { payer, payee, operator, token, salt, authorizedSigner, expiringNonceHash };
+}
+function channelId(descriptor, escrow, chainId) {
+  return toHex(keccak256(concat(descriptorWords(descriptor), addressWord(escrow), word(BigInt(chainId)))));
+}
+function voucherSigner(descriptor) {
+  return descriptor.authorizedSigner === ZERO_ADDRESS ? descriptor.payer : descriptor.authorizedSigner;
+}
+function voucherDigest(escrow, chainId, channel, cumulativeAmount) {
+  const domain = keccak256(concat(DOMAIN_TYPE, DOMAIN_NAME, DOMAIN_VERSION, word(BigInt(chainId)), addressWord(escrow)));
+  const voucher = keccak256(concat(VOUCHER_TYPE, fromHex(channel) ?? new Uint8Array(32), word(cumulativeAmount)));
+  return keccak256(concat(Uint8Array.of(25, 1), domain, voucher));
+}
+function getChannelStateCall(channel) {
+  return toHex(concat(fromHex(GET_CHANNEL_STATE) ?? new Uint8Array(), fromHex(channel) ?? new Uint8Array(32)));
+}
+function decodeChannelState(result) {
+  const bytes = typeof result === "string" ? fromHex(result) : void 0;
+  if (bytes?.length !== 96) return void 0;
+  return {
+    settled: toBigInt(bytes.subarray(0, 32)),
+    deposit: toBigInt(bytes.subarray(32, 64)),
+    closeRequestedAt: toBigInt(bytes.subarray(64, 96))
+  };
+}
+function closeCall(descriptor, cumulativeAmount, captureAmount, signature) {
+  const padded = new Uint8Array(Math.ceil(signature.length / 32) * 32);
+  padded.set(signature);
+  const head = concat(descriptorWords(descriptor), word(cumulativeAmount), word(captureAmount), word(10n * 32n));
+  return toHex(concat(fromHex(CLOSE) ?? new Uint8Array(), head, word(BigInt(signature.length)), padded));
+}
+function descriptorWords(descriptor) {
+  return concat(
+    addressWord(descriptor.payer),
+    addressWord(descriptor.payee),
+    addressWord(descriptor.operator),
+    addressWord(descriptor.token),
+    fromHex(descriptor.salt) ?? new Uint8Array(32),
+    addressWord(descriptor.authorizedSigner),
+    fromHex(descriptor.expiringNonceHash) ?? new Uint8Array(32)
+  );
+}
+
+// src/tempo-session-rail.ts
+var NAME3 = "mpp-tempo-session";
+var METHOD3 = "tempo";
+var INTENT3 = "session";
+var TOKEN_SCALE2 = 6;
+function mppTempoSession(options) {
+  const secrets = challengeSecrets(options.secret, NAME3);
+  const realm = asciiRealm(options.realm);
+  const recipient = requireAddress(options.recipient, "recipient");
+  const token = requireAddress(options.token.address, "token.address");
+  const escrow = requireAddress(options.escrow ?? TEMPO_CHANNEL_ESCROW, "escrow");
+  const operator = requireAddress(options.operator ?? ZERO_ADDRESS, "operator");
+  const clock = options.clock ?? { now: () => /* @__PURE__ */ new Date() };
+  const rpc = { url: options.rpcUrl, fetch: options.fetch ?? ((input, init) => fetch(input, init)) };
+  const vouchers = /* @__PURE__ */ new Map();
+  const request = (amount) => ({
+    amount: amount.toString(),
+    unitType: "request",
+    currency: token,
+    recipient,
+    methodDetails: {
+      chainId: options.chainId,
+      escrowContract: escrow,
+      sessionProtocol: "v2",
+      ...operator === ZERO_ADDRESS ? {} : { operator }
+    }
+  });
+  return {
+    name: NAME3,
+    livemode: true,
+    capabilities: {
+      flows: ["upfront"],
+      authorization: "reusable",
+      variableAmount: false,
+      quotes: true,
+      // Nothing is captured on-chain per charge, so a refund is releasing consumption the close
+      // helper would otherwise capture. See README: closing must use the ledger's consumption.
+      refund: true,
+      partialRefund: false,
+      lookup: true
+    },
+    offer({ price }) {
+      if (price.currency !== options.denomination) return Promise.resolve(null);
+      return Promise.resolve({
+        rail: NAME3,
+        asset: { code: options.token.code, network: `eip155:${String(options.chainId)}`, scale: TOKEN_SCALE2 },
+        amount: toAssetUnits3(price, TOKEN_SCALE2).toString(),
+        basis: "par",
+        details: { method: METHOD3, intent: INTENT3, escrow, recipient }
+      });
+    },
+    challenge(quote, quoteToken, offer) {
+      return quoteChallenge(secrets, { realm, method: METHOD3, intent: INTENT3, request: request(BigInt(offer.amount)) }, quote, quoteToken);
+    },
+    async verify(context, terms, operation) {
+      const now = clock.now();
+      for (const [key, entry] of vouchers) if (entry.expiresAt <= now.getTime()) vouchers.delete(key);
+      const read = await readCredential(context, { realm, method: METHOD3, intent: INTENT3, secrets, now });
+      if (read.status === "absent") return read;
+      if (read.status === "invalid") return { status: "invalid", reason: read.reason };
+      const { credential } = read;
+      const resolved = await chargeTerms(credential, terms, NAME3);
+      if (resolved.status === "invalid") return { status: "invalid", reason: resolved.reason };
+      const amount = resolved.offer === null ? toAssetUnits3(resolved.price, TOKEN_SCALE2) : BigInt(resolved.offer.amount);
+      if (resolved.price.currency !== options.denomination || !sameRequest(credential, request(amount))) {
+        return { status: "invalid", reason: "challenge_terms_mismatch" };
+      }
+      const { payload } = credential;
+      if (payload.action !== "voucher") return { status: "invalid", reason: "session_action_unsupported" };
+      const descriptor = parseDescriptor(payload.descriptor);
+      const channel = parseBytes32(payload.channelId);
+      const signature = typeof payload.signature === "string" ? fromHex(payload.signature) : void 0;
+      if (descriptor === void 0 || channel === void 0 || signature === void 0 || !isIntegerString(payload.cumulativeAmount)) {
+        return { status: "invalid", reason: "invalid_payload" };
+      }
+      const cumulativeAmount = BigInt(payload.cumulativeAmount);
+      if (cumulativeAmount > MAX_UINT96) return { status: "invalid", reason: "invalid_payload" };
+      if (descriptor.payee !== recipient || descriptor.token !== token || descriptor.operator !== operator) {
+        return { status: "invalid", reason: "channel_terms_mismatch" };
+      }
+      if (channelId(descriptor, escrow, options.chainId) !== channel) return { status: "invalid", reason: "channel_id_mismatch" };
+      if (recoverAddress(voucherDigest(escrow, options.chainId, channel, cumulativeAmount), signature) !== voucherSigner(descriptor)) {
+        return { status: "invalid", reason: "signature_invalid" };
+      }
+      const answer = await rpcCall(rpc, "eth_call", [{ to: escrow, data: getChannelStateCall(channel) }, "latest"], { signal: operation.signal, write: false });
+      const state = answer.ok ? decodeChannelState(answer.result) : void 0;
+      if (state === void 0) throw new TollstileError7("PROVIDER_UNAVAILABLE", "Tempo RPC could not read the channel state.");
+      if (state.deposit === 0n) return { status: "invalid", reason: "channel_not_found" };
+      if (state.closeRequestedAt !== 0n) return { status: "invalid", reason: "channel_closing" };
+      if (cumulativeAmount > state.deposit) return { status: "invalid", reason: "amount_exceeds_deposit" };
+      if (cumulativeAmount < state.settled) return { status: "invalid", reason: "voucher_below_settled" };
+      const expiresAt = Date.parse(credential.challenge.expires);
+      vouchers.set(context.requestId, { channelId: channel, cumulativeAmount, signature: payload.signature, challengeId: credential.challenge.id, expiresAt });
+      return {
+        status: "valid",
+        proofId: channel,
+        payer: `did:pkh:eip155:${String(options.chainId)}:${descriptor.payer}`,
+        quote: resolved.quote,
+        // The ledger stores the limit of the first verification; later deposits do not raise it.
+        limit: money(options.denomination, state.deposit - state.settled),
+        expiresAt: null,
+        data: { channelId: channel, descriptor, baseline: state.settled.toString() }
+      };
+    },
+    settle(authorization, charge) {
+      const data = sessionData(authorization);
+      const voucher = vouchers.get(charge.requestId);
+      if (voucher?.channelId !== data.channelId) {
+        return Promise.reject(
+          new TollstileError7("PROVIDER_UNAVAILABLE", `No voucher for ${charge.id} is held by this process. Reconciliation will release it.`)
+        );
+      }
+      vouchers.delete(charge.requestId);
+      const required = BigInt(data.baseline) + toAssetUnits3(authorization.consumed, TOKEN_SCALE2) + toAssetUnits3(authorization.reserved, TOKEN_SCALE2);
+      if (voucher.cumulativeAmount < required) return Promise.resolve({ status: "rejected", reason: "voucher_insufficient" });
+      return Promise.resolve({
+        status: "settled",
+        reference: `${data.channelId}:${required.toString()}`,
+        details: {
+          channelId: data.channelId,
+          challengeId: voucher.challengeId,
+          cumulativeAmount: voucher.cumulativeAmount.toString(),
+          signature: voucher.signature,
+          required: required.toString()
+        }
+      });
+    },
+    refund(_authorization, charge) {
+      return Promise.resolve({ status: "refunded", reference: `${charge.settlement?.reference ?? charge.id}:uncaptured` });
+    },
+    release(_authorization, charge) {
+      vouchers.delete(charge.requestId);
+      return Promise.resolve();
+    },
+    lookup(_authorization, charge) {
+      return Promise.resolve(
+        charge.pending === "refund" ? { status: "refunded", reference: `${charge.settlement?.reference ?? charge.id}:uncaptured` } : { status: "none" }
+      );
+    },
+    receipt(authorization, charge, context) {
+      const data = sessionData(authorization);
+      const details = isObject(charge.settlement?.details) ? charge.settlement.details : {};
+      return paymentReceipt(context, {
+        method: METHOD3,
+        reference: data.channelId,
+        settledAt: charge.updatedAt,
+        challengeId: typeof details.challengeId === "string" ? details.challengeId : "",
+        extra: {
+          intent: INTENT3,
+          channelId: data.channelId,
+          acceptedCumulative: stringOr(details.cumulativeAmount),
+          spent: stringOr(details.required)
+        }
+      });
+    }
+  };
+}
+function tempoSessionClose(input) {
+  const data = sessionData(input.authorization);
+  const escrow = requireAddress(input.escrow ?? TEMPO_CHANNEL_ESCROW, "escrow");
+  const descriptor = parseDescriptor(data.descriptor);
+  if (descriptor === void 0) throw new TollstileError7("LEDGER_INCONSISTENT", `Authorization ${input.authorization.id} has no channel descriptor.`);
+  const consumed = BigInt(data.baseline) + toAssetUnits3(input.authorization.consumed, TOKEN_SCALE2);
+  const captureAmount = input.settledOnChain === void 0 || input.settledOnChain < consumed ? consumed : input.settledOnChain;
+  const voucher = input.charges.filter((charge) => charge.authorizationId === input.authorization.id).map((charge) => isObject(charge.settlement?.details) ? charge.settlement.details : {}).flatMap(
+    (details) => isIntegerString(details.cumulativeAmount) && typeof details.signature === "string" ? [{ cumulativeAmount: BigInt(details.cumulativeAmount), signature: details.signature }] : []
+  ).reduce((best, next) => best === void 0 || next.cumulativeAmount > best.cumulativeAmount ? next : best, void 0);
+  const signature = voucher === void 0 ? void 0 : fromHex(voucher.signature);
+  if (voucher === void 0 || signature === void 0 || voucher.cumulativeAmount < captureAmount) {
+    throw new TollstileError7(
+      "LEDGER_INCONSISTENT",
+      `No voucher among the given charges covers the ${captureAmount.toString()} base units consumed on ${data.channelId}. Pass every settled charge of the authorization.`
+    );
+  }
+  return {
+    channelId: data.channelId,
+    to: escrow,
+    data: closeCall(descriptor, voucher.cumulativeAmount, captureAmount, signature),
+    captureAmount,
+    cumulativeAmount: voucher.cumulativeAmount
+  };
+}
+function sessionData(authorization) {
+  const { data } = authorization;
+  const descriptor = isObject(data) ? parseDescriptor(data.descriptor) : void 0;
+  if (!isObject(data) || typeof data.channelId !== "string" || descriptor === void 0 || !isIntegerString(data.baseline)) {
+    throw new TollstileError7("LEDGER_INCONSISTENT", `Authorization ${authorization.id} does not hold mpp-tempo-session data.`);
+  }
+  return { channelId: data.channelId, descriptor, baseline: data.baseline };
+}
+function stringOr(value) {
+  return typeof value === "string" ? value : "";
+}
+export {
+  mppStripe,
+  mppTempo,
+  mppTempoSession,
+  tempoSessionClose
+};