thunder-bridge 1.4.2 → 1.5.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,69 +17,45 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
+  AmountError: () => AmountError,
   GatewayCheatError: () => GatewayCheatError,
   Gateways: () => Gateways,
-  IDEMPOTENCY_KEY_REUSED: () => IDEMPOTENCY_KEY_REUSED,
   IdempotencyConflictError: () => IdempotencyConflictError,
-  NO_WALLET_AVAILABLE: () => NO_WALLET_AVAILABLE,
   NoWalletAvailableError: () => NoWalletAvailableError,
-  PAYMENT_ALREADY_WATCHED: () => PAYMENT_ALREADY_WATCHED,
   ProblemError: () => ProblemError,
-  REQUEST_IN_FLIGHT: () => REQUEST_IN_FLIGHT,
   ThunderBridge: () => ThunderBridge,
   UnverifiedRecipientError: () => UnverifiedRecipientError,
   WrapRefusedError: () => WrapRefusedError,
   answerVerifyChallenge: () => answerVerifyChallenge,
-  answerVerifyChallengeRequest: () => answerVerifyChallengeRequest,
-  answerWebhookChallenge: () => answerWebhookChallenge,
-  answerWebhookChallengeRequest: () => answerWebhookChallengeRequest,
-  bankRail: () => bankRail,
-  bankTransfer: () => bankTransfer,
-  bankVerifyEndpoint: () => bankVerifyEndpoint,
-  bitstamp: () => bitstamp,
-  coinbase: () => coinbase,
-  coinmate: () => coinmate,
+  carriesProof: () => carriesProof,
   decodeInvoice: () => decodeInvoice,
-  fioStatement: () => fioStatement,
-  invoiceToDataUrl: () => invoiceToDataUrl,
-  invoiceToSvg: () => invoiceToSvg,
-  isProblemType: () => isProblemType,
-  isProvablyPaid: () => isProvablyPaid,
-  isProvablySettled: () => isProvablySettled,
-  kraken: () => kraken,
-  lightningRail: () => lightningRail,
-  lnurlToDataUrl: () => lnurlToDataUrl,
-  lnurlToSvg: () => lnurlToSvg,
-  medianOf: () => medianOf,
-  minorScaleOf: () => minorScaleOf,
-  minorUnitsOf: () => minorUnitsOf,
-  msatFor: () => msatFor,
-  parseSettlement: () => parseSettlement,
-  parseSettlementRequest: () => parseSettlementRequest,
-  parseWatchedWebhook: () => parseWatchedWebhook,
-  parseWatchedWebhookRequest: () => parseWatchedWebhookRequest,
-  parseWebhook: () => parseWebhook,
-  parseWebhookRequest: () => parseWebhookRequest,
+  fiat: () => fiat,
+  invoiceFrom: () => invoiceFrom,
+  msat: () => msat,
   preimageMatchesHash: () => preimageMatchesHash,
   proveOrigin: () => proveOrigin,
   proveSettlement: () => proveSettlement,
   proveWrapped: () => proveWrapped,
-  qrToDataUrl: () => qrToDataUrl,
-  qrToSvg: () => qrToSvg,
+  relayedVerifyUrl: () => relayedVerifyUrl,
+  sats: () => sats,
   seal: () => seal,
-  spdToDataUrl: () => spdToDataUrl,
-  spdToSvg: () => spdToSvg,
-  toLnurl: () => toLnurl,
   unseal: () => unseal,
-  verifyWebhookSignature: () => verifyWebhookSignature,
   wrapFeeCeiling: () => wrapFeeCeiling
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // ../core/bytes.ts
 function bytesToHex(bytes) {
@@ -94,8 +72,8 @@ function hexToBytes(hex) {
   }
   return bytes;
 }
-function isHex(text2) {
-  return /^[0-9a-f]+$/i.test(text2) && text2.length % 2 === 0;
+function isHex(text3) {
+  return /^[0-9a-f]+$/i.test(text3) && text3.length % 2 === 0;
 }
 
 // ../core/sha256.ts
@@ -189,8 +167,8 @@ function sha256(bytes) {
   }
   return asBytes(state);
 }
-function sha256Hex(text2) {
-  return bytesToHex(sha256(new TextEncoder().encode(text2)));
+function sha256Hex(text3) {
+  return bytesToHex(sha256(new TextEncoder().encode(text3)));
 }
 function withPadding(bytes) {
   const padded = new Uint8Array(
@@ -377,158 +355,6 @@ function wordsToBytes(words) {
   return Uint8Array.from(bytes);
 }
 
-// ../core/url.ts
-var PRIVATE_SUFFIXES = ["localhost", "local", "internal", "lan", "arpa", "test", "invalid"];
-function publicHttps(raw) {
-  let url;
-  try {
-    url = new URL(raw);
-  } catch {
-    return false;
-  }
-  return url.protocol === "https:" && hostIsPublic(url.hostname.toLowerCase());
-}
-function sameOrigin(one, other) {
-  try {
-    return new URL(one).origin === new URL(other).origin;
-  } catch {
-    return false;
-  }
-}
-function publicAddress(literal) {
-  return literal.includes(":") ? ipv6IsGlobal(literal) : ipv4IsGlobal(literal);
-}
-function hostIsPublic(host) {
-  if (host.startsWith("[")) {
-    return publicAddress(host.slice(1, -1));
-  }
-  const name = host.replace(/\.$/, "");
-  if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) {
-    return publicAddress(name);
-  }
-  const labels = name.split(".");
-  if (labels.length < 2 || labels.some((label) => label === "")) {
-    return false;
-  }
-  return !PRIVATE_SUFFIXES.includes(labels[labels.length - 1]);
-}
-function ipv4IsGlobal(literal) {
-  const parts = literal.split(".").map(Number);
-  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
-    return false;
-  }
-  const [a, b] = parts;
-  if (a === 0 || a === 10 || a === 127 || a >= 240) {
-    return false;
-  }
-  if (a === 100 && b >= 64 && b < 128) {
-    return false;
-  }
-  if (a === 169 && b === 254) {
-    return false;
-  }
-  if (a === 172 && b >= 16 && b < 32) {
-    return false;
-  }
-  if (a === 192 && b === 168) {
-    return false;
-  }
-  return true;
-}
-function ipv6IsGlobal(literal) {
-  const groups = ipv6Groups(literal.toLowerCase());
-  if (groups.length !== 8 || groups.some(Number.isNaN)) {
-    return false;
-  }
-  const leading = groups.slice(0, 5).every((group) => group === 0);
-  if (leading && groups[5] === 0 && groups[6] === 0 && groups[7] <= 1) {
-    return false;
-  }
-  if (leading && groups[5] === 65535) {
-    const [high, low] = [groups[6], groups[7]];
-    return ipv4IsGlobal(`${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`);
-  }
-  const first = groups[0];
-  if ((first & 65024) === 64512) {
-    return false;
-  }
-  if ((first & 65472) === 65152) {
-    return false;
-  }
-  return true;
-}
-function ipv6Groups(address) {
-  const [head = "", tail] = address.split("::");
-  const left = head.split(":").filter((group) => group !== "");
-  const right = (tail ?? "").split(":").filter((group) => group !== "");
-  const gap = tail === void 0 ? [] : Array(8 - left.length - right.length).fill("0");
-  return [...left, ...gap, ...right].map((group) => parseInt(group, 16));
-}
-
-// ../core/lnurl.ts
-var BECH32_CHARSET2 = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
-var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
-var CHECKSUM_SLOTS = [0, 1, 2, 3, 4, 5];
-var LNURL_HRP = "lnurl";
-function toLnurl(endpoint) {
-  const scheme = parsedScheme(endpoint);
-  if (scheme !== "https:" && scheme !== "http:") {
-    throw new Error(`${endpoint} is not an http or https URL`);
-  }
-  const words = toWords(new TextEncoder().encode(endpoint));
-  const data = [...words, ...checksumWords(LNURL_HRP, words)];
-  return `${LNURL_HRP}1${data.map((word) => BECH32_CHARSET2[word]).join("")}`.toUpperCase();
-}
-function parsedScheme(endpoint) {
-  try {
-    return new URL(endpoint).protocol;
-  } catch {
-    return null;
-  }
-}
-function toWords(bytes) {
-  const words = [];
-  let accumulator = 0;
-  let bits = 0;
-  for (const byte of bytes) {
-    accumulator = accumulator << 8 | byte;
-    bits += 8;
-    while (bits >= 5) {
-      bits -= 5;
-      words.push(accumulator >> bits & 31);
-    }
-  }
-  if (bits > 0) {
-    words.push(accumulator << 5 - bits & 31);
-  }
-  return words;
-}
-function checksumWords(hrp, words) {
-  const expanded = [...hrp].map((char) => char.charCodeAt(0));
-  const values = [
-    ...expanded.map((code) => code >> 5),
-    0,
-    ...expanded.map((code) => code & 31),
-    ...words,
-    ...CHECKSUM_SLOTS.map(() => 0)
-  ];
-  const polymod = bech32Polymod(values) ^ 1;
-  return CHECKSUM_SLOTS.map((slot) => polymod >> 5 * (5 - slot) & 31);
-}
-function bech32Polymod(values) {
-  let checksum = 1;
-  for (const value of values) {
-    const top = checksum >> 25;
-    checksum = (checksum & 33554431) << 5 ^ value;
-    for (let bit = 0; bit < 5; bit++) {
-      if (top >> bit & 1) {
-        checksum ^= BECH32_GENERATOR[bit];
-      }
-    }
-  }
-  return checksum;
-}
-
 // ../core/sealed.ts
 var VERSION = "v1";
 var IV_BYTES = 12;
@@ -594,12 +420,12 @@ function toBase64Url(bytes) {
   }
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
-function fromBase64Url(text2) {
-  if (text2.length === 0 || !/^[A-Za-z0-9_-]+$/.test(text2)) {
+function fromBase64Url(text3) {
+  if (text3.length === 0 || !/^[A-Za-z0-9_-]+$/.test(text3)) {
     return null;
   }
   try {
-    const binary = atob(text2.replace(/-/g, "+").replace(/_/g, "/"));
+    const binary = atob(text3.replace(/-/g, "+").replace(/_/g, "/"));
     const bytes = new Uint8Array(binary.length);
     for (let at = 0; at < bytes.length; at++) {
       bytes[at] = binary.charCodeAt(at);
@@ -610,32 +436,109 @@ function fromBase64Url(text2) {
   }
 }
 
-// ../core/hmac.ts
-async function hmacHex(secret, payload) {
-  const raw = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
-  const key = await crypto.subtle.importKey(
-    "raw",
-    asBuffer(raw),
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  const message = typeof payload === "string" ? new TextEncoder().encode(payload) : payload;
-  return bytesToHex(new Uint8Array(await crypto.subtle.sign("HMAC", key, asBuffer(message))));
-}
-function equalInConstantTime(one, other) {
-  if (one.length !== other.length) {
-    return false;
+// src/errors.ts
+var AmountError = class extends Error {
+  /**
+   * Whether a failure is one of these, without asking whether it is this exact
+   * class. Every entry point carries its own copy of the class, so a price
+   * refused inside `thunder-bridge/price` is not `instanceof` the `AmountError`
+   * imported from `thunder-bridge`. The name and the code are the same in every
+   * copy, so this holds where `instanceof` does not
+   */
+  static is(failure) {
+    return failure instanceof Error && failure.name === "AmountError" && "code" in failure;
   }
-  let difference = 0;
-  for (let at = 0; at < one.length; at++) {
-    difference |= one.charCodeAt(at) ^ other.charCodeAt(at);
+  code;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "AmountError";
+    this.code = code;
   }
-  return difference === 0;
-}
-function asBuffer(bytes) {
-  return bytes instanceof Uint8Array && bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
+};
+var GatewayCheatError = class extends Error {
+  code;
+  paymentId;
+  constructor(code, paymentId) {
+    super(`gateway verification failed: ${code}`);
+    this.name = "GatewayCheatError";
+    this.code = code;
+    this.paymentId = paymentId;
+  }
+};
+var WrapRefusedError = class extends Error {
+  code;
+  constructor(code, detail) {
+    super(`wrapped invoice refused: ${code}, ${detail}`);
+    this.name = "WrapRefusedError";
+    this.code = code;
+  }
+};
+var UnverifiedRecipientError = class extends Error {
+  lnAddress;
+  paymentId;
+  constructor(lnAddress, paymentId, cause) {
+    super(`could not reach ${lnAddress} to verify the invoice: ${String(cause)}`);
+    this.name = "UnverifiedRecipientError";
+    this.lnAddress = lnAddress;
+    this.paymentId = paymentId;
+  }
+};
+var ProblemError = class extends Error {
+  static NO_WALLET_AVAILABLE = "urn:problem-type:thunder-bridge:no-wallet-available";
+  static REQUEST_IN_FLIGHT = "urn:problem-type:thunder-bridge:request-in-flight";
+  static IDEMPOTENCY_KEY_REUSED = "urn:problem-type:thunder-bridge:idempotency-key-reused";
+  static PAYMENT_ALREADY_WATCHED = "urn:problem-type:thunder-bridge:payment-already-watched";
+  static INVALID_REQUEST = "urn:problem-type:thunder-bridge:invalid-request";
+  static CALLER_UNKNOWN = "urn:problem-type:thunder-bridge:caller-unknown";
+  static VERIFY_HOST_REFUSED = "urn:problem-type:thunder-bridge:verify-host-refused";
+  static VERIFY_UNCONFIRMED = "urn:problem-type:thunder-bridge:verify-unconfirmed";
+  static VERIFY_UNCONSENTED = "urn:problem-type:thunder-bridge:verify-unconsented";
+  static WEBHOOK_UNCONFIRMED = "urn:problem-type:thunder-bridge:webhook-unconfirmed";
+  static TOO_MANY_PENDING = "urn:problem-type:thunder-bridge:too-many-pending";
+  /**
+   * Whether a problem carries this type. Branch on the type, never on the prose,
+   * and reach for `instanceof` first: every type this SDK gives a class to has one
+   */
+  static is(problem, type) {
+    return problem.type === type;
+  }
+  type;
+  title;
+  status;
+  detail;
+  constructor(problem) {
+    const title = problem.title ?? "Request failed";
+    super(problem.detail ? `${title}: ${problem.detail}` : title);
+    this.name = "ProblemError";
+    this.type = problem.type ?? "about:blank";
+    this.title = title;
+    this.status = problem.status ?? 0;
+    this.detail = problem.detail ?? null;
+  }
+};
+function isProblemType(problem, type) {
+  return problem.type === type;
 }
+var NO_WALLET_AVAILABLE = "urn:problem-type:thunder-bridge:no-wallet-available";
+var REQUEST_IN_FLIGHT = "urn:problem-type:thunder-bridge:request-in-flight";
+var IDEMPOTENCY_KEY_REUSED = "urn:problem-type:thunder-bridge:idempotency-key-reused";
+var PAYMENT_ALREADY_WATCHED = "urn:problem-type:thunder-bridge:payment-already-watched";
+var IdempotencyConflictError = class extends ProblemError {
+  conflict;
+  constructor(problem, conflict) {
+    super(problem);
+    this.name = "IdempotencyConflictError";
+    this.conflict = conflict;
+  }
+};
+var NoWalletAvailableError = class extends ProblemError {
+  wallets;
+  constructor(problem, wallets) {
+    super({ ...problem, type: NO_WALLET_AVAILABLE });
+    this.name = "NoWalletAvailableError";
+    this.wallets = wallets;
+  }
+};
 
 // src/currency.ts
 var ISO_4217_MINOR_UNITS = {
@@ -669,72 +572,770 @@ var ISO_4217_MINOR_UNITS = {
 function minorUnitsOf(currency) {
   const digits = ISO_4217_MINOR_UNITS[currency.toUpperCase()];
   if (digits === void 0) {
-    throw new Error(
+    throw new AmountError(
+      "unknown-currency",
       `${currency.toUpperCase()} is not a currency this knows the ISO 4217 minor unit of`
     );
   }
-  return digits;
+  return digits;
+}
+function minorScaleOf(currency) {
+  return 10 ** minorUnitsOf(currency);
+}
+
+// src/price.ts
+var MSAT_PER_BTC2 = 1e11;
+var BASIS_POINTS = 1e4;
+var DEFAULT_HOLD_SECS = 60;
+var DEFAULT_MIN_VENUES = 2;
+var DEFAULT_MAX_SPREAD_BPS = 200;
+var MILLIS = 1e3;
+function coinbase(baseUrl = "https://api.coinbase.com") {
+  return async (currency) => {
+    const asked = currency.toUpperCase();
+    const answer = await asJson(`${baseUrl}/v2/prices/BTC-${asked}/spot`, "coinbase");
+    const quoted = answer.data;
+    if (quoted?.currency !== asked) {
+      throw new Error(`coinbase quoted ${quoted?.currency} when asked for ${asked}`);
+    }
+    return asMinor(quoted.amount, "coinbase", asked);
+  };
+}
+function kraken(baseUrl = "https://api.kraken.com") {
+  return async (currency) => {
+    const asked = currency.toUpperCase();
+    const answer = await asJson(`${baseUrl}/0/public/Ticker?pair=XBT${asked}`, "kraken");
+    if (answer.error?.length) {
+      throw new Error(`kraken refused XBT${asked}: ${answer.error[0]}`);
+    }
+    const pairs = Object.values(answer.result ?? {});
+    if (pairs.length !== 1) {
+      throw new Error(`kraken answered ${pairs.length} pairs for XBT${asked}`);
+    }
+    return asMinor(pairs[0]?.c?.[0], "kraken", asked);
+  };
+}
+function bitstamp(baseUrl = "https://www.bitstamp.net") {
+  return async (currency) => {
+    const pair = `btc${currency.toLowerCase()}`;
+    const answer = await asJson(`${baseUrl}/api/v2/ticker/${pair}/`, "bitstamp");
+    if (Array.isArray(answer)) {
+      throw new Error(`bitstamp has no ${pair} pair`);
+    }
+    return asMinor(answer.last, "bitstamp", currency);
+  };
+}
+function coinmate(baseUrl = "https://coinmate.io") {
+  return async (currency) => {
+    const pair = `BTC_${currency.toUpperCase()}`;
+    const answer = await asJson(`${baseUrl}/api/ticker?currencyPair=${pair}`, "coinmate");
+    if (answer.error !== false) {
+      throw new Error(`coinmate refused ${pair}: ${answer.errorMessage ?? "no reason"}`);
+    }
+    return asMinor(answer.data?.last, "coinmate", currency);
+  };
+}
+function medianOf(tickers = [coinbase(), kraken(), bitstamp(), coinmate()], options = {}) {
+  const holdFor = (options.holdForSecs ?? DEFAULT_HOLD_SECS) * MILLIS;
+  const minVenues = options.minVenues ?? DEFAULT_MIN_VENUES;
+  const maxSpread = options.maxSpreadBps ?? DEFAULT_MAX_SPREAD_BPS;
+  const held = /* @__PURE__ */ new Map();
+  return async (currency) => {
+    const asked = currency.toUpperCase();
+    const remembered = held.get(asked);
+    if (remembered && Date.now() - remembered.at < holdFor) {
+      return remembered.price;
+    }
+    const answers = await Promise.allSettled(tickers.map((ticker) => ticker(asked)));
+    const quoted = answers.filter((answer) => answer.status === "fulfilled").map((answer) => answer.value).sort((one, other) => one - other);
+    if (quoted.length < minVenues) {
+      throw new Error(
+        `${quoted.length} of ${tickers.length} venues quoted ${asked}, ${minVenues} wanted: ${refusals(answers)}`
+      );
+    }
+    const spread2 = spreadBpsOf(quoted);
+    if (spread2 > maxSpread) {
+      throw new Error(
+        `venues disagree on ${asked} by ${Math.round(spread2)} bps, more than the ${maxSpread} allowed: ${quoted.join(", ")}`
+      );
+    }
+    const price = middleOf(quoted);
+    held.set(asked, { at: Date.now(), price });
+    return price;
+  };
+}
+function msatFor(amountMinor, priceMinorPerBtc, options = {}) {
+  if (!Number.isInteger(amountMinor) || amountMinor <= 0) {
+    throw new Error("amountMinor must be a whole number of minor units above zero");
+  }
+  if (!Number.isFinite(priceMinorPerBtc) || priceMinorPerBtc <= 0) {
+    throw new Error(`${priceMinorPerBtc} is not a usable price`);
+  }
+  const spreadBps = options.spreadBps ?? 0;
+  if (!Number.isInteger(spreadBps) || spreadBps < 0) {
+    throw new Error("spreadBps must be a whole number of basis points, none or more");
+  }
+  const wanted = BigInt(amountMinor) * BigInt(MSAT_PER_BTC2) * BigInt(BASIS_POINTS + spreadBps);
+  const per = BigInt(Math.round(priceMinorPerBtc)) * BigInt(BASIS_POINTS);
+  const msat2 = (wanted + per - 1n) / per;
+  if (msat2 > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`${amountMinor} at ${priceMinorPerBtc} is more millisatoshi than exist`);
+  }
+  return Number(msat2);
+}
+async function asJson(url, venue) {
+  const answer = await fetch(url, { headers: { accept: "application/json" } });
+  if (!answer.ok) {
+    throw new Error(`${venue} answered ${answer.status}`);
+  }
+  return answer.json();
+}
+function asMinor(quoted, venue, currency) {
+  const major2 = Number(quoted);
+  if (!Number.isFinite(major2) || major2 <= 0) {
+    throw new Error(`${venue} quoted ${String(quoted)} for ${currency.toUpperCase()}`);
+  }
+  return Math.round(major2 * minorScaleOf(currency));
+}
+function spreadBpsOf(sorted) {
+  const lowest = sorted[0] ?? 0;
+  const highest = sorted[sorted.length - 1] ?? 0;
+  return lowest === 0 ? Number.POSITIVE_INFINITY : (highest - lowest) / lowest * BASIS_POINTS;
+}
+function middleOf(sorted) {
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 1) {
+    return sorted[middle] ?? 0;
+  }
+  return Math.round(((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2);
+}
+function refusals(answers) {
+  return answers.filter((answer) => answer.status === "rejected").map(
+    (answer) => answer.reason instanceof Error ? answer.reason.message : String(answer.reason)
+  ).join("; ");
+}
+
+// src/amount.ts
+var MSAT_PER_SAT = 1e3;
+var MAX_SATS = Math.floor(Number.MAX_SAFE_INTEGER / MSAT_PER_SAT);
+function sats(whole) {
+  if (!Number.isInteger(whole) || whole < 1 || whole > MAX_SATS) {
+    throw new AmountError("not-whole-satoshi", `${whole} is not a payable count of satoshi`);
+  }
+  return whole * MSAT_PER_SAT;
+}
+function msat(exact) {
+  if (!Number.isSafeInteger(exact) || exact < 1) {
+    throw new AmountError(
+      "not-whole-millisatoshi",
+      `${exact} is not a payable count of millisatoshi`
+    );
+  }
+  return exact;
+}
+function fiat(major2, currency, options) {
+  const amountMinor = minorFrom(major2, currency);
+  const rate = options?.rate ?? medianOf();
+  return async () => {
+    const wanted = msatFor(amountMinor, await rate(currency), { spreadBps: options?.spreadBps });
+    return sats(Math.ceil(wanted / MSAT_PER_SAT));
+  };
+}
+async function amountNow(amount) {
+  return typeof amount === "function" ? msat(await amount()) : msat(amount);
+}
+function minorFrom(major2, currency) {
+  const digits = minorUnitsOf(currency);
+  if (typeof major2 === "number") {
+    return payable(Math.round(major2 * minorScaleOf(currency)), major2, currency);
+  }
+  const parsed = /^(\d+)(?:[.,](\d+))?$/.exec(major2.trim());
+  if (parsed === null) {
+    throw new AmountError(
+      "not-a-decimal",
+      `${major2} is not a decimal ${currency.toUpperCase()} amount`
+    );
+  }
+  const fraction = parsed[2] ?? "";
+  if (fraction.length > digits) {
+    throw new AmountError(
+      "too-precise",
+      `${major2} carries more decimals than ${currency.toUpperCase()} has, which is ${digits}`
+    );
+  }
+  return payable(Number(`${parsed[1]}${fraction.padEnd(digits, "0")}`), major2, currency);
+}
+function payable(minor, major2, currency) {
+  if (!Number.isSafeInteger(minor) || minor < 1) {
+    throw new AmountError(
+      "not-a-decimal",
+      `${major2} is not a ${currency.toUpperCase()} price this can charge`
+    );
+  }
+  return minor;
+}
+
+// ../core/ed25519.ts
+var ALGORITHM = { name: "Ed25519" };
+var SEED_BYTES = 32;
+var SIGNATURE_BYTES = 64;
+var PUBLIC_KEY_BYTES = 32;
+var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
+async function signingKeyFromSeed(seed) {
+  if (seed.length !== SEED_BYTES) {
+    throw new Error(`an ed25519 seed is ${SEED_BYTES} bytes`);
+  }
+  const wrapped = new Uint8Array(PKCS8_HEADER.length + SEED_BYTES);
+  wrapped.set(PKCS8_HEADER);
+  wrapped.set(seed, PKCS8_HEADER.length);
+  const key = await crypto.subtle.importKey("pkcs8", asBuffer(wrapped), ALGORITHM, true, ["sign"]);
+  const jwk = await crypto.subtle.exportKey("jwk", key);
+  return {
+    publicKeyHex: bytesToHex(fromBase64Url2(jwk.x ?? "")),
+    sign: async (payload) => bytesToHex(new Uint8Array(await crypto.subtle.sign(ALGORITHM, key, asBuffer(payload))))
+  };
+}
+async function verifyHex(publicKeyHex, signatureHex, payload) {
+  if (!isHex(publicKeyHex) || publicKeyHex.length !== PUBLIC_KEY_BYTES * 2) {
+    return false;
+  }
+  if (!isHex(signatureHex) || signatureHex.length !== SIGNATURE_BYTES * 2) {
+    return false;
+  }
+  try {
+    const key = await crypto.subtle.importKey(
+      "raw",
+      asBuffer(hexToBytes(publicKeyHex)),
+      ALGORITHM,
+      false,
+      ["verify"]
+    );
+    return await crypto.subtle.verify(
+      ALGORITHM,
+      key,
+      asBuffer(hexToBytes(signatureHex)),
+      asBuffer(payload)
+    );
+  } catch {
+    return false;
+  }
+}
+function fromBase64Url2(text3) {
+  const padded = text3.replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(padded + "=".repeat((4 - padded.length % 4) % 4));
+  const bytes = new Uint8Array(raw.length);
+  for (let at = 0; at < raw.length; at++) {
+    bytes[at] = raw.charCodeAt(at);
+  }
+  return bytes;
+}
+function asBuffer(bytes) {
+  return bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
+}
+
+// ../core/hmac.ts
+async function hmacHex(secret, payload) {
+  const raw = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    asBuffer2(raw),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const message = typeof payload === "string" ? new TextEncoder().encode(payload) : payload;
+  return bytesToHex(new Uint8Array(await crypto.subtle.sign("HMAC", key, asBuffer2(message))));
+}
+function equalInConstantTime(one, other) {
+  if (one.length !== other.length) {
+    return false;
+  }
+  let difference = 0;
+  for (let at = 0; at < one.length; at++) {
+    difference |= one.charCodeAt(at) ^ other.charCodeAt(at);
+  }
+  return difference === 0;
+}
+function asBuffer2(bytes) {
+  return bytes instanceof Uint8Array && bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
+}
+
+// ../core/caller.ts
+var KEY_HEADER = "x-client-key";
+var SIGNATURE_HEADER = "x-signature";
+var TIMESTAMP_HEADER = "x-timestamp";
+var PREFIX = "ed25519=";
+var SIGNING_LABEL = "request-signing";
+async function callerKey(secret) {
+  return await signingKeyFromSeed(hexToBytes(await hmacHex(secret, SIGNING_LABEL)));
+}
+function paymentNamedBy(caller, paymentHash) {
+  return sha256Hex(`${caller}.payment-id.${paymentHash}`);
+}
+async function signedAs(key, method, path, body) {
+  const timestamp = String(Math.floor(Date.now() / 1e3));
+  return {
+    [KEY_HEADER]: key.publicKeyHex,
+    [TIMESTAMP_HEADER]: timestamp,
+    [SIGNATURE_HEADER]: `${PREFIX}${await key.sign(spoken(timestamp, method, path, body))}`
+  };
+}
+function spoken(timestamp, method, path, body) {
+  return new TextEncoder().encode(
+    `${timestamp}.${method.toUpperCase()}.${path}.${sha256Hex(body)}`
+  );
+}
+
+// src/charge.ts
+async function priced(charge) {
+  const paidTo = typeof charge.paidTo === "string" ? [charge.paidTo] : [...charge.paidTo];
+  if (paidTo.length === 0) {
+    throw new Error("name at least one lightning address to pay");
+  }
+  return { paidTo, amountMsat: await amountNow(charge.amount) };
+}
+
+// ../core/url.ts
+var PRIVATE_SUFFIXES = ["localhost", "local", "internal", "lan", "arpa", "test", "invalid"];
+function publicHttps(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return false;
+  }
+  return url.protocol === "https:" && hostIsPublic(url.hostname.toLowerCase());
+}
+function sameOrigin(one, other) {
+  try {
+    return new URL(one).origin === new URL(other).origin;
+  } catch {
+    return false;
+  }
+}
+function publicAddress(literal) {
+  return literal.includes(":") ? ipv6IsGlobal(literal) : ipv4IsGlobal(literal);
+}
+function hostIsPublic(host) {
+  if (host.startsWith("[")) {
+    return publicAddress(host.slice(1, -1));
+  }
+  const name = host.replace(/\.$/, "");
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) {
+    return publicAddress(name);
+  }
+  const labels = name.split(".");
+  if (labels.length < 2 || labels.some((label) => label === "")) {
+    return false;
+  }
+  return !PRIVATE_SUFFIXES.includes(labels[labels.length - 1]);
+}
+function ipv4IsGlobal(literal) {
+  const parts = literal.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return false;
+  }
+  const [a, b] = parts;
+  if (a === 0 || a === 10 || a === 127 || a >= 240) {
+    return false;
+  }
+  if (a === 100 && b >= 64 && b < 128) {
+    return false;
+  }
+  if (a === 169 && b === 254) {
+    return false;
+  }
+  if (a === 172 && b >= 16 && b < 32) {
+    return false;
+  }
+  if (a === 192 && b === 168) {
+    return false;
+  }
+  return true;
+}
+function ipv6IsGlobal(literal) {
+  const groups = ipv6Groups(literal.toLowerCase());
+  if (groups.length !== 8 || groups.some(Number.isNaN)) {
+    return false;
+  }
+  const leading = groups.slice(0, 5).every((group) => group === 0);
+  if (leading && groups[5] === 0 && groups[6] === 0 && groups[7] <= 1) {
+    return false;
+  }
+  if (leading && groups[5] === 65535) {
+    const [high, low] = [groups[6], groups[7]];
+    return ipv4IsGlobal(`${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`);
+  }
+  const first = groups[0];
+  if ((first & 65024) === 64512) {
+    return false;
+  }
+  if ((first & 65472) === 65152) {
+    return false;
+  }
+  return true;
+}
+function ipv6Groups(address) {
+  const [head = "", tail] = address.split("::");
+  const left = head.split(":").filter((group) => group !== "");
+  const right = (tail ?? "").split(":").filter((group) => group !== "");
+  const gap = tail === void 0 ? [] : Array(8 - left.length - right.length).fill("0");
+  return [...left, ...gap, ...right].map((group) => parseInt(group, 16));
+}
+
+// ../core/outbound.ts
+var HTTP_TIMEOUT_MS = 15e3;
+var LOOKUP_TIMEOUT_MS = 5e3;
+var HOPS_FOLLOWED = 2;
+var REDIRECTS = [301, 302, 303, 307, 308];
+var KEEPS_THE_METHOD = [307, 308];
+var CREDENTIALS = ["authorization", "cookie", "proxy-authorization"];
+var BODY_LIMIT_BYTES = 262144;
+async function ask(send, url, sent = {}) {
+  const capped = AbortSignal.timeout(HTTP_TIMEOUT_MS);
+  const signal = sent.deadline ? AbortSignal.any([sent.deadline, capped]) : capped;
+  let target = url;
+  let carried = sent;
+  for (let hop = 0; hop <= HOPS_FOLLOWED; hop += 1) {
+    const at = await addressesToReach(target);
+    const response = await send(target, carried, signal, at);
+    if (!REDIRECTS.includes(response.status)) {
+      return await answerOf(response);
+    }
+    const location = response.headers.get("location");
+    if (location === null) {
+      throw new Error(`${target} answered ${response.status} without saying where to`);
+    }
+    await response.body?.cancel();
+    const next = new URL(location, target).toString();
+    carried = KEEPS_THE_METHOD.includes(response.status) ? carried : withoutBody(carried);
+    carried = sameOrigin(target, next) ? carried : withoutCredentials(carried);
+    target = next;
+  }
+  throw new Error(`${url} redirected more than ${HOPS_FOLLOWED} times`);
+}
+async function addressesToReach(url) {
+  if (!publicHttps(url)) {
+    throw new Error(`${url} is not a public https URL`);
+  }
+  const found = await resolved(url);
+  if (found.length === 0 || !found.every((one) => publicAddress(one.address))) {
+    throw new Error(`${url} resolves to an address we do not reach`);
+  }
+  return found;
+}
+async function resolved(url) {
+  const { lookup } = await import("dns/promises");
+  const { setTimeout: sleep } = await import("timers/promises");
+  const host = new URL(url).hostname.replace(/^\[|]$/g, "");
+  const found = await Promise.race([
+    lookup(host, { all: true, verbatim: true }).catch(() => []),
+    sleep(LOOKUP_TIMEOUT_MS, null, { ref: false })
+  ]);
+  return found ?? [];
+}
+async function answerOf(response) {
+  const { status, ok, headers } = response;
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return { status, ok, body: "", truncated: false, headers };
+  }
+  const read = [];
+  let bytes = 0;
+  while (bytes <= BODY_LIMIT_BYTES) {
+    const { done, value } = await reader.read();
+    if (done) {
+      return { status, ok, body: text(read), truncated: false, headers };
+    }
+    read.push(value);
+    bytes += value.length;
+  }
+  await reader.cancel();
+  return { status, ok, body: text(read), truncated: true, headers };
+}
+function withoutBody(sent) {
+  const headers = { ...sent.headers };
+  delete headers["content-type"];
+  return { ...sent, method: "GET", headers, body: void 0 };
+}
+function withoutCredentials(sent) {
+  const headers = { ...sent.headers };
+  for (const named of CREDENTIALS) {
+    delete headers[named];
+  }
+  return { ...sent, headers };
+}
+function text(chunks) {
+  const decoder = new TextDecoder();
+  let decoded2 = "";
+  for (const chunk of chunks) {
+    decoded2 += decoder.decode(chunk, { stream: true });
+  }
+  return decoded2 + decoder.decode();
+}
+
+// ../core/refusal.ts
+var WalletRefused = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+};
+var NoWalletAvailable = class extends Error {
+  wallets;
+  constructor(wallets) {
+    super(wallets.map((wallet) => `${wallet.address} ${wallet.reason}`).join(", "));
+    this.wallets = wallets;
+  }
+};
+
+// ../core/lnurl.ts
+var VERIFY_WITHOUT_PREIMAGE = ["zeuspay.com", "zeusnuts.com", "ecash.love"];
+var RESOLVE_TIMEOUT_MS = 3e4;
+var NAMES_ONE_ACCOUNT = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/;
+var MIN_PACE_SECS = 1;
+var MAX_PACE_SECS = 3600;
+var MIN_PER_SECOND = 0.01;
+var MAX_PER_SECOND = 100;
+async function resolve(send, addresses, amountMsat) {
+  const served = await firstThatServes(
+    addresses,
+    (address, deadline) => resolveAddress(send, address, amountMsat, deadline)
+  );
+  return served.won;
+}
+async function firstThatServes(addresses, attempt) {
+  const deadline = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
+  const refusals3 = [];
+  for (const address of addresses) {
+    if (deadline.aborted) {
+      break;
+    }
+    try {
+      return { won: await attempt(address, deadline), refusals: refusals3 };
+    } catch (refusal) {
+      if (!(refusal instanceof WalletRefused)) {
+        throw refusal;
+      }
+      console.warn(`wallet ${address} refused, ${refusal.reason}: ${refusal.message}`);
+      refusals3.push({ address, reason: refusal.reason });
+    }
+  }
+  throw new NoWalletAvailable(refusals3);
 }
-function minorScaleOf(currency) {
-  return 10 ** minorUnitsOf(currency);
+async function probe(send, address, amountMsat, deadline) {
+  const [user, domain] = splitAddress(address);
+  if (cannotReleaseAPreimage(domain)) {
+    throw new WalletRefused("cannot-prove-delivery", `${address} never releases a preimage`);
+  }
+  const pay = await answered(
+    send,
+    `https://${domain}/.well-known/lnurlp/${user}`,
+    deadline
+  );
+  if (pay.tag !== "payRequest" || !pay.callback) {
+    throw new WalletRefused("unreachable", `${address} answered with no payRequest`);
+  }
+  if (amountMsat < pay.minSendable || amountMsat > pay.maxSendable) {
+    throw new WalletRefused(
+      "amount-not-accepted",
+      `${address} takes [${pay.minSendable}, ${pay.maxSendable}] msat, not ${amountMsat}`
+    );
+  }
+  return { address, pay };
 }
-
-// ../core/ed25519.ts
-var ALGORITHM = { name: "Ed25519" };
-var SEED_BYTES = 32;
-var SIGNATURE_BYTES = 64;
-var PUBLIC_KEY_BYTES = 32;
-var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
-async function signingKeyFromSeed(seed) {
-  if (seed.length !== SEED_BYTES) {
-    throw new Error(`an ed25519 seed is ${SEED_BYTES} bytes`);
+async function resolveAddress(send, address, amountMsat, deadline) {
+  const { pay } = await probe(send, address, amountMsat, deadline);
+  const invoice = await answered(
+    send,
+    withAmount(pay.callback, amountMsat),
+    deadline
+  );
+  if (!invoice.pr) {
+    throw new WalletRefused("unreachable", `${address} returned no invoice`);
+  }
+  if (!invoice.verify || !publicHttps(invoice.verify)) {
+    throw new WalletRefused(
+      "cannot-prove-delivery",
+      `${address} publishes no usable LUD-21 verify URL`
+    );
+  }
+  const issued = decodeIssued(address, invoice.pr);
+  if (issued.amountMsat !== amountMsat) {
+    throw new WalletRefused(
+      "invoice-refused",
+      `${address} issued an invoice for ${issued.amountMsat} msat, not ${amountMsat}`
+    );
+  }
+  if (issued.descriptionHash !== sha256Hex(pay.metadata)) {
+    throw new WalletRefused(
+      "invoice-refused",
+      `${address} does not bind its invoice to the metadata it serves`
+    );
   }
-  const wrapped = new Uint8Array(PKCS8_HEADER.length + SEED_BYTES);
-  wrapped.set(PKCS8_HEADER);
-  wrapped.set(seed, PKCS8_HEADER.length);
-  const key = await crypto.subtle.importKey("pkcs8", asBuffer2(wrapped), ALGORITHM, true, ["sign"]);
-  const jwk = await crypto.subtle.exportKey("jwk", key);
   return {
-    publicKeyHex: bytesToHex(fromBase64Url2(jwk.x ?? "")),
-    sign: async (payload) => bytesToHex(new Uint8Array(await crypto.subtle.sign(ALGORITHM, key, asBuffer2(payload))))
+    address,
+    bolt11: invoice.pr,
+    verifyUrl: invoice.verify,
+    paymentHash: issued.paymentHash,
+    expiresAt: issued.expiresAt
   };
 }
-async function verifyHex(publicKeyHex, signatureHex, payload) {
-  if (!isHex(publicKeyHex) || publicKeyHex.length !== PUBLIC_KEY_BYTES * 2) {
-    return false;
+async function answered(send, url, deadline) {
+  try {
+    return await fetchJson(send, url, deadline);
+  } catch (cause) {
+    throw new WalletRefused("unreachable", String(cause));
   }
-  if (!isHex(signatureHex) || signatureHex.length !== SIGNATURE_BYTES * 2) {
-    return false;
+}
+function decodeIssued(address, bolt11) {
+  const { paymentHash, descriptionHash, amountMsat, expiresAt } = decodeInvoice(bolt11);
+  if (paymentHash === null || expiresAt === null) {
+    throw new WalletRefused("invoice-refused", `${address} issued an invoice we cannot decode`);
+  }
+  return { paymentHash, descriptionHash, amountMsat, expiresAt };
+}
+async function checkSettled(send, verifyUrl, paymentHash) {
+  const answer = await answeredJson(send, verifyUrl);
+  const asked = {
+    pace: paceAskedFor(answer.headers),
+    ceiling: ceilingAskedFor(answer.headers)
+  };
+  if (!answer.said.settled || !answer.said.preimage) {
+    return { preimage: null, ...asked };
+  }
+  if (!preimageMatchesHash(answer.said.preimage, paymentHash)) {
+    throw new Error(`verify returned a preimage that does not hash to ${paymentHash}`);
+  }
+  return { preimage: answer.said.preimage, ...asked };
+}
+function paceAskedFor(headers) {
+  const asked = /max-age\s*=\s*(\d+)/i.exec(headers.get("cache-control") ?? "");
+  if (!asked) {
+    return null;
+  }
+  return Math.min(Math.max(Number(asked[1]), MIN_PACE_SECS), MAX_PACE_SECS);
+}
+function ceilingAskedFor(headers) {
+  const asked = /^\s*(\d+)\s*(?:;\s*w\s*=\s*(\d+))?/i.exec(headers.get("ratelimit-limit") ?? "");
+  if (!asked) {
+    return null;
+  }
+  const perWindow = Number(asked[1]);
+  const window = asked[2] === void 0 ? 1 : Number(asked[2]);
+  if (perWindow === 0 || window === 0) {
+    return null;
+  }
+  return Math.min(Math.max(perWindow / window, MIN_PER_SECOND), MAX_PER_SECOND);
+}
+function cannotReleaseAPreimage(host) {
+  const lowered = host.toLowerCase();
+  return VERIFY_WITHOUT_PREIMAGE.some(
+    (known) => lowered === known || lowered.endsWith(`.${known}`)
+  );
+}
+function withAmount(callback, amountMsat) {
+  const separator = callback.includes("?") ? "&" : "?";
+  return `${callback}${separator}amount=${amountMsat}`;
+}
+function splitAddress(address) {
+  const [user, domain, ...rest] = address.split("@");
+  if (!user || !domain || rest.length > 0 || !NAMES_ONE_ACCOUNT.test(user) || !isNothingButAHost(domain) || !publicHttps(`https://${domain}/`)) {
+    throw new WalletRefused("address-unusable", `${address} is not a usable lightning address`);
   }
+  return [user, domain];
+}
+function isNothingButAHost(domain) {
   try {
-    const key = await crypto.subtle.importKey(
-      "raw",
-      asBuffer2(hexToBytes(publicKeyHex)),
-      ALGORITHM,
-      false,
-      ["verify"]
-    );
-    return await crypto.subtle.verify(
-      ALGORITHM,
-      key,
-      asBuffer2(hexToBytes(signatureHex)),
-      asBuffer2(payload)
-    );
+    const parsed = new URL(`https://${domain}/`);
+    return parsed.host === domain.toLowerCase() && parsed.pathname === "/" && parsed.search === "" && parsed.hash === "";
   } catch {
     return false;
   }
 }
-function fromBase64Url2(text2) {
-  const padded = text2.replace(/-/g, "+").replace(/_/g, "/");
-  const raw = atob(padded + "=".repeat((4 - padded.length % 4) % 4));
-  const bytes = new Uint8Array(raw.length);
-  for (let at = 0; at < raw.length; at++) {
-    bytes[at] = raw.charCodeAt(at);
+async function fetchJson(send, url, deadline) {
+  return (await answeredJson(send, url, deadline)).said;
+}
+async function answeredJson(send, url, deadline) {
+  const answer = await ask(send, url, { headers: { accept: "application/json" }, deadline });
+  if (!answer.ok) {
+    throw new Error(`${url} answered ${answer.status}`);
   }
-  return bytes;
+  if (answer.truncated) {
+    throw new Error(`${url} answered with more than the ${BODY_LIMIT_BYTES} bytes we read`);
+  }
+  return { said: JSON.parse(answer.body), headers: answer.headers };
 }
-function asBuffer2(bytes) {
-  return bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
+
+// ../core/pinned.ts
+var HTTPS_PORT = 443;
+var CARRIES_NO_BODY = [204, 205, 304];
+var pinnedToTheAddressWeVerified = async (url, sent, signal, at) => {
+  const asked = new URL(url);
+  const first = at[0];
+  if (first === void 0) {
+    throw new Error(`${url} resolved to nothing worth connecting to`);
+  }
+  const { request } = await import("https");
+  const { Readable } = await import("stream");
+  return new Promise((settle, fail) => {
+    if (signal.aborted) {
+      fail(signal.reason);
+      return;
+    }
+    const call = request(reaching(asked, sent, at, first), (answer) => {
+      const status = answer.statusCode ?? 502;
+      settle(
+        new Response(
+          CARRIES_NO_BODY.includes(status) ? null : Readable.toWeb(answer),
+          { status, headers: headersOf(answer.headers) }
+        )
+      );
+    });
+    const give = () => call.destroy(new Error(`${url} took longer than allowed`));
+    signal.addEventListener("abort", give, { once: true });
+    call.on("close", () => signal.removeEventListener("abort", give));
+    call.on("error", fail);
+    if (sent.body !== void 0) {
+      call.write(sent.body);
+    }
+    call.end();
+  });
+};
+function reaching(asked, sent, at, first) {
+  return {
+    host: asked.hostname,
+    servername: asked.hostname,
+    port: asked.port === "" ? HTTPS_PORT : Number(asked.port),
+    path: `${asked.pathname}${asked.search}`,
+    method: sent.method ?? "GET",
+    headers: { ...sent.headers, host: asked.host },
+    agent: false,
+    lookup: (_name, options, done) => {
+      if (options.all === true) {
+        done(
+          null,
+          at.map((one) => ({ ...one }))
+        );
+      } else {
+        done(null, first.address, first.family);
+      }
+    }
+  };
+}
+function headersOf(raw) {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(raw)) {
+    if (Array.isArray(value)) {
+      for (const one of value) {
+        headers.append(name, one);
+      }
+    } else if (value !== void 0) {
+      headers.set(name, value);
+    }
+  }
+  return headers;
 }
 
 // src/wire.ts
@@ -747,19 +1348,19 @@ var REASONS = /* @__PURE__ */ new Set([
   "cannot-prove-delivery",
   "invoice-refused"
 ]);
-function createRequestBody(params, trigger, replay) {
+function createRequestBody(priced2, webhookUrl, trigger, replay) {
   return JSON.stringify({
-    ln_addresses: params.lnAddresses,
-    incoming_amount: toAmount(params.amountMsat),
-    webhook: params.webhookUrl ? { url: params.webhookUrl } : void 0,
+    ln_addresses: priced2.paidTo,
+    incoming_amount: toAmount(priced2.amountMsat),
+    webhook: webhookUrl ? { url: webhookUrl } : void 0,
     trigger: trigger ?? void 0,
     replay
   });
 }
-function quoteRequestBody(params) {
+function quoteRequestBody(priced2) {
   return JSON.stringify({
-    ln_addresses: params.lnAddresses,
-    amount: toAmount(params.amountMsat)
+    ln_addresses: priced2.paidTo,
+    amount: toAmount(priced2.amountMsat)
   });
 }
 function quoteFromWire(body) {
@@ -767,12 +1368,12 @@ function quoteFromWire(body) {
   if (wire === null) {
     return null;
   }
-  const lnAddress = text(wire["ln_address"]);
+  const lnAddress = text2(wire["ln_address"]);
   const amountMsat = msatFrom(wire["amount"], 1);
   const feeMsat = msatFrom(wire["fee"], 0);
   const minMsat = msatFrom(wire["min_amount"], 0);
   const maxMsat = msatFrom(wire["max_amount"], 0);
-  const metadata = text(wire["metadata"]);
+  const metadata = text2(wire["metadata"]);
   const refusals3 = refusalsFrom(wire["refusals"]);
   if (lnAddress === null || amountMsat === null || feeMsat === null) {
     return null;
@@ -787,57 +1388,66 @@ function paymentFromWire(body) {
   if (wire === null) {
     return null;
   }
-  const id = text(wire["id"]);
-  const lnAddress = text(wire["ln_address"]);
-  const bolt11 = text(wire["bolt11"]);
-  const paymentHash = text(wire["payment_hash"]);
-  const verifyUrl = text(wire["verify_url"]);
-  const amountMsat = msatFrom(wire["incoming_amount"], 1);
+  const id = text2(wire["id"]);
+  const paymentHash = text2(wire["payment_hash"]);
+  const verifyUrl = text2(wire["verify_url"]);
   const expiresAt = secondsFrom(wire["expires_at"]);
   const createdAt = secondsFrom(wire["created_at"]);
   const status = wire["status"];
   const preimage = wire["preimage"] ?? null;
-  if (id === null || lnAddress === null || bolt11 === null) {
-    return null;
-  }
-  if (paymentHash === null || verifyUrl === null) {
+  const sealed = wire["sealed"] ?? null;
+  if (id === null || paymentHash === null || verifyUrl === null) {
     return null;
   }
-  if (amountMsat === null || expiresAt === null || createdAt === null) {
+  if (expiresAt === null || createdAt === null || !isStatus(status)) {
     return null;
   }
-  if (!isStatus(status)) {
+  if (preimage !== null && typeof preimage !== "string") {
     return null;
   }
-  if (preimage !== null && typeof preimage !== "string") {
+  if (sealed !== null && typeof sealed !== "string") {
     return null;
   }
-  return {
+  const reported = {
     id,
-    lnAddress,
-    amountMsat,
     status,
     paymentHash,
-    bolt11,
+    verifyUrl,
     preimage,
     expiresAt,
     createdAt,
-    verifyUrl
+    sealed
   };
+  const lnAddress = text2(wire["ln_address"]);
+  const amountMsat = wire["incoming_amount"] === void 0 ? null : msatFrom(wire["incoming_amount"], 1);
+  const bolt11 = text2(wire["bolt11"]);
+  if (lnAddress !== null && amountMsat !== null && bolt11 !== null) {
+    return { ...reported, kind: "minted", lnAddress, amountMsat, bolt11 };
+  }
+  if (lnAddress === null && amountMsat === null && bolt11 === null) {
+    return { ...reported, kind: "watched", lnAddress: null, amountMsat: null, bolt11: null };
+  }
+  return null;
+}
+function mintedFromWire(body) {
+  const payment = paymentFromWire(body);
+  return payment !== null && payment.kind === "minted" ? payment : null;
 }
-function watchRequestBody(params, trigger) {
-  const expiresAt = new Date(params.expiresAt * 1e3);
+function watchRequestBody(handover, trigger) {
+  const expiresAt = new Date(handover.expiresAt * 1e3);
   if (Number.isNaN(expiresAt.getTime())) {
-    throw new TypeError(`expiresAt must be a usable unix time in seconds, got ${params.expiresAt}`);
+    throw new TypeError(
+      `expiresAt must be a usable unix time in seconds, got ${handover.expiresAt}`
+    );
   }
   return JSON.stringify({
-    payment_hash: params.paymentHash,
-    verify_url: params.verifyUrl,
+    payment_hash: handover.paymentHash,
+    verify_url: handover.verifyUrl,
     expires_at: expiresAt.toISOString(),
     trigger: trigger ?? void 0,
-    replay: params.replay,
-    sealed: params.sealed,
-    webhook: params.webhookUrl ? { url: params.webhookUrl } : void 0
+    replay: handover.replay,
+    sealed: handover.sealed,
+    webhook: handover.webhookUrl ? { url: handover.webhookUrl } : void 0
   });
 }
 function settlementFromWire(body) {
@@ -845,8 +1455,8 @@ function settlementFromWire(body) {
   if (wire === null) {
     return null;
   }
-  const id = text(wire["id"]);
-  const paymentHash = text(wire["payment_hash"]);
+  const id = text2(wire["id"]);
+  const paymentHash = text2(wire["payment_hash"]);
   const settledAt = secondsFrom(wire["settled_at"]);
   const status = wire["status"];
   const preimage = wire["preimage"] ?? null;
@@ -858,66 +1468,20 @@ function settlementFromWire(body) {
   }
   return { id, status, paymentHash, preimage, settledAt };
 }
-function triggerEventFromWire(body) {
-  const wire = asObject(body);
-  if (wire === null) {
-    return null;
-  }
-  const id = text(wire["id"]);
-  const paymentHash = text(wire["payment_hash"]);
-  const verifyUrl = text(wire["verify_url"]);
-  const expiresAt = secondsFrom(wire["expires_at"]);
-  const createdAt = secondsFrom(wire["created_at"]);
-  const status = wire["status"];
-  const preimage = wire["preimage"] ?? null;
-  const sealed = wire["sealed"] ?? null;
-  if (id === null || paymentHash === null || verifyUrl === null) {
-    return null;
-  }
-  if (expiresAt === null || createdAt === null || !isStatus(status)) {
-    return null;
-  }
-  if (preimage !== null && typeof preimage !== "string") {
-    return null;
-  }
-  if (sealed !== null && typeof sealed !== "string") {
-    return null;
-  }
-  return {
-    id,
-    kind: kindOf(wire),
-    paymentHash,
-    verifyUrl,
-    status,
-    preimage,
-    expiresAt,
-    createdAt,
-    sealed,
-    lnAddress: text(wire["ln_address"]),
-    amountMsat: wire["incoming_amount"] === void 0 ? null : msatFrom(wire["incoming_amount"], 1)
-  };
-}
 function socketTicketFromWire(body) {
   const wire = asObject(body);
   if (wire === null) {
     return null;
   }
-  const ticket = text(wire["ticket"]);
+  const ticket = text2(wire["ticket"]);
   const expiresAt = secondsFrom(wire["expires_at"]);
   if (ticket === null || expiresAt === null) {
     return null;
   }
   return { ticket, expiresAt };
 }
-function kindOf(wire) {
-  const said = wire["kind"];
-  if (said === "minted" || said === "watched") {
-    return said;
-  }
-  return text(wire["ln_address"]) === null ? "watched" : "minted";
-}
-function toAmount(msat) {
-  return { value: String(msat), asset_code: ASSET_CODE, asset_scale: ASSET_SCALE };
+function toAmount(msat2) {
+  return { value: String(msat2), asset_code: ASSET_CODE, asset_scale: ASSET_SCALE };
 }
 function asObject(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -925,7 +1489,7 @@ function asObject(value) {
   }
   return value;
 }
-function text(value) {
+function text2(value) {
   return typeof value === "string" ? value : null;
 }
 function msatFrom(value, least) {
@@ -940,8 +1504,8 @@ function msatFrom(value, least) {
   if (typeof digits !== "string" || !/^[0-9]+$/.test(digits)) {
     return null;
   }
-  const msat = Number(digits);
-  return Number.isSafeInteger(msat) && msat >= least ? msat : null;
+  const msat2 = Number(digits);
+  return Number.isSafeInteger(msat2) && msat2 >= least ? msat2 : null;
 }
 function refusalsFrom(value) {
   if (!Array.isArray(value)) {
@@ -950,7 +1514,7 @@ function refusalsFrom(value) {
   const refusals3 = [];
   for (const entry of value) {
     const failure = asObject(entry);
-    const address = failure === null ? null : text(failure["address"]);
+    const address = failure === null ? null : text2(failure["address"]);
     const reason = failure?.["reason"];
     if (address === null || typeof reason !== "string" || !REASONS.has(reason)) {
       return null;
@@ -971,118 +1535,67 @@ function isStatus(value) {
 }
 
 // src/webhook.ts
-var SIGNATURE_HEADER = "x-signature";
-var TIMESTAMP_HEADER = "x-timestamp";
+var SIGNATURE_HEADER2 = "x-signature";
+var TIMESTAMP_HEADER2 = "x-timestamp";
 var GATEWAY_KEY_PREFIX = "ed25519=";
 var DEFAULT_TOLERANCE_SECS = 300;
 var CHALLENGE = "webhook-challenge";
 var VERIFY_CHALLENGE = "verify-challenge";
-async function verifyWebhookSignature(body, signature, credential, timestamp, options = {}) {
-  if (!recent(timestamp, options.toleranceSecs ?? DEFAULT_TOLERANCE_SECS)) {
-    return false;
-  }
-  if (!signature.startsWith(GATEWAY_KEY_PREFIX)) {
-    return false;
-  }
-  return await verifyHex(
-    credential.publicKey.toLowerCase(),
-    signature.slice(GATEWAY_KEY_PREFIX.length).toLowerCase(),
-    signed(timestamp, body)
-  );
+async function readPayment(request, credential, options = {}) {
+  const body = await believable(request, credential, options);
+  return body === null ? null : decoded(body, paymentFromWire);
 }
-async function parseWebhook(body, signature, credential, timestamp, options = {}) {
-  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) {
-    return null;
-  }
-  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
-  try {
-    return paymentFromWire(JSON.parse(text2));
-  } catch {
-    return null;
-  }
+async function readSettlement(request, credential, options = {}) {
+  const body = await believable(request, credential, options);
+  return body === null ? null : decoded(body, settlementFromWire);
 }
-async function parseWebhookRequest(request, credential, options = {}) {
-  const signature = request.headers.get(SIGNATURE_HEADER);
-  const timestamp = request.headers.get(TIMESTAMP_HEADER);
-  if (signature === null || timestamp === null) {
-    return null;
-  }
-  return parseWebhook(await request.text(), signature, credential, timestamp, options);
+async function answerWebhookChallenge(request, credential, options = {}) {
+  const body = await believable(request, credential, options);
+  const nonce = body === null ? null : nonceOf(body, CHALLENGE);
+  return nonce === null ? null : answered2(nonce);
 }
-async function parseWatchedWebhook(body, signature, credential, timestamp, options = {}) {
-  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) {
-    return null;
-  }
-  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
-  try {
-    return triggerEventFromWire(JSON.parse(text2));
-  } catch {
+async function answerVerifyChallenge(request) {
+  if (request.method !== "POST") {
     return null;
   }
+  const nonce = nonceOf(await request.clone().text(), VERIFY_CHALLENGE);
+  return nonce === null ? null : answered2(nonce);
 }
-async function parseWatchedWebhookRequest(request, credential, options = {}) {
-  const signature = request.headers.get(SIGNATURE_HEADER);
-  const timestamp = request.headers.get(TIMESTAMP_HEADER);
+async function believable(request, credential, options) {
+  const signature = request.headers.get(SIGNATURE_HEADER2);
+  const timestamp = request.headers.get(TIMESTAMP_HEADER2);
   if (signature === null || timestamp === null) {
     return null;
   }
-  return parseWatchedWebhook(await request.text(), signature, credential, timestamp, options);
-}
-async function parseSettlement(body, signature, credential, timestamp, options = {}) {
-  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) {
-    return null;
-  }
-  try {
-    return settlementFromWire(JSON.parse(textOf(body)));
-  } catch {
-    return null;
-  }
-}
-async function parseSettlementRequest(request, credential, options = {}) {
-  const signature = request.headers.get(SIGNATURE_HEADER);
-  const timestamp = request.headers.get(TIMESTAMP_HEADER);
-  if (signature === null || timestamp === null) {
+  if (!recent(timestamp, options.toleranceSecs ?? DEFAULT_TOLERANCE_SECS)) {
     return null;
   }
-  return await parseSettlement(await request.text(), signature, credential, timestamp, options);
-}
-function isProvablySettled(settled) {
-  if (settled.status !== "paid" || settled.preimage === null) {
-    return false;
-  }
-  return preimageMatchesHash(settled.preimage, settled.paymentHash);
-}
-async function answerWebhookChallenge(body, signature, credential, timestamp, options = {}) {
-  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) {
+  if (!signature.startsWith(GATEWAY_KEY_PREFIX)) {
     return null;
   }
-  const nonce = challenged(typeof body === "string" ? body : new TextDecoder().decode(body));
-  return nonce === null ? null : JSON.stringify({ nonce });
+  const body = await request.clone().text();
+  const signed = await verifyHex(
+    credential.publicKey.toLowerCase(),
+    signature.slice(GATEWAY_KEY_PREFIX.length).toLowerCase(),
+    stamped(timestamp, body)
+  );
+  return signed ? body : null;
 }
-async function answerWebhookChallengeRequest(request, credential, options = {}) {
-  const signature = request.headers.get(SIGNATURE_HEADER);
-  const timestamp = request.headers.get(TIMESTAMP_HEADER);
-  if (signature === null || timestamp === null) {
+function decoded(body, from) {
+  try {
+    return from(JSON.parse(body));
+  } catch {
     return null;
   }
-  const answer = await answerWebhookChallenge(
-    await request.clone().text(),
-    signature,
-    credential,
-    timestamp,
-    options
-  );
-  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
-}
-function textOf(body) {
-  return typeof body === "string" ? body : new TextDecoder().decode(body);
 }
-function challenged(text2) {
-  return nonceOf(text2, CHALLENGE);
+function answered2(nonce) {
+  return new Response(JSON.stringify({ nonce }), {
+    headers: { "content-type": "application/json" }
+  });
 }
-function nonceOf(text2, type) {
+function nonceOf(text3, type) {
   try {
-    const said = JSON.parse(text2);
+    const said = JSON.parse(text3);
     if (said["type"] !== type || typeof said["nonce"] !== "string") {
       return null;
     }
@@ -1091,17 +1604,6 @@ function nonceOf(text2, type) {
     return null;
   }
 }
-function answerVerifyChallenge(body) {
-  const nonce = nonceOf(body, VERIFY_CHALLENGE);
-  return nonce === null ? null : JSON.stringify({ nonce });
-}
-async function answerVerifyChallengeRequest(request) {
-  if (request.method !== "POST") {
-    return null;
-  }
-  const answer = answerVerifyChallenge(await request.clone().text());
-  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
-}
 function recent(timestamp, toleranceSecs) {
   const sent = Number(timestamp);
   if (!Number.isFinite(sent)) {
@@ -1109,14 +1611,8 @@ function recent(timestamp, toleranceSecs) {
   }
   return Math.abs(Math.floor(Date.now() / 1e3) - sent) <= toleranceSecs;
 }
-function signed(timestamp, body) {
-  const encoder = new TextEncoder();
-  const stamp = encoder.encode(`${timestamp}.`);
-  const rest = typeof body === "string" ? encoder.encode(body) : new Uint8Array(body);
-  const payload = new Uint8Array(stamp.length + rest.length);
-  payload.set(stamp);
-  payload.set(rest, stamp.length);
-  return payload;
+function stamped(timestamp, body) {
+  return new TextEncoder().encode(`${timestamp}.${body}`);
 }
 
 // src/bank.ts
@@ -1125,10 +1621,10 @@ var DEFAULT_LOOK_BACK_SECS = 7 * 24 * 60 * 60;
 var DEFAULT_POLL_EVERY_SECS = 30;
 var IBAN = /^[A-Z]{2}[0-9]{2}[0-9A-Z]{8,30}$/;
 var FORBIDDEN_IN_SPD = "*";
-async function bankTransfer(params) {
+async function bankTransfer(gateway, params) {
   const currency = params.currency ?? DEFAULT_CURRENCY;
   refuseUnusable(params, currency);
-  await refuseAnOpenGateway(params);
+  await refuseAnOpenGateway(gateway, params);
   const spd = shortPaymentDescriptor(params, currency);
   const subject = subjectOf(params.reference, params.amountMinor, currency);
   const polling = new URL(params.verifyUrl);
@@ -1137,7 +1633,7 @@ async function bankTransfer(params) {
   polling.searchParams.set("cc", currency);
   polling.searchParams.set("sig", await hmacHex(params.secret, `verify|${subject}`));
   const verifyUrl = polling.toString();
-  const watched = await params.gateway.watchPayment({
+  const watched = await gateway.watch({
     paymentHash: hashOf(await hmacHex(params.secret, `preimage|${subject}`)),
     verifyUrl,
     expiresAt: params.expiresAt,
@@ -1153,7 +1649,7 @@ function bankVerifyEndpoint(config) {
     "cache-control": `max-age=${config.pollEverySecs ?? DEFAULT_POLL_EVERY_SECS}`
   };
   return async (request) => {
-    const consented = await answerVerifyChallengeRequest(request);
+    const consented = await answerVerifyChallenge(request);
     if (consented !== null) {
       return consented;
     }
@@ -1214,11 +1710,11 @@ function shortPaymentDescriptor(params, currency) {
 function major(amountMinor, currency) {
   return (amountMinor / minorScaleOf(currency)).toFixed(minorUnitsOf(currency));
 }
-async function refuseAnOpenGateway(params) {
+async function refuseAnOpenGateway(gateway, params) {
   if (params.allowPublicGateway === true) {
     return;
   }
-  if (await params.gateway.refusesStrangers()) {
+  if (await gateway.refusesStrangers()) {
     return;
   }
   throw new Error(
@@ -1242,124 +1738,240 @@ function refuseUnusable(params, currency) {
     throw new Error("a variable symbol is up to ten digits");
   }
 }
-function unixNow() {
-  return Math.floor(Date.now() / 1e3);
+function unixNow() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// src/qr.ts
+var import_uqr = require("uqr");
+var SAFE_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$|^rgba?\([\d.,%/\s]+\)$|^[a-z]+$/i;
+function toLightningUri(destination) {
+  const scanned = isLnAddress(destination) ? destination : destination.toUpperCase();
+  return `LIGHTNING:${scanned}`;
+}
+function invoiceToSvg(destination, options) {
+  return svgOf(toLightningUri(destination), options);
+}
+function svgOf(scanned, options) {
+  const size = options?.size ?? 256;
+  const color = options?.color ?? "#000";
+  if (!SAFE_COLOR.test(color)) {
+    throw new Error(`Invalid color: ${color}`);
+  }
+  return renderSvg(scanned, size, color);
+}
+function isLnAddress(destination) {
+  const at = destination.indexOf("@");
+  return at > 0 && destination.slice(at + 1).includes(".");
+}
+function renderSvg(content, size, color) {
+  const { data } = (0, import_uqr.encode)(content);
+  const modules = data.length;
+  const cellSize = size / modules;
+  let path = "";
+  for (let y = 0; y < modules; y++) {
+    for (let x = 0; x < modules; x++) {
+      if (data[y][x]) {
+        path += `M${x * cellSize},${y * cellSize}h${cellSize}v${cellSize}h-${cellSize}z`;
+      }
+    }
+  }
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}">`,
+    `<rect width="100%" height="100%" fill="white"/>`,
+    `<path d="${path}" fill="${color}"/>`,
+    `</svg>`
+  ].join("");
+}
+
+// src/relay.ts
+var DEFAULT_POLL_EVERY_SECS2 = 5;
+var WALLET = "w";
+function lightningVerifyEndpoint(config) {
+  const paced = {
+    "cache-control": `max-age=${config.pollEverySecs ?? DEFAULT_POLL_EVERY_SECS2}`
+  };
+  return async (request) => {
+    const consented = await answerVerifyChallenge(request);
+    if (consented !== null) {
+      return consented;
+    }
+    const sealed = new URL(request.url).searchParams.get(WALLET);
+    if (sealed === null) {
+      return Response.json({ settled: false }, { status: 400 });
+    }
+    const opened = await unseal(config.secret, sealed);
+    if (opened === null) {
+      return Response.json({ settled: false }, { status: 403 });
+    }
+    const wallet = JSON.parse(opened);
+    const asked = await checkSettled(
+      config.send ?? pinnedToTheAddressWeVerified,
+      wallet.url,
+      wallet.hash
+    ).catch(() => null);
+    if (asked === null) {
+      return Response.json({ settled: false }, { status: 502 });
+    }
+    return Response.json(
+      { settled: asked.preimage !== null, preimage: asked.preimage },
+      { headers: paced }
+    );
+  };
+}
+async function relayedVerifyUrl(endpoint, wallet, secret) {
+  const relayed = new URL(endpoint);
+  relayed.searchParams.set(WALLET, await seal(secret, JSON.stringify(wallet)));
+  return relayed.toString();
 }
 
-// ../core/caller.ts
-var KEY_HEADER = "x-client-key";
-var SIGNATURE_HEADER2 = "x-signature";
-var TIMESTAMP_HEADER2 = "x-timestamp";
-var PREFIX = "ed25519=";
-var SIGNING_LABEL = "request-signing";
-async function callerKey(secret) {
-  return await signingKeyFromSeed(hexToBytes(await hmacHex(secret, SIGNING_LABEL)));
+// src/rail.ts
+var BANK = "bank";
+var LIGHTNING = "lightning";
+function bankRail(gateway, config) {
+  return async (order) => {
+    const expiresAt = config.expiresAt(order);
+    const transfer = await bankTransfer(gateway, {
+      secret: config.secret,
+      iban: config.iban,
+      verifyUrl: config.verifyUrl,
+      reference: order.reference,
+      amountMinor: order.amountMinor,
+      currency: order.currency,
+      expiresAt,
+      trigger: config.trigger,
+      replay: config.replay,
+      sealed: await config.sealed?.(order),
+      variableSymbol: config.variableSymbol?.(order),
+      webhookUrl: config.webhookUrl,
+      allowPublicGateway: config.allowPublicGateway
+    });
+    return {
+      id: transfer.id,
+      rail: config.name ?? BANK,
+      scan: transfer.spd,
+      qr: transfer.spd,
+      expiresAt
+    };
+  };
 }
-function paymentNamedBy(caller, paymentHash) {
-  return sha256Hex(`${caller}.payment-id.${paymentHash}`);
+function lightningRail(gateway, config) {
+  return async (order) => {
+    const payment = await gateway.mint(
+      {
+        paidTo: config.paidTo,
+        amount: await msatForOrder(order, config.amount, config.rate),
+        webhookUrl: config.webhookUrl
+      },
+      {
+        idempotencyKey: config.idempotencyKey?.(order),
+        trigger: config.trigger,
+        replay: config.replay
+      }
+    );
+    return {
+      id: payment.id,
+      rail: config.name ?? LIGHTNING,
+      scan: payment.bolt11,
+      qr: toLightningUri(payment.bolt11),
+      expiresAt: payment.expiresAt
+    };
+  };
 }
-async function signedAs(key, method, path, body) {
-  const timestamp = String(Math.floor(Date.now() / 1e3));
-  return {
-    [KEY_HEADER]: key.publicKeyHex,
-    [TIMESTAMP_HEADER2]: timestamp,
-    [SIGNATURE_HEADER2]: `${PREFIX}${await key.sign(spoken(timestamp, method, path, body))}`
+function blindLightningRail(gateway, config) {
+  return async (order) => {
+    const resolved2 = await invoiceFrom(
+      config.paidTo,
+      await msatForOrder(order, config.amount, config.rate),
+      config.send
+    );
+    const relay = config.relayThrough;
+    const watched = await gateway.watch({
+      paymentHash: resolved2.paymentHash,
+      verifyUrl: relay ? await relayedVerifyUrl(
+        relay.endpoint,
+        { url: resolved2.verifyUrl, hash: resolved2.paymentHash },
+        relay.secret
+      ) : resolved2.verifyUrl,
+      expiresAt: resolved2.expiresAt,
+      trigger: config.trigger,
+      replay: config.replay,
+      sealed: await config.sealed?.(order),
+      webhookUrl: config.webhookUrl
+    });
+    return {
+      id: watched.id,
+      rail: config.name ?? LIGHTNING,
+      scan: resolved2.bolt11,
+      qr: toLightningUri(resolved2.bolt11),
+      expiresAt: resolved2.expiresAt
+    };
   };
 }
-function spoken(timestamp, method, path, body) {
-  return new TextEncoder().encode(
-    `${timestamp}.${method.toUpperCase()}.${path}.${sha256Hex(body)}`
-  );
+async function invoiceFrom(paidTo, amount, send = pinnedToTheAddressWeVerified) {
+  const addresses = typeof paidTo === "string" ? [paidTo] : paidTo;
+  try {
+    return await resolve(send, addresses, await amountNow(amount));
+  } catch (refused) {
+    if (refused instanceof NoWalletAvailable) {
+      throw new NoWalletAvailableError({ title: refused.message }, refused.wallets);
+    }
+    throw refused;
+  }
 }
-
-// src/errors.ts
-var GatewayCheatError = class extends Error {
-  code;
-  paymentId;
-  constructor(code, paymentId) {
-    super(`gateway verification failed: ${code}`);
-    this.name = "GatewayCheatError";
-    this.code = code;
-    this.paymentId = paymentId;
+async function msatForOrder(order, amount, rate) {
+  if (amount !== void 0) {
+    return await amountNow(amount(order));
   }
-};
-var WrapRefusedError = class extends Error {
-  code;
-  constructor(code, detail) {
-    super(`wrapped invoice refused: ${code}, ${detail}`);
-    this.name = "WrapRefusedError";
-    this.code = code;
+  return msat(msatFor(order.amountMinor, await (rate ?? medianOf())(order.currency)));
+}
+var Rails = class {
+  constructor(gateway) {
+    this.gateway = gateway;
   }
-};
-var UnverifiedRecipientError = class extends Error {
-  lnAddress;
-  paymentId;
-  constructor(lnAddress, paymentId, cause) {
-    super(`could not reach ${lnAddress} to verify the invoice: ${String(cause)}`);
-    this.name = "UnverifiedRecipientError";
-    this.lnAddress = lnAddress;
-    this.paymentId = paymentId;
+  gateway;
+  /** Lightning, with the gateway minting against a priority list of addresses */
+  lightning(config) {
+    return lightningRail(this.gateway, config);
   }
-};
-var ProblemError = class extends Error {
-  type;
-  title;
-  status;
-  detail;
-  constructor(problem) {
-    const title = problem.title ?? "Request failed";
-    super(problem.detail ? `${title}: ${problem.detail}` : title);
-    this.name = "ProblemError";
-    this.type = problem.type ?? "about:blank";
-    this.title = title;
-    this.status = problem.status ?? 0;
-    this.detail = problem.detail ?? null;
+  /**
+   * Lightning, with the invoice resolved here so the gateway is told neither the
+   * address nor the amount
+   */
+  blindLightning(config) {
+    return blindLightningRail(this.gateway, config);
   }
-};
-function isProblemType(problem, type) {
-  return problem.type === type;
-}
-var NO_WALLET_AVAILABLE = "urn:problem-type:thunder-bridge:no-wallet-available";
-var REQUEST_IN_FLIGHT = "urn:problem-type:thunder-bridge:request-in-flight";
-var IDEMPOTENCY_KEY_REUSED = "urn:problem-type:thunder-bridge:idempotency-key-reused";
-var PAYMENT_ALREADY_WATCHED = "urn:problem-type:thunder-bridge:payment-already-watched";
-var IdempotencyConflictError = class extends ProblemError {
-  conflict;
-  constructor(problem, conflict) {
-    super(problem);
-    this.name = "IdempotencyConflictError";
-    this.conflict = conflict;
+  /** A bank transfer, proved the way a Lightning payment is */
+  bank(config) {
+    return bankRail(this.gateway, config);
   }
-};
-var NoWalletAvailableError = class extends ProblemError {
-  wallets;
-  constructor(problem, wallets) {
-    super({ ...problem, type: NO_WALLET_AVAILABLE });
-    this.name = "NoWalletAvailableError";
-    this.wallets = wallets;
+  /**
+   * One bank transfer without building a rail first, for a shop that asks for
+   * them one at a time rather than beside another payment method
+   */
+  transfer(params) {
+    return bankTransfer(this.gateway, params);
   }
 };
 
 // src/verify.ts
-var HTTP_TIMEOUT_MS = 15e3;
+var HTTP_TIMEOUT_MS2 = 15e3;
 var DEFAULT_WRAP_PROPORTION = 0.01;
 var DEFAULT_WRAP_BASE_MSAT = 1e3;
-async function proveOrigin(payment, request) {
+async function proveOrigin(payment, asked) {
   const cheat = (code) => new GatewayCheatError(code, payment.id);
-  const listed = request.lnAddresses.find(
-    (address) => equalIgnoringCase(address, payment.lnAddress)
-  );
+  const listed = asked.paidTo.find((address) => equalIgnoringCase(address, payment.lnAddress));
   if (listed === void 0) {
     throw cheat("address_not_requested");
   }
-  if (payment.amountMsat !== request.amountMsat) {
+  if (payment.amountMsat !== asked.amountMsat) {
     throw cheat("amount_mismatch");
   }
   const invoice = decodeInvoice(payment.bolt11);
   if (invoice.paymentHash === null || !equalIgnoringCase(invoice.paymentHash, payment.paymentHash)) {
     throw cheat("hash_mismatch");
   }
-  if (invoice.amountMsat !== request.amountMsat) {
+  if (invoice.amountMsat !== asked.amountMsat) {
     throw cheat("amount_mismatch");
   }
   const payRequest = await payRequestFor(listed, payment);
@@ -1377,8 +1989,8 @@ async function proveOrigin(payment, request) {
     throw cheat("invoice_not_issued");
   }
 }
-async function proveSettlement(payment, request) {
-  await proveOrigin(payment, request);
+async function proveSettlement(payment, asked) {
+  await proveOrigin(payment, asked);
   const verified = await reachable(payment.verifyUrl, payment);
   if (verified.settled !== true || typeof verified.preimage !== "string") {
     return null;
@@ -1388,46 +2000,48 @@ async function proveSettlement(payment, request) {
   }
   return verified.preimage;
 }
-function isProvablyPaid(payment) {
-  if (payment.status !== "paid" || payment.preimage === null) {
+function carriesProof(report) {
+  if (report.status !== "paid" || report.preimage === null) {
     return false;
   }
-  const invoiceHash = decodeInvoice(payment.bolt11).paymentHash;
-  if (invoiceHash === null || !equalIgnoringCase(invoiceHash, payment.paymentHash)) {
-    return false;
+  if (report.bolt11 !== void 0 && report.bolt11 !== null) {
+    const invoiceHash = decodeInvoice(report.bolt11).paymentHash;
+    if (invoiceHash === null || !equalIgnoringCase(invoiceHash, report.paymentHash)) {
+      return false;
+    }
   }
-  return preimageMatchesHash(payment.preimage, invoiceHash);
+  return preimageMatchesHash(report.preimage, report.paymentHash);
 }
 function wrapFeeCeiling(amountMsat, allowance) {
   const proportional = amountMsat * (allowance?.proportion ?? DEFAULT_WRAP_PROPORTION);
-  return Math.max(allowance?.baseMsat ?? DEFAULT_WRAP_BASE_MSAT, Math.floor(proportional));
+  return msat(Math.max(allowance?.baseMsat ?? DEFAULT_WRAP_BASE_MSAT, Math.floor(proportional)));
 }
 function proveWrapped(wrapped, recipient, allowance) {
   const offered = decodeInvoice(wrapped);
   const owed = decodeInvoice(recipient);
-  const refuse = (code, detail) => {
+  const refuse2 = (code, detail) => {
     throw new WrapRefusedError(code, detail);
   };
   if (offered.paymentHash === null || offered.amountMsat === null || offered.expiresAt === null) {
-    refuse("undecodable", "the wrapped invoice carries no hash, amount or expiry");
+    refuse2("undecodable", "the wrapped invoice carries no hash, amount or expiry");
   }
   if (owed.paymentHash === null || owed.amountMsat === null || owed.expiresAt === null) {
-    refuse("undecodable", "the recipient's invoice carries no hash, amount or expiry");
+    refuse2("undecodable", "the recipient's invoice carries no hash, amount or expiry");
   }
   if (offered.paymentHash?.toLowerCase() !== owed.paymentHash?.toLowerCase()) {
-    refuse("hash_mismatch", "settling the wrap would not settle the recipient");
+    refuse2("hash_mismatch", "settling the wrap would not settle the recipient");
   }
   const asked = offered.amountMsat ?? 0;
   const due = owed.amountMsat ?? 0;
   if (asked < due) {
-    refuse("amount_below_recipient", `${asked} msat cannot forward ${due} msat`);
+    refuse2("amount_below_recipient", `${asked} msat cannot forward ${due} msat`);
   }
   const ceiling = wrapFeeCeiling(due, allowance);
   if (asked - due > ceiling) {
-    refuse("fee_above_allowance", `${asked - due} msat over ${due}, and ${ceiling} was allowed`);
+    refuse2("fee_above_allowance", `${asked - due} msat over ${due}, and ${ceiling} was allowed`);
   }
   if ((owed.expiresAt ?? 0) <= (offered.expiresAt ?? 0)) {
-    refuse("recipient_expires_first", "the operator could be paid and find it cannot deliver");
+    refuse2("recipient_expires_first", "the operator could be paid and find it cannot deliver");
   }
 }
 async function payRequestFor(listed, payment) {
@@ -1445,7 +2059,7 @@ async function reachable(url, payment) {
       throw new Error(`${url} is not a public https URL`);
     }
     const response = await fetch(url, {
-      signal: AbortSignal.timeout(HTTP_TIMEOUT_MS),
+      signal: AbortSignal.timeout(HTTP_TIMEOUT_MS2),
       headers: { accept: "application/json" }
     });
     if (!response.ok) {
@@ -1464,6 +2078,280 @@ function equalIgnoringCase(one, other) {
   return one.toLowerCase() === other.toLowerCase();
 }
 
+// src/request.ts
+function paymentRequestOf(gateway, payment, options) {
+  return {
+    id: payment.id,
+    bolt11: payment.bolt11,
+    paymentHash: payment.paymentHash,
+    lnAddress: payment.lnAddress,
+    amountMsat: payment.amountMsat,
+    expiresAt: payment.expiresAt,
+    qr: invoiceToSvg(payment.bolt11, options?.qr),
+    payment,
+    paid: async (waiting) => paidOnly(await gateway.settled(payment.id, { ...waitingOf(options), ...waiting })),
+    prove: () => proveSettlement(payment, { paidTo: [payment.lnAddress], amountMsat: payment.amountMsat }),
+    onPaid: (arrived, failed) => {
+      const stop = new AbortController();
+      const waiting = waitingOf(options);
+      const signal = waiting.signal ? AbortSignal.any([stop.signal, waiting.signal]) : stop.signal;
+      gateway.settled(payment.id, { ...waiting, signal }).then((ended) => arrived(paidOnly(ended))).catch((reason) => {
+        if (!stop.signal.aborted) {
+          failed?.(reason);
+        }
+      });
+      return () => stop.abort();
+    }
+  };
+}
+function paidOnly(ended) {
+  if (ended.status !== "paid") {
+    throw new Error(`payment ${ended.id} ended ${ended.status} rather than paid`);
+  }
+  if (ended.kind !== "minted") {
+    throw new Error(`payment ${ended.id} came back without the invoice it was minted with`);
+  }
+  return ended;
+}
+function waitingOf(options) {
+  return { signal: options?.signal, tickets: options?.tickets };
+}
+
+// src/trigger.ts
+var NONCE_BYTES = 16;
+function lnurlPayEndpoint(gateway, config) {
+  return async (request) => {
+    const url = new URL(request.url);
+    const asked = url.searchParams.get("to");
+    try {
+      return asked === null ? await offer(gateway, config, url) : await mint(gateway, config, url, asked);
+    } catch (failure) {
+      return refuse(failure instanceof Error ? failure.message : "the trigger could not be served");
+    }
+  };
+}
+function watchTicketEndpoint(gateway, config) {
+  return async (request) => {
+    const offered = await offeredSecret(request);
+    if (!equalInConstantTime(sha256Hex(offered), sha256Hex(config.watchSecret))) {
+      return Response.json({ reason: "not the watch secret" }, { status: 403 });
+    }
+    return await issue(gateway, config);
+  };
+}
+function publicWatchTicketEndpoint(gateway, config) {
+  return () => issue(gateway, config);
+}
+async function offer(gateway, config, url) {
+  const { least, most } = await spread(config.amount);
+  const quote = await gateway.quote({ paidTo: config.paidTo, amount: msat(least) });
+  const nonce = randomNonce();
+  const callback = new URL(config.baseUrl ?? `${url.origin}${url.pathname}`);
+  callback.searchParams.set("to", quote.lnAddress);
+  callback.searchParams.set("least", String(least));
+  callback.searchParams.set("most", String(most));
+  callback.searchParams.set("n", nonce);
+  callback.searchParams.set("sig", await sign(config.secret, quote.lnAddress, least, most, nonce));
+  return Response.json({
+    tag: "payRequest",
+    callback: callback.toString(),
+    metadata: quote.metadata,
+    minSendable: least,
+    maxSendable: most
+  });
+}
+async function spread(amount) {
+  if (typeof amount === "number" || typeof amount === "function") {
+    const pinned = await amountNow(amount);
+    return { least: pinned, most: pinned };
+  }
+  const least = await amountNow(amount.least);
+  const most = await amountNow(amount.most);
+  if (most < least) {
+    throw new Error(`a range cannot end at ${most} msat when it starts at ${least}`);
+  }
+  return { least, most };
+}
+async function mint(gateway, config, url, address) {
+  const least = Number(url.searchParams.get("least"));
+  const most = Number(url.searchParams.get("most"));
+  const nonce = url.searchParams.get("n") ?? "";
+  const signature = url.searchParams.get("sig") ?? "";
+  const expected = await sign(config.secret, address, least, most, nonce);
+  if (!equalInConstantTime(signature, expected)) {
+    return refuse("this callback was not signed here");
+  }
+  const asked = url.searchParams.get("amount");
+  const amountMsat = asked === null ? least : Number(asked);
+  if (!Number.isSafeInteger(amountMsat) || amountMsat < least || amountMsat > most) {
+    return refuse(
+      least === most ? `this trigger costs exactly ${least} msat` : `this trigger takes between ${least} and ${most} msat`
+    );
+  }
+  const minted = config.blind ? await mintBlind(gateway, config, address, amountMsat) : await mintThroughGateway(gateway, config, address, amountMsat, nonce);
+  return Response.json({
+    status: "OK",
+    pr: minted.bolt11,
+    routes: [],
+    verify: minted.verifyUrl
+  });
+}
+async function mintThroughGateway(gateway, config, address, amountMsat, nonce) {
+  const payment = await gateway.mint(
+    { paidTo: address, amount: msat(amountMsat) },
+    { idempotencyKey: nonce, trigger: config.watchSecret, replay: config.replay }
+  );
+  return { bolt11: payment.bolt11, verifyUrl: payment.verifyUrl };
+}
+async function mintBlind(gateway, config, address, amountMsat) {
+  const resolved2 = await resolve(
+    config.send ?? pinnedToTheAddressWeVerified,
+    [address],
+    amountMsat
+  );
+  const minted = { ...resolved2, amountMsat, lnAddress: resolved2.address };
+  const locked = config.sealed;
+  const relay = config.relayThrough;
+  try {
+    await gateway.watch({
+      paymentHash: resolved2.paymentHash,
+      verifyUrl: relay ? await relayedVerifyUrl(
+        relay.endpoint,
+        { url: resolved2.verifyUrl, hash: resolved2.paymentHash },
+        relay.secret
+      ) : resolved2.verifyUrl,
+      expiresAt: resolved2.expiresAt,
+      trigger: config.watchSecret,
+      replay: config.replay,
+      sealed: locked ? await seal(locked.secret, JSON.stringify(locked.data(minted))) : void 0
+    });
+  } catch (refused) {
+    if (!alreadyWatched(refused)) {
+      throw refused;
+    }
+  }
+  return { bolt11: resolved2.bolt11, verifyUrl: resolved2.verifyUrl };
+}
+function alreadyWatched(refused) {
+  return refused instanceof ProblemError && isProblemType(refused, PAYMENT_ALREADY_WATCHED);
+}
+function sign(secret, address, least, most, nonce) {
+  return hmacHex(secret, `${address}|${least}|${most}|${nonce}`);
+}
+function randomNonce() {
+  const bytes = crypto.getRandomValues(new Uint8Array(NONCE_BYTES));
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function refuse(reason) {
+  return Response.json({ status: "ERROR", reason });
+}
+async function issue(gateway, config) {
+  const issued = await gateway.ticket(config.watchSecret, { replay: config.replay });
+  return Response.json({
+    ticket: issued.ticket,
+    expires_at: new Date(issued.expiresAt * 1e3).toISOString()
+  });
+}
+async function offeredSecret(request) {
+  const body = await request.json().catch(() => null);
+  return typeof body?.secret === "string" ? body.secret : "";
+}
+
+// src/serving.ts
+var Serve = class {
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  gateway;
+  /**
+   * An LNURL-pay endpoint of your own, standing in front of a priority list of
+   * addresses, so a printed QR points at your domain and never expires
+   */
+  lnurlPay(config) {
+    return lnurlPayEndpoint(this.gateway, config);
+  }
+  /** Trades the watch secret for a one minute socket ticket, refusing anyone without it */
+  watchTicket(config) {
+    return watchTicketEndpoint(this.gateway, config);
+  }
+  /**
+   * Mints a socket ticket for anybody who asks, which makes the trigger's whole
+   * stream public, preimages included. Only for a board where that is the point
+   */
+  publicWatchTicket(config) {
+    return publicWatchTicketEndpoint(this.gateway, config);
+  }
+  /**
+   * A verify endpoint of your own that asks the recipient's wallet for you, so
+   * the gateway polls you and never the wallet
+   */
+  verify(config) {
+    return lightningVerifyEndpoint(config);
+  }
+  /** The verify endpoint a bank rail is polled at, answering off your own statement */
+  bankVerify(config) {
+    return bankVerifyEndpoint(config);
+  }
+  /**
+   * The whole webhook route: it answers the gateway's challenge, checks the
+   * signature against the key the gateway publishes, refuses a settlement that
+   * proves nothing, and calls you for the one that does.
+   *
+   * `export const POST = gateway.serve.webhook({ onSettled: fulfil })` is the
+   * entire integration
+   */
+  webhook(handlers) {
+    const options = { toleranceSecs: handlers.toleranceSecs };
+    return async (request) => {
+      const credential = await this.credential(handlers);
+      const challenge = await answerWebhookChallenge(request, credential, options);
+      if (challenge !== null) {
+        return challenge;
+      }
+      const settlement = await readSettlement(request, credential, options);
+      if (settlement !== null) {
+        return await acted(settlement, handlers);
+      }
+      const payment = await readPayment(request, credential, options);
+      if (payment !== null) {
+        await handlers.onPayment?.(payment);
+        return new Response("ok");
+      }
+      return new Response("bad signature", { status: 401 });
+    };
+  }
+  /** Verify a delivery and read the settlement out of it, null when it is not believable */
+  async readSettlement(request, options) {
+    return await readSettlement(request, await this.credential({}), options);
+  }
+  /** Verify a delivery and read the payment out of it, null when it is not believable */
+  async readPayment(request, options) {
+    return await readPayment(request, await this.credential({}), options);
+  }
+  /** Answer the challenge the gateway sends before it will post to a webhook of yours */
+  async answerWebhookChallenge(request, options) {
+    return await answerWebhookChallenge(request, await this.credential({}), options);
+  }
+  async credential(handlers) {
+    return handlers.credential ?? { publicKey: await this.gateway.webhookKey() };
+  }
+};
+async function acted(settlement, handlers) {
+  if (carriesProof(settlement)) {
+    await handlers.onSettled?.(settlement);
+    return new Response("ok");
+  }
+  if (handlers.onUnproven === void 0) {
+    return new Response("the recipient released no preimage", { status: 202 });
+  }
+  await handlers.onUnproven(settlement);
+  return new Response("ok");
+}
+
 // src/client.ts
 var TERMINAL = /* @__PURE__ */ new Set(["paid", "expired"]);
 var RECONNECT_DELAY_MS = 3e3;
@@ -1483,6 +2371,13 @@ function backoffMs(firstDelay, attempt) {
   const grown = Math.min(firstDelay * 2 ** (attempt - 1), RECONNECT_CAP_MS);
   return Math.round(grown * (0.5 + Math.random() / 2));
 }
+function gatewayAt(baseUrl) {
+  const at = URL.canParse(baseUrl) ? new URL(baseUrl) : null;
+  if (at === null || at.protocol !== "http:" && at.protocol !== "https:") {
+    throw new Error(`${baseUrl} is not an http or https gateway url`);
+  }
+  return baseUrl.replace(/\/+$/, "");
+}
 var ThunderBridge = class {
   baseUrl;
   verify;
@@ -1490,28 +2385,34 @@ var ThunderBridge = class {
   secret;
   strangers = null;
   speaks = null;
+  published = null;
+  /** Everything this gateway lets you mount, from an LNURL endpoint to a webhook route */
+  serve;
+  /** One call per sale, whatever the rail moves */
+  rails;
   constructor(baseUrl, options) {
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.baseUrl = gatewayAt(baseUrl);
     this.verify = options?.verify ?? true;
     this.token = options?.token ?? null;
     this.secret = options?.secret ?? null;
+    this.serve = new Serve(this);
+    this.rails = new Rails(this);
   }
   /**
-   * Whether a token was given, which is what makes an instance yours: a gateway
-   * started with `GATEWAY_TOKEN` answers nobody else, so anything you hand it
-   * stays between you and it
+   * Whether a token was given to this instance, which is your side of the
+   * arrangement and says nothing about the gateway's. `refusesStrangers` is the
+   * one that asks the gateway, and it is the one to guard anything with
    */
-  get isPrivate() {
+  get hasToken() {
     return this.token !== null;
   }
   /**
    * Whether the gateway turns away a caller carrying no token, asked by making
-   * one unauthenticated read it would have to refuse. `isPrivate` answers only
-   * whether you configured a token, which is your side of the arrangement and
-   * says nothing about the gateway's, so a made-up token against a public
-   * instance reads as private and is not. Asked once and remembered, because an
-   * instance does not change its mind. Anything other than a refusal counts as
-   * open, so an unreachable gateway fails closed
+   * one unauthenticated read it would have to refuse. `hasToken` answers only
+   * whether you configured one, so a made-up token against a public instance
+   * reads as yours and is not. Asked once and remembered, because an instance
+   * does not change its mind. Anything other than a refusal counts as open, so
+   * an unreachable gateway fails closed
    */
   async refusesStrangers() {
     this.strangers ??= fetch(`${this.baseUrl}/incoming-payments/${STRANGER_PROBE}`, {
@@ -1519,14 +2420,24 @@ var ThunderBridge = class {
     }).then((answer) => answer.status === 401).catch(() => false);
     return await this.strangers;
   }
+  /**
+   * Ask to be paid for one thing. It mints the invoice, proves it came from the
+   * address you asked for, draws the QR and hands back one object with a way to
+   * wait for the money. This is `mint` plus the two things every caller does next
+   */
+  async requestPayment(asked) {
+    return paymentRequestOf(this, await this.mint(asked, asked), asked);
+  }
   /**
    * Ask the gateway for an invoice payable to the first address on your list
    * that can issue a provable one, throws `NoWalletAvailableError` when none can
    * and `GatewayCheatError` when what comes back is not what you asked for
    */
-  async createPayment(params, options) {
+  async mint(charge, options) {
+    const asked = await priced(charge);
     const sent = createRequestBody(
-      params,
+      asked,
+      charge.webhookUrl,
       options?.trigger ? sha256Hex(unguessable(options.trigger)) : null,
       options?.replay
     );
@@ -1542,9 +2453,9 @@ var ThunderBridge = class {
     if (!response.ok) {
       throw await problemFrom(response);
     }
-    const payment = await paymentFrom(response);
+    const payment = await mintedFrom(response);
     if (this.verify) {
-      await proveOrigin(payment, params);
+      await proveOrigin(payment, asked);
     }
     return payment;
   }
@@ -1555,8 +2466,8 @@ var ThunderBridge = class {
    * whether a wallet returns a provable invoice cannot be known without asking
    * it for one, and asking mints it
    */
-  async createQuote(params) {
-    const sent = quoteRequestBody(params);
+  async quote(charge) {
+    const sent = quoteRequestBody(await priced(charge));
     const response = await fetch(`${this.baseUrl}/quotes`, {
       method: "POST",
       headers: await this.sending("/quotes", sent),
@@ -1574,13 +2485,19 @@ var ThunderBridge = class {
     }
     return quote;
   }
-  /** Read a payment back, null when the gateway has never heard of it */
   /**
-   * The key this gateway signs webhooks with when you registered none of your own,
-   * ready to hand to `parseWebhookRequest` as `{ publicKey }`. Fetch it once and
-   * keep it: it is the same for every instance in the cluster
+   * The key this gateway signs webhooks with when you registered none of your own.
+   * `serve.webhook` reads it for you. Asked once and kept, because it is the same
+   * for every instance in the cluster
    */
   async webhookKey() {
+    this.published ??= this.publishedKey().catch((refused) => {
+      this.published = null;
+      throw refused;
+    });
+    return await this.published;
+  }
+  async publishedKey() {
     const response = await fetch(`${this.baseUrl}/webhook-key`);
     if (!response.ok) {
       throw await problemFrom(response);
@@ -1594,25 +2511,12 @@ var ThunderBridge = class {
     }
     return body.public_key;
   }
-  async getPayment(id) {
-    const path = `/incoming-payments/${encodeURIComponent(id)}`;
-    const response = await fetch(`${this.baseUrl}${path}`, {
-      headers: await this.reading("GET", path)
-    });
-    if (response.status === 404) {
-      return null;
-    }
-    if (!response.ok) {
-      throw await problemFrom(response);
-    }
-    return this.checked(await paymentFrom(response));
-  }
   /**
-   * Read back a payment the gateway is only watching, null when it has never
-   * heard of it. A watched payment carries no address, amount or invoice, so
-   * `getPayment` refuses it and this reads the shape both rails share
+   * Read a payment back, null when the gateway has never heard of it. One method
+   * for both sorts: `kind` says whether the gateway minted it or was handed it,
+   * and the address, amount and invoice are null on one it was never told
    */
-  async getWatched(id) {
+  async payment(id) {
     const path = `/incoming-payments/${encodeURIComponent(id)}`;
     const response = await fetch(`${this.baseUrl}${path}`, {
       headers: await this.reading("GET", path)
@@ -1620,17 +2524,10 @@ var ThunderBridge = class {
     if (response.status === 404) {
       return null;
     }
-    if (!response.ok) {
-      throw await problemFrom(response);
-    }
-    const watched = triggerEventFromWire(await response.json().catch(() => null));
-    if (watched === null) {
-      throw new ProblemError({
-        status: response.status,
-        title: "The gateway answered with something that is not a payment"
-      });
+    if (!response.ok) {
+      throw await problemFrom(response);
     }
-    return this.proven(watched);
+    return this.proven(await paymentFrom(response));
   }
   /**
    * List what this gateway is watching, newest first. Only a gateway started
@@ -1641,7 +2538,7 @@ var ThunderBridge = class {
    * Anything older than that window is not in the answer, and the list does not
    * pretend otherwise
    */
-  async listPayments(limit) {
+  async payments(limit) {
     const path = `/incoming-payments${limit === void 0 ? "" : `?limit=${limit}`}`;
     const response = await fetch(`${this.baseUrl}${path}`, {
       headers: await this.reading("GET", path)
@@ -1650,7 +2547,7 @@ var ThunderBridge = class {
       throw await problemFrom(response);
     }
     const body = await response.json().catch(() => null);
-    const listed = Array.isArray(body?.payments) ? body.payments.map(triggerEventFromWire).filter((one) => one !== null) : null;
+    const listed = Array.isArray(body?.payments) ? body.payments.map(paymentFromWire).filter((one) => one !== null) : null;
     if (listed === null || typeof body?.settled_scanned !== "number") {
       throw new ProblemError({
         status: response.status,
@@ -1665,34 +2562,15 @@ var ThunderBridge = class {
    * one that has answered is followed until its own expiry, so the wait always
    * ends by itself
    */
-  async waitForPayment(id, options) {
-    const payment = paymentFromWire(await this.followed(id, options));
-    if (payment === null) {
-      throw new ProblemError({
-        status: 200,
-        title: `payment ${id} is watched rather than minted here, read it with waitForWatched`
-      });
-    }
-    return this.checked(payment);
-  }
-  /**
-   * Follow a payment the gateway is only watching, one it did not mint, until it
-   * is paid or expired.
-   *
-   * A watched payment carries no address, no amount and no invoice, because the
-   * gateway was told none of them, so it reads back as the shape a trigger
-   * streams rather than as a `Payment`. That is every bank transfer, and every
-   * Lightning invoice registered with `watchPayment` instead of `createPayment`.
-   */
-  async waitForWatched(id, options) {
-    const watched = triggerEventFromWire(await this.followed(id, options));
-    if (watched === null) {
+  async settled(id, options) {
+    const ended = paymentFromWire(await this.followed(id, options));
+    if (ended === null) {
       throw new ProblemError({
         status: 200,
         title: "The gateway answered with something that is not a payment"
       });
     }
-    return this.proven(watched);
+    return this.proven(ended);
   }
   followed(id, options) {
     const base = this.baseUrl.replace(/^http/, "ws");
@@ -1759,7 +2637,7 @@ var ThunderBridge = class {
         opened.onmessage = (event) => {
           try {
             const frame = JSON.parse(String(event.data));
-            const watched = triggerEventFromWire(frame);
+            const watched = paymentFromWire(frame);
             if (watched === null) {
               return;
             }
@@ -1788,16 +2666,16 @@ var ThunderBridge = class {
    * what you want is the one that arrives and nothing further from the other.
    *
    * A leg that expires is a loser, not a winner, which is the whole reason this is
-   * not a race: `waitForPayment` ends on `paid` and on `expired` alike, and a
+   * not a race: `settled` ends on `paid` and on `expired` alike, and a
    * Lightning invoice expires in an hour while a bank transfer takes days. `null`
    * means every leg ended without being paid.
    *
    * Stopping the wait is not revoking the invoice. Nobody can revoke one, because
    * the recipient's own wallet minted it, so a payer who pays the loser afterwards
-   * really does pay twice and that shows up on `followTrigger` as a second
-   * settlement to refund.
+   * really does pay twice and that shows up on `follow` as a second settlement to
+   * refund.
    */
-  async firstToSettle(ids, options) {
+  async firstSettled(ids, options) {
     if (ids.length === 0) {
       return null;
     }
@@ -1814,7 +2692,7 @@ var ThunderBridge = class {
           }
         };
         for (const id of ids) {
-          this.waitForWatched(id, { ...options, signal }).then((watched) => watched.status === "paid" ? resolve2(watched) : lost()).catch((failure) => {
+          this.settled(id, { ...options, signal }).then((watched) => watched.status === "paid" ? resolve2(watched) : lost()).catch((failure) => {
             refused ??= failure;
             lost();
           });
@@ -1834,10 +2712,10 @@ var ThunderBridge = class {
    * rather than one recipient, which is what makes leaving it cheap. Anything
    * the watcher needs goes in `sealed`, which the gateway cannot read
    */
-  async watchPayment(params) {
+  async watch(handover) {
     const sent = watchRequestBody(
-      params,
-      params.trigger ? sha256Hex(unguessable(params.trigger)) : null
+      handover,
+      handover.trigger ? sha256Hex(unguessable(handover.trigger)) : null
     );
     const response = await fetch(`${this.baseUrl}/watched-payments`, {
       method: "POST",
@@ -1847,14 +2725,14 @@ var ThunderBridge = class {
     if (!response.ok) {
       throw await problemFrom(response);
     }
-    const watched = triggerEventFromWire(await response.json().catch(() => null));
+    const watched = paymentFromWire(await response.json().catch(() => null));
     if (watched === null) {
       throw new ProblemError({
         status: response.status,
         title: "The gateway answered with something that is not a watched payment"
       });
     }
-    const named = await this.nameFor(params.paymentHash);
+    const named = await this.nameFor(handover.paymentHash);
     if (named !== null && watched.id !== named) {
       throw new GatewayCheatError("id_not_mine", watched.id);
     }
@@ -1875,7 +2753,7 @@ var ThunderBridge = class {
    * connect and then live, reconnecting on its own until the returned function
    * is called. A trigger has no terminal state, so this never resolves
    */
-  followTrigger(secret, options) {
+  follow(secret, options) {
     const base = this.baseUrl.replace(/^http/, "ws");
     const asked = options.replay === void 0 ? "" : `?replay=${options.replay}`;
     const direct = `${base}/ws/triggers/${encodeURIComponent(unguessable(secret))}${asked}`;
@@ -1914,7 +2792,7 @@ var ThunderBridge = class {
       };
       socket.onmessage = (event) => {
         try {
-          const settled = triggerEventFromWire(JSON.parse(String(event.data)));
+          const settled = paymentFromWire(JSON.parse(String(event.data)));
           if (settled !== null) {
             options.onPayment(this.proven(settled));
           }
@@ -1936,13 +2814,13 @@ var ThunderBridge = class {
    * A one minute pass onto one trigger's stream, for something that must hold
    * neither the token nor the trigger secret. Mint it in a handler and answer
    * with the ticket alone, because that is all a browser needs to connect and
-   * all it can do anything with. `watchTicketEndpoint` is this method already
+   * all it can do anything with. `serve.watchTicket` is this method already
    * wrapped in a route
    */
-  async createSocketTicket(params) {
+  async ticket(trigger, options) {
     return await this.mintedTicket({
-      trigger_secret: unguessable(params.trigger),
-      replay: params.replay
+      trigger_secret: unguessable(trigger),
+      replay: options?.replay
     });
   }
   needsTicket(asked) {
@@ -1983,15 +2861,8 @@ var ThunderBridge = class {
     this.speaks ??= callerKey(this.secret ?? "");
     return await this.speaks;
   }
-  proven(settled) {
-    const unproven = settled.status === "paid" && (settled.preimage === null || !preimageMatchesHash(settled.preimage, settled.paymentHash));
-    if (this.verify && unproven) {
-      throw new GatewayCheatError("preimage_mismatch", settled.id);
-    }
-    return settled;
-  }
-  checked(payment) {
-    if (this.verify && payment.status === "paid" && !isProvablyPaid(payment)) {
+  proven(payment) {
+    if (this.verify && payment.status === "paid" && !carriesProof(payment)) {
       throw new GatewayCheatError("preimage_mismatch", payment.id);
     }
     return payment;
@@ -2007,11 +2878,21 @@ async function paymentFrom(response) {
   }
   return payment;
 }
+async function mintedFrom(response) {
+  const payment = mintedFromWire(await response.json().catch(() => null));
+  if (payment === null) {
+    throw new ProblemError({
+      status: response.status,
+      title: "The gateway answered with something that is not a minted payment"
+    });
+  }
+  return payment;
+}
 async function problemFrom(response) {
   const problem = await response.json().catch(() => ({}));
   const document = { ...problem, status: response.status };
   if (isProblemType(problem, NO_WALLET_AVAILABLE)) {
-    return new NoWalletAvailableError(document, refusals(problem.wallets));
+    return new NoWalletAvailableError(document, refusals2(problem.wallets));
   }
   if (isProblemType(problem, REQUEST_IN_FLIGHT)) {
     return new IdempotencyConflictError(document, "request-in-flight");
@@ -2021,7 +2902,7 @@ async function problemFrom(response) {
   }
   return new ProblemError(document);
 }
-function refusals(wallets) {
+function refusals2(wallets) {
   if (!Array.isArray(wallets)) {
     return [];
   }
@@ -2030,118 +2911,6 @@ function refusals(wallets) {
   });
 }
 
-// src/fio.ts
-var BASE_URL = "https://fioapi.fio.cz/v1/rest";
-var MINOR_UNITS = 100;
-var MILLIS = 1e3;
-var DATE_CHARS = "2026-08-04".length;
-var DEFAULT_MIN_INTERVAL_SECS = 30;
-var TOO_SOON = 409;
-var BOOKED_AT = "column0";
-var AMOUNT = "column1";
-var CURRENCY = "column14";
-var VARIABLE_SYMBOL = "column5";
-var USER_IDENTIFICATION = "column7";
-var MESSAGE_FOR_RECIPIENT = "column16";
-var PAYER_REFERENCE = "column27";
-var WHERE_A_PAYER_WRITES = [
-  MESSAGE_FOR_RECIPIENT,
-  VARIABLE_SYMBOL,
-  USER_IDENTIFICATION,
-  PAYER_REFERENCE
-];
-var UTC_OFFSET = /^[+-]\d{4}$/;
-function fioStatement(config) {
-  const named = typeof config.token === "string" ? [config.token] : config.token;
-  if (named.length === 0) {
-    throw new Error("fioStatement needs at least one token to read with");
-  }
-  const usedAt = new Map(named.map((token) => [token, Number.NEGATIVE_INFINITY]));
-  const tokenWindowMs = (config.minIntervalSecs ?? DEFAULT_MIN_INTERVAL_SECS) * MILLIS;
-  const paceMs = tokenWindowMs / usedAt.size;
-  let lastRead = Number.NEGATIVE_INFINITY;
-  let credits = [];
-  return async (sinceUnix) => {
-    const now = Date.now();
-    if (now - lastRead < paceMs) {
-      return credits;
-    }
-    const idlest = longestUnused(usedAt);
-    if (now - idlest.usedAt < tokenWindowMs) {
-      return credits;
-    }
-    usedAt.set(idlest.token, now);
-    lastRead = now;
-    const url = [
-      config.baseUrl ?? BASE_URL,
-      "periods",
-      idlest.token,
-      asDate(sinceUnix),
-      asDate(Math.floor(now / MILLIS)),
-      "transactions.json"
-    ].join("/");
-    const answer = await fetch(url, { headers: { accept: "application/json" } });
-    if (answer.status === TOO_SOON) {
-      throw new Error("fio refuses a second read of this token inside its 30 second window");
-    }
-    if (!answer.ok) {
-      throw new Error(`fio answered ${answer.status} reading the statement`);
-    }
-    const read = await answer.json();
-    credits = (read.accountStatement?.transactionList?.transaction ?? []).filter(isCredit).map(asCredit);
-    return credits;
-  };
-}
-function longestUnused(usedAt) {
-  let token = "";
-  let idleSince = Number.POSITIVE_INFINITY;
-  for (const [candidate, at] of usedAt) {
-    if (at < idleSince) {
-      token = candidate;
-      idleSince = at;
-    }
-  }
-  return { token, usedAt: idleSince };
-}
-function isCredit(transaction) {
-  return numberIn(transaction[AMOUNT]) > 0;
-}
-function asCredit(transaction) {
-  return {
-    amountMinor: Math.round(numberIn(transaction[AMOUNT]) * MINOR_UNITS),
-    currency: textIn(transaction[CURRENCY]),
-    reference: WHERE_A_PAYER_WRITES.map((column) => textIn(transaction[column])).filter((written) => written.length > 0).join(" "),
-    bookedAt: bookedAtIn(transaction[BOOKED_AT])
-  };
-}
-function bookedAtIn(cell) {
-  const value = cell?.value;
-  if (typeof value === "number") {
-    return Math.floor(value / MILLIS);
-  }
-  const at = Date.parse(asIso8601(textIn(cell)));
-  return Number.isFinite(at) ? Math.floor(at / MILLIS) : 0;
-}
-function asIso8601(booked) {
-  const day = booked.slice(0, DATE_CHARS);
-  const zone = booked.slice(DATE_CHARS);
-  if (!UTC_OFFSET.test(zone)) {
-    return `${day}T00:00:00Z`;
-  }
-  return `${day}T00:00:00${zone.slice(0, 3)}:${zone.slice(3)}`;
-}
-function numberIn(cell) {
-  const value = Number(cell?.value ?? Number.NaN);
-  return Number.isFinite(value) ? value : 0;
-}
-function textIn(cell) {
-  const value = cell?.value;
-  return value === null || value === void 0 ? "" : String(value).trim();
-}
-function asDate(unix) {
-  return new Date(unix * MILLIS).toISOString().slice(0, DATE_CHARS);
-}
-
 // src/gateways.ts
 var Gateways = class {
   each;
@@ -2165,10 +2934,8 @@ var Gateways = class {
    * carrying the first refusal, because one gateway that agreed is enough to be
    * watched
    */
-  async watchPayment(params) {
-    const asked = await Promise.allSettled(
-      this.each.map((gateway) => gateway.watchPayment(params))
-    );
+  async watch(handover) {
+    const asked = await Promise.allSettled(this.each.map((gateway) => gateway.watch(handover)));
     const taken = [];
     const refusals3 = [];
     for (const [at, answer] of asked.entries()) {
@@ -2190,7 +2957,7 @@ var Gateways = class {
    * saying so. When they all end without a payment, the first ending is the answer,
    * and when they all fail, the first failure is thrown
    */
-  async waitForWatched(id, options) {
+  async settled(id, options) {
     const stopLosers = new AbortController();
     const signal = options?.signal ? AbortSignal.any([stopLosers.signal, options.signal]) : stopLosers.signal;
     const unpaid = [];
@@ -2205,7 +2972,7 @@ var Gateways = class {
           }
         };
         for (const gateway of this.each) {
-          gateway.waitForWatched(id, { ...options, signal }).then((watched) => {
+          gateway.settled(id, { ...options, signal }).then((watched) => {
             if (watched.status === "paid") {
               return resolve2(watched);
             }
@@ -2229,315 +2996,30 @@ var Gateways = class {
     }
   }
 };
-
-// src/price.ts
-var MSAT_PER_BTC2 = 1e11;
-var BASIS_POINTS = 1e4;
-var DEFAULT_HOLD_SECS = 60;
-var DEFAULT_MIN_VENUES = 2;
-var DEFAULT_MAX_SPREAD_BPS = 200;
-var MILLIS2 = 1e3;
-function coinbase(baseUrl = "https://api.coinbase.com") {
-  return async (currency) => {
-    const asked = currency.toUpperCase();
-    const answer = await asJson(`${baseUrl}/v2/prices/BTC-${asked}/spot`, "coinbase");
-    const quoted = answer.data;
-    if (quoted?.currency !== asked) {
-      throw new Error(`coinbase quoted ${quoted?.currency} when asked for ${asked}`);
-    }
-    return asMinor(quoted.amount, "coinbase", asked);
-  };
-}
-function kraken(baseUrl = "https://api.kraken.com") {
-  return async (currency) => {
-    const asked = currency.toUpperCase();
-    const answer = await asJson(`${baseUrl}/0/public/Ticker?pair=XBT${asked}`, "kraken");
-    if (answer.error?.length) {
-      throw new Error(`kraken refused XBT${asked}: ${answer.error[0]}`);
-    }
-    const pairs = Object.values(answer.result ?? {});
-    if (pairs.length !== 1) {
-      throw new Error(`kraken answered ${pairs.length} pairs for XBT${asked}`);
-    }
-    return asMinor(pairs[0]?.c?.[0], "kraken", asked);
-  };
-}
-function bitstamp(baseUrl = "https://www.bitstamp.net") {
-  return async (currency) => {
-    const pair = `btc${currency.toLowerCase()}`;
-    const answer = await asJson(`${baseUrl}/api/v2/ticker/${pair}/`, "bitstamp");
-    if (Array.isArray(answer)) {
-      throw new Error(`bitstamp has no ${pair} pair`);
-    }
-    return asMinor(answer.last, "bitstamp", currency);
-  };
-}
-function coinmate(baseUrl = "https://coinmate.io") {
-  return async (currency) => {
-    const pair = `BTC_${currency.toUpperCase()}`;
-    const answer = await asJson(`${baseUrl}/api/ticker?currencyPair=${pair}`, "coinmate");
-    if (answer.error !== false) {
-      throw new Error(`coinmate refused ${pair}: ${answer.errorMessage ?? "no reason"}`);
-    }
-    return asMinor(answer.data?.last, "coinmate", currency);
-  };
-}
-function medianOf(tickers = [coinbase(), kraken(), bitstamp(), coinmate()], options = {}) {
-  const holdFor = (options.holdForSecs ?? DEFAULT_HOLD_SECS) * MILLIS2;
-  const minVenues = options.minVenues ?? DEFAULT_MIN_VENUES;
-  const maxSpread = options.maxSpreadBps ?? DEFAULT_MAX_SPREAD_BPS;
-  const held = /* @__PURE__ */ new Map();
-  return async (currency) => {
-    const asked = currency.toUpperCase();
-    const remembered = held.get(asked);
-    if (remembered && Date.now() - remembered.at < holdFor) {
-      return remembered.price;
-    }
-    const answers = await Promise.allSettled(tickers.map((ticker) => ticker(asked)));
-    const quoted = answers.filter((answer) => answer.status === "fulfilled").map((answer) => answer.value).sort((one, other) => one - other);
-    if (quoted.length < minVenues) {
-      throw new Error(
-        `${quoted.length} of ${tickers.length} venues quoted ${asked}, ${minVenues} wanted: ${refusals2(answers)}`
-      );
-    }
-    const spread = spreadBpsOf(quoted);
-    if (spread > maxSpread) {
-      throw new Error(
-        `venues disagree on ${asked} by ${Math.round(spread)} bps, more than the ${maxSpread} allowed: ${quoted.join(", ")}`
-      );
-    }
-    const price = middleOf(quoted);
-    held.set(asked, { at: Date.now(), price });
-    return price;
-  };
-}
-function msatFor(amountMinor, priceMinorPerBtc, options = {}) {
-  if (!Number.isInteger(amountMinor) || amountMinor <= 0) {
-    throw new Error("amountMinor must be a whole number of minor units above zero");
-  }
-  if (!Number.isFinite(priceMinorPerBtc) || priceMinorPerBtc <= 0) {
-    throw new Error(`${priceMinorPerBtc} is not a usable price`);
-  }
-  const spreadBps = options.spreadBps ?? 0;
-  if (!Number.isInteger(spreadBps) || spreadBps < 0) {
-    throw new Error("spreadBps must be a whole number of basis points, none or more");
-  }
-  const wanted = BigInt(amountMinor) * BigInt(MSAT_PER_BTC2) * BigInt(BASIS_POINTS + spreadBps);
-  const per = BigInt(Math.round(priceMinorPerBtc)) * BigInt(BASIS_POINTS);
-  const msat = (wanted + per - 1n) / per;
-  if (msat > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new Error(`${amountMinor} at ${priceMinorPerBtc} is more millisatoshi than exist`);
-  }
-  return Number(msat);
-}
-async function asJson(url, venue) {
-  const answer = await fetch(url, { headers: { accept: "application/json" } });
-  if (!answer.ok) {
-    throw new Error(`${venue} answered ${answer.status}`);
-  }
-  return answer.json();
-}
-function asMinor(quoted, venue, currency) {
-  const major2 = Number(quoted);
-  if (!Number.isFinite(major2) || major2 <= 0) {
-    throw new Error(`${venue} quoted ${String(quoted)} for ${currency.toUpperCase()}`);
-  }
-  return Math.round(major2 * minorScaleOf(currency));
-}
-function spreadBpsOf(sorted) {
-  const lowest = sorted[0] ?? 0;
-  const highest = sorted[sorted.length - 1] ?? 0;
-  return lowest === 0 ? Number.POSITIVE_INFINITY : (highest - lowest) / lowest * BASIS_POINTS;
-}
-function middleOf(sorted) {
-  const middle = Math.floor(sorted.length / 2);
-  if (sorted.length % 2 === 1) {
-    return sorted[middle] ?? 0;
-  }
-  return Math.round(((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2);
-}
-function refusals2(answers) {
-  return answers.filter((answer) => answer.status === "rejected").map(
-    (answer) => answer.reason instanceof Error ? answer.reason.message : String(answer.reason)
-  ).join("; ");
-}
-
-// src/qr.ts
-var import_uqr = require("uqr");
-var SAFE_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$|^rgba?\([\d.,%/\s]+\)$|^[a-z]+$/i;
-function encodeForQr(destination) {
-  const scanned = isLnAddress(destination) ? destination : destination.toUpperCase();
-  return `LIGHTNING:${scanned}`;
-}
-function invoiceToSvg(destination, options) {
-  return svgOf(encodeForQr(destination), options);
-}
-function invoiceToDataUrl(destination, options) {
-  return asDataUrl(invoiceToSvg(destination, options));
-}
-function lnurlToSvg(endpoint, options) {
-  return svgOf(toLnurl(endpoint), options);
-}
-function lnurlToDataUrl(endpoint, options) {
-  return asDataUrl(lnurlToSvg(endpoint, options));
-}
-function spdToSvg(spd, options) {
-  return svgOf(spd, options);
-}
-function spdToDataUrl(spd, options) {
-  return asDataUrl(spdToSvg(spd, options));
-}
-function qrToSvg(payload, options) {
-  return svgOf(payload, options);
-}
-function qrToDataUrl(payload, options) {
-  return asDataUrl(qrToSvg(payload, options));
-}
-function svgOf(scanned, options) {
-  const size = options?.size ?? 256;
-  const color = options?.color ?? "#000";
-  if (!SAFE_COLOR.test(color)) {
-    throw new Error(`Invalid color: ${color}`);
-  }
-  return renderSvg(scanned, size, color);
-}
-function asDataUrl(svg) {
-  return `data:image/svg+xml,${encodeURIComponent(svg)}`;
-}
-function isLnAddress(destination) {
-  const at = destination.indexOf("@");
-  return at > 0 && destination.slice(at + 1).includes(".");
-}
-function renderSvg(content, size, color) {
-  const { data } = (0, import_uqr.encode)(content);
-  const modules = data.length;
-  const cellSize = size / modules;
-  let path = "";
-  for (let y = 0; y < modules; y++) {
-    for (let x = 0; x < modules; x++) {
-      if (data[y][x]) {
-        path += `M${x * cellSize},${y * cellSize}h${cellSize}v${cellSize}h-${cellSize}z`;
-      }
-    }
-  }
-  return [
-    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}">`,
-    `<rect width="100%" height="100%" fill="white"/>`,
-    `<path d="${path}" fill="${color}"/>`,
-    `</svg>`
-  ].join("");
-}
-
-// src/rail.ts
-var BANK = "bank";
-var LIGHTNING = "lightning";
-function bankRail(config) {
-  return async (order) => {
-    const expiresAt = config.expiresAt(order);
-    const transfer = await bankTransfer({
-      gateway: config.gateway,
-      secret: config.secret,
-      iban: config.iban,
-      verifyUrl: config.verifyUrl,
-      reference: order.reference,
-      amountMinor: order.amountMinor,
-      currency: order.currency,
-      expiresAt,
-      trigger: config.trigger,
-      replay: config.replay,
-      sealed: await config.sealed?.(order),
-      variableSymbol: config.variableSymbol?.(order),
-      webhookUrl: config.webhookUrl,
-      allowPublicGateway: config.allowPublicGateway
-    });
-    return {
-      id: transfer.id,
-      rail: config.name ?? BANK,
-      scan: transfer.spd,
-      qr: transfer.spd,
-      expiresAt
-    };
-  };
-}
-function lightningRail(config) {
-  return async (order) => {
-    const payment = await config.gateway.createPayment(
-      {
-        lnAddresses: config.lnAddresses,
-        amountMsat: await config.amountMsat(order),
-        webhookUrl: config.webhookUrl
-      },
-      {
-        idempotencyKey: config.idempotencyKey?.(order),
-        trigger: config.trigger,
-        replay: config.replay
-      }
-    );
-    return {
-      id: payment.id,
-      rail: config.name ?? LIGHTNING,
-      scan: payment.bolt11,
-      qr: encodeForQr(payment.bolt11),
-      expiresAt: payment.expiresAt
-    };
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AmountError,
   GatewayCheatError,
   Gateways,
-  IDEMPOTENCY_KEY_REUSED,
   IdempotencyConflictError,
-  NO_WALLET_AVAILABLE,
   NoWalletAvailableError,
-  PAYMENT_ALREADY_WATCHED,
   ProblemError,
-  REQUEST_IN_FLIGHT,
   ThunderBridge,
   UnverifiedRecipientError,
   WrapRefusedError,
   answerVerifyChallenge,
-  answerVerifyChallengeRequest,
-  answerWebhookChallenge,
-  answerWebhookChallengeRequest,
-  bankRail,
-  bankTransfer,
-  bankVerifyEndpoint,
-  bitstamp,
-  coinbase,
-  coinmate,
+  carriesProof,
   decodeInvoice,
-  fioStatement,
-  invoiceToDataUrl,
-  invoiceToSvg,
-  isProblemType,
-  isProvablyPaid,
-  isProvablySettled,
-  kraken,
-  lightningRail,
-  lnurlToDataUrl,
-  lnurlToSvg,
-  medianOf,
-  minorScaleOf,
-  minorUnitsOf,
-  msatFor,
-  parseSettlement,
-  parseSettlementRequest,
-  parseWatchedWebhook,
-  parseWatchedWebhookRequest,
-  parseWebhook,
-  parseWebhookRequest,
+  fiat,
+  invoiceFrom,
+  msat,
   preimageMatchesHash,
   proveOrigin,
   proveSettlement,
   proveWrapped,
-  qrToDataUrl,
-  qrToSvg,
+  relayedVerifyUrl,
+  sats,
   seal,
-  spdToDataUrl,
-  spdToSvg,
-  toLnurl,
   unseal,
-  verifyWebhookSignature,
   wrapFeeCeiling
 });