thunder-bridge 1.4.2 → 2.1.1

package/dist/index.js

@@ -13,8 +13,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
@@ -108,8 +108,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(
@@ -175,6 +175,7 @@ function rotate(value, by) {
 
 // ../core/bolt11.ts
 var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
 var CHECKSUM_WORDS = 6;
 var TIMESTAMP_WORDS = 7;
 var SIGNATURE_WORDS = 104;
@@ -192,18 +193,27 @@ var HRP_MULTIPLIER_MSAT = {
   n: MSAT_PER_BTC / 1e9,
   p: MSAT_PER_BTC / 1e12
 };
-var HRP_AMOUNT = /^ln[a-z]+?(\d+)([munp]?)$/;
+var HRP = /^ln(?:bcrt|bc|tbs|tb|sb)(?:(\d+)([munp]?))?$/;
 function decodeInvoice(bolt11) {
   const parts = splitBech32(bolt11);
   if (parts === null) {
-    return { paymentHash: null, descriptionHash: null, amountMsat: null, expiresAt: null };
+    return {
+      paymentHash: null,
+      descriptionHash: null,
+      amountMsat: null,
+      issuedAt: null,
+      expiresAt: null
+    };
   }
   const tagged = taggedFields(parts.words);
+  const issuedAt = issuedAtOf(parts.words);
+  const expiry = tagged.get(EXPIRY_TAG);
   return {
     paymentHash: hexTag(tagged, PAYMENT_HASH_TAG, PAYMENT_HASH_WORDS),
     descriptionHash: hexTag(tagged, DESCRIPTION_HASH_TAG, DESCRIPTION_HASH_WORDS),
     amountMsat: amountFromHrp(parts.hrp),
-    expiresAt: expiryOf(parts.words, tagged)
+    issuedAt,
+    expiresAt: issuedAt === null ? null : issuedAt + (expiry ? readNumber(expiry) : DEFAULT_EXPIRY_SECS)
   };
 }
 function preimageMatchesHash(preimage, paymentHash) {
@@ -214,7 +224,7 @@ function preimageMatchesHash(preimage, paymentHash) {
 }
 function splitBech32(bolt11) {
   const lower = bolt11.toLowerCase();
-  if (isBolt12Encoding(lower)) {
+  if (isBolt12Encoding(lower) || bolt11 !== lower && bolt11 !== bolt11.toUpperCase()) {
     return null;
   }
   const separator = lower.lastIndexOf("1");
@@ -233,7 +243,28 @@ function splitBech32(bolt11) {
     }
     words.push(value);
   }
-  return { hrp: lower.slice(0, separator), words: words.slice(0, -CHECKSUM_WORDS) };
+  const hrp = lower.slice(0, separator);
+  if (!HRP.test(hrp) || bech32Polymod([...expandedHrp(hrp), ...words]) !== 1) {
+    return null;
+  }
+  return { hrp, words: words.slice(0, -CHECKSUM_WORDS) };
+}
+function expandedHrp(hrp) {
+  const codes = [...hrp].map((char) => char.charCodeAt(0));
+  return [...codes.map((code) => code >> 5), 0, ...codes.map((code) => code & 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;
 }
 function isBolt12Encoding(lower) {
   return lower.startsWith("lno") || lower.startsWith("lni") || lower.startsWith("lnr");
@@ -263,19 +294,17 @@ function hexTag(fields, tag, expectedWords) {
   }
   return bytesToHex(wordsToBytes(words));
 }
-function expiryOf(words, fields) {
+function issuedAtOf(words) {
   if (words.length < TIMESTAMP_WORDS + SIGNATURE_WORDS) {
     return null;
   }
-  const expiry = fields.get(EXPIRY_TAG);
-  return readNumber(words.slice(0, TIMESTAMP_WORDS)) + (expiry ? readNumber(expiry) : DEFAULT_EXPIRY_SECS);
+  return readNumber(words.slice(0, TIMESTAMP_WORDS));
 }
 function amountFromHrp(hrp) {
-  const match = HRP_AMOUNT.exec(hrp);
-  if (match === null) {
+  const [, digits, multiplier] = HRP.exec(hrp) ?? [];
+  if (digits === void 0 || multiplier === "p" && !digits.endsWith("0")) {
     return null;
   }
-  const [, digits, multiplier] = match;
   return multiplier ? Number(digits) * HRP_MULTIPLIER_MSAT[multiplier] : Number(digits) * MSAT_PER_BTC;
 }
 function readNumber(words) {
@@ -296,180 +325,74 @@ 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;
+// ../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 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) {
+function equalInConstantTime(one, other) {
+  if (one.length !== other.length) {
     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;
+  let difference = 0;
+  for (let at = 0; at < one.length; at++) {
+    difference |= one.charCodeAt(at) ^ other.charCodeAt(at);
   }
+  return difference === 0;
 }
-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;
+function asBuffer(bytes) {
+  return bytes instanceof Uint8Array && bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
 }
 
 // ../core/sealed.ts
-var VERSION = "v1";
+var VERSION = "v2";
+var UNPADDED_VERSION = "v1";
 var IV_BYTES = 12;
 var MIN_SECRET_CHARS = 32;
 var MAX_PLAIN_BYTES = 3e3;
+var SIZE_CLASSES = [256, 1024, MAX_PLAIN_BYTES];
+var END_OF_TEXT = 128;
 var INFO = new TextEncoder().encode("thunder-bridge/sealed");
-async function seal(secret, plaintext) {
-  const body = new TextEncoder().encode(plaintext);
-  if (body.length > MAX_PLAIN_BYTES) {
-    throw new Error(`sealed takes at most ${MAX_PLAIN_BYTES} bytes, this was ${body.length}`);
+async function seal(secret, plaintext, paymentHash) {
+  return await sealUnder(
+    secret,
+    plaintext,
+    crypto.getRandomValues(new Uint8Array(IV_BYTES)),
+    boundTo(paymentHash)
+  );
+}
+async function sealStable(secret, plaintext) {
+  const derived = await hmacHex(secret, `sealed-nonce|${plaintext}`);
+  const nonce = new Uint8Array(IV_BYTES);
+  for (let at = 0; at < IV_BYTES; at++) {
+    nonce[at] = Number.parseInt(derived.slice(at * 2, at * 2 + 2), 16);
   }
+  return await sealUnder(secret, plaintext, nonce, boundTo(void 0));
+}
+async function sealUnder(secret, plaintext, iv, additionalData) {
+  const body = padToClass(plaintext);
   const key = await keyFor(secret);
-  const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
-  const cipher = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, body));
+  const cipher = new Uint8Array(
+    await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData }, key, body)
+  );
   const joined = new Uint8Array(iv.length + cipher.length);
   joined.set(iv);
   joined.set(cipher, iv.length);
   return `${VERSION}.${toBase64Url(joined)}`;
 }
-async function unseal(secret, sealed) {
+async function unseal(secret, sealed, paymentHash) {
   const key = await keyFor(secret);
-  if (!sealed.startsWith(`${VERSION}.`)) {
+  const padded = sealed.startsWith(`${VERSION}.`);
+  const unbound = !padded && sealed.startsWith(`${UNPADDED_VERSION}.`);
+  if (!padded && (!unbound || paymentHash !== void 0)) {
     return null;
   }
   const joined = fromBase64Url(sealed.slice(VERSION.length + 1));
@@ -477,20 +400,50 @@ async function unseal(secret, sealed) {
     return null;
   }
   try {
-    const body = await crypto.subtle.decrypt(
-      { name: "AES-GCM", iv: joined.slice(0, IV_BYTES) },
-      key,
-      joined.slice(IV_BYTES)
+    const body = new Uint8Array(
+      await crypto.subtle.decrypt(
+        {
+          name: "AES-GCM",
+          iv: joined.slice(0, IV_BYTES),
+          additionalData: padded ? boundTo(paymentHash) : void 0
+        },
+        key,
+        joined.slice(IV_BYTES)
+      )
     );
-    return new TextDecoder().decode(body);
+    const text3 = padded ? unpad(body) : body;
+    return text3 === null ? null : new TextDecoder().decode(text3);
   } catch {
     return null;
   }
 }
-async function keyFor(secret) {
+function refuseAWeakSecret(secret) {
   if (secret.length < MIN_SECRET_CHARS) {
     throw new Error(`the sealing secret needs ${MIN_SECRET_CHARS} characters of randomness`);
   }
+}
+function boundTo(paymentHash) {
+  return new TextEncoder().encode(
+    paymentHash === void 0 ? VERSION : `${VERSION}|${paymentHash.toLowerCase()}`
+  );
+}
+function padToClass(plaintext) {
+  const text3 = new TextEncoder().encode(plaintext);
+  const size = SIZE_CLASSES.find((limit) => text3.length <= limit);
+  if (size === void 0) {
+    throw new Error(`sealed takes at most ${MAX_PLAIN_BYTES} bytes, this was ${text3.length}`);
+  }
+  const body = new Uint8Array(size + 1);
+  body.set(text3);
+  body[text3.length] = END_OF_TEXT;
+  return body;
+}
+function unpad(body) {
+  const end = body.lastIndexOf(END_OF_TEXT);
+  return end === -1 ? null : body.subarray(0, end);
+}
+async function keyFor(secret) {
+  refuseAWeakSecret(secret);
   const material = await crypto.subtle.importKey(
     "raw",
     new TextEncoder().encode(secret),
@@ -513,12 +466,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);
@@ -529,32 +482,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 = {
@@ -588,7 +618,8 @@ 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`
     );
   }
@@ -598,16 +629,218 @@ function minorScaleOf(currency) {
   return 10 ** minorUnitsOf(currency);
 }
 
-// ../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`);
-  }
+// 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 quoted2 = answer.data;
+    if (quoted2?.currency !== asked) {
+      throw new Error(`coinbase quoted ${quoted2?.currency} when asked for ${asked}`);
+    }
+    return asMinor(quoted2.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 quoted2 = answers.filter((answer) => answer.status === "fulfilled").map((answer) => answer.value).sort((one, other) => one - other);
+    if (quoted2.length < minVenues) {
+      throw new Error(
+        `${quoted2.length} of ${tickers.length} venues quoted ${asked}, ${minVenues} wanted: ${refusals(answers)}`
+      );
+    }
+    const spread2 = spreadBpsOf(quoted2);
+    if (spread2 > maxSpread) {
+      throw new Error(
+        `venues disagree on ${asked} by ${Math.round(spread2)} bps, more than the ${maxSpread} allowed: ${quoted2.join(", ")}`
+      );
+    }
+    const price = middleOf(quoted2);
+    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(quoted2, venue, currency) {
+  const major2 = Number(quoted2);
+  if (!Number.isFinite(major2) || major2 <= 0) {
+    throw new Error(`${venue} quoted ${String(quoted2)} 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");
+var SIGN_BIT_CLEARED = 127;
+var SMALL_ORDER = [
+  "00".repeat(32),
+  `01${"00".repeat(31)}`,
+  "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05",
+  "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a",
+  `ec${"ff".repeat(30)}7f`,
+  `ed${"ff".repeat(30)}7f`,
+  `ee${"ff".repeat(30)}7f`
+];
+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);
@@ -622,6 +855,9 @@ async function verifyHex(publicKeyHex, signatureHex, payload) {
   if (!isHex(publicKeyHex) || publicKeyHex.length !== PUBLIC_KEY_BYTES * 2) {
     return false;
   }
+  if (hasSmallOrder(publicKeyHex)) {
+    return false;
+  }
   if (!isHex(signatureHex) || signatureHex.length !== SIGNATURE_BYTES * 2) {
     return false;
   }
@@ -643,8 +879,13 @@ async function verifyHex(publicKeyHex, signatureHex, payload) {
     return false;
   }
 }
-function fromBase64Url2(text2) {
-  const padded = text2.replace(/-/g, "+").replace(/_/g, "/");
+function hasSmallOrder(publicKeyHex) {
+  const point = hexToBytes(publicKeyHex);
+  point[PUBLIC_KEY_BYTES - 1] = point[PUBLIC_KEY_BYTES - 1] & SIGN_BIT_CLEARED;
+  return SMALL_ORDER.includes(bytesToHex(point));
+}
+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++) {
@@ -656,135 +897,766 @@ function asBuffer2(bytes) {
   return bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
 }
 
-// src/wire.ts
-var ASSET_CODE = "BTC";
-var ASSET_SCALE = 11;
-var REASONS = /* @__PURE__ */ new Set([
-  "address-unusable",
-  "unreachable",
-  "amount-not-accepted",
-  "cannot-prove-delivery",
-  "invoice-refused"
-]);
-function createRequestBody(params, trigger, replay) {
-  return JSON.stringify({
-    ln_addresses: params.lnAddresses,
-    incoming_amount: toAmount(params.amountMsat),
-    webhook: params.webhookUrl ? { url: params.webhookUrl } : void 0,
-    trigger: trigger ?? void 0,
-    replay
-  });
+// ../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 quoteRequestBody(params) {
-  return JSON.stringify({
-    ln_addresses: params.lnAddresses,
-    amount: toAmount(params.amountMsat)
-  });
+function paymentNamedBy(caller, paymentHash) {
+  return sha256Hex(`${caller}.payment-id.${paymentHash}`);
 }
-function quoteFromWire(body) {
-  const wire = asObject(body);
-  if (wire === null) {
-    return null;
+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");
   }
-  const lnAddress = text(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 refusals3 = refusalsFrom(wire["refusals"]);
-  if (lnAddress === null || amountMsat === null || feeMsat === null) {
-    return null;
+  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;
   }
-  if (minMsat === null || maxMsat === null || metadata === null || refusals3 === null) {
-    return null;
+  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;
   }
-  return { lnAddress, amountMsat, feeMsat, minMsat, maxMsat, metadata, refusals: refusals3 };
 }
-function paymentFromWire(body) {
-  const wire = asObject(body);
-  if (wire === null) {
-    return null;
+function publicAddress(literal) {
+  return literal.includes(":") ? ipv6IsGlobal(literal) : ipv4IsGlobal(literal);
+}
+function hostIsPublic(host) {
+  if (host.startsWith("[")) {
+    return publicAddress(host.slice(1, -1));
   }
-  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 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;
+  const name = host.replace(/\.$/, "");
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) {
+    return publicAddress(name);
   }
-  if (paymentHash === null || verifyUrl === null) {
-    return null;
+  const labels = name.split(".");
+  if (labels.length < 2 || labels.some((label) => label === "")) {
+    return false;
   }
-  if (amountMsat === null || expiresAt === null || createdAt === null) {
-    return null;
+  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;
   }
-  if (!isStatus(status)) {
-    return null;
+  const [a, b, c] = parts;
+  if (a === 0 || a === 10 || a === 127 || a >= 224) {
+    return false;
   }
-  if (preimage !== null && typeof preimage !== "string") {
-    return null;
+  if (a === 100 && b >= 64 && b < 128) {
+    return false;
   }
-  return {
-    id,
-    lnAddress,
-    amountMsat,
-    status,
-    paymentHash,
-    bolt11,
-    preimage,
-    expiresAt,
-    createdAt,
-    verifyUrl
-  };
-}
-function watchRequestBody(params, trigger) {
-  const expiresAt = new Date(params.expiresAt * 1e3);
-  if (Number.isNaN(expiresAt.getTime())) {
-    throw new TypeError(`expiresAt must be a usable unix time in seconds, got ${params.expiresAt}`);
+  if (a === 169 && b === 254) {
+    return false;
+  }
+  if (a === 172 && b >= 16 && b < 32) {
+    return false;
+  }
+  if (a === 192 && (b === 168 || b === 0 && (c === 0 || c === 2))) {
+    return false;
+  }
+  if (a === 198 && (b === 18 || b === 19 || b === 51 && c === 100)) {
+    return false;
+  }
+  if (a === 203 && b === 0 && c === 113) {
+    return false;
+  }
+  return true;
+}
+function ipv6IsGlobal(literal) {
+  const groups = ipv6Groups(literal.toLowerCase());
+  if (groups.length !== 8 || groups.some(Number.isNaN)) {
+    return false;
+  }
+  const [first, second, third, fourth, fifth, sixth, high, low] = groups;
+  const embedded = (one, other) => ipv4IsGlobal(`${one >> 8}.${one & 255}.${other >> 8}.${other & 255}`);
+  const zeroBefore = (count) => groups.slice(0, count).every((group) => group === 0);
+  if (zeroBefore(5) && sixth === 65535) {
+    return embedded(high, low);
+  }
+  if (zeroBefore(6) || zeroBefore(4) && fifth === 65535 && sixth === 0) {
+    return false;
+  }
+  if (first === 100 && second === 65435) {
+    return third === 0 && fourth === 0 && fifth === 0 && sixth === 0 && embedded(high, low);
+  }
+  if (first === 8194) {
+    return embedded(second, third);
+  }
+  if (first === 8193 && second === 0) {
+    return false;
+  }
+  if (first === 256 && second === 0 && third === 0 && fourth === 0) {
+    return false;
+  }
+  if ((first & 65024) === 64512 || (first & 65280) === 65280) {
+    return false;
+  }
+  if ((first & 65472) === 65152 || (first & 65472) === 65216) {
+    return false;
   }
+  return true;
+}
+function ipv6Groups(address) {
+  const halves = withDottedTailAsGroups(address).split("::");
+  const [head = "", tail] = halves;
+  const left = head.split(":").filter((group) => group !== "");
+  const right = (tail ?? "").split(":").filter((group) => group !== "");
+  const missing = 8 - left.length - right.length;
+  if (halves.length > 2 || missing < 0) {
+    return [Number.NaN];
+  }
+  const gap = tail === void 0 ? [] : Array(missing).fill("0");
+  return [...left, ...gap, ...right].map(
+    (group) => /^[0-9a-f]{1,4}$/.test(group) ? parseInt(group, 16) : Number.NaN
+  );
+}
+function withDottedTailAsGroups(address) {
+  const dotted = /^(.*:)(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(address);
+  if (dotted === null) {
+    return address;
+  }
+  const [a, b, c, d] = dotted[2].split(".").map(Number);
+  if ([a, b, c, d].some((part) => part > 255)) {
+    return `${dotted[1]}x`;
+  }
+  return `${dotted[1]}${(a << 8 | b).toString(16)}:${(c << 8 | d).toString(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();
+    if (sent.staysOnOrigin && !sameOrigin(target, next)) {
+      throw new Error(`${target} redirected off its own origin, to ${next}`);
+    }
+    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 = Object.fromEntries(
+    Object.entries(sent.headers ?? {}).filter(([name]) => name.toLowerCase() !== "content-type")
+  );
+  return { ...sent, method: "GET", headers, body: void 0 };
+}
+function withoutCredentials(sent) {
+  const headers = Object.fromEntries(
+    Object.entries(sent.headers ?? {}).filter(
+      ([name]) => !CREDENTIALS.includes(name.toLowerCase())
+    )
+  );
+  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 quote(send, addresses, amountMsat) {
+  const served = await firstThatServes(
+    addresses,
+    (address2, deadline) => probe(send, address2, amountMsat, deadline)
+  );
+  const { address, pay } = served.won;
+  return {
+    won: {
+      address,
+      minMsat: pay.minSendable,
+      maxMsat: pay.maxSendable,
+      metadata: pay.metadata
+    },
+    refusals: served.refusals
+  };
+}
+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);
+}
+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 };
+}
+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`
+    );
+  }
+  return {
+    address,
+    bolt11: invoice.pr,
+    verifyUrl: invoice.verify,
+    paymentHash: issued.paymentHash,
+    expiresAt: issued.expiresAt
+  };
+}
+async function answered(send, url, deadline) {
+  try {
+    return await fetchJson(send, url, deadline);
+  } catch (cause) {
+    throw new WalletRefused("unreachable", String(cause));
+  }
+}
+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, { staysOnOrigin: true });
+  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 parsed = new URL(`https://${domain}/`);
+    return parsed.host === domain.toLowerCase() && parsed.pathname === "/" && parsed.search === "" && parsed.hash === "";
+  } catch {
+    return false;
+  }
+}
+async function fetchJson(send, url, deadline) {
+  return (await answeredJson(send, url, { deadline })).said;
+}
+async function answeredJson(send, url, sent) {
+  const answer = await ask(send, url, { headers: { accept: "application/json" }, ...sent });
+  if (!answer.ok) {
+    throw new Error(`${url} answered ${answer.status}`);
+  }
+  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 };
+}
+
+// ../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;
+      try {
+        settle(
+          new Response(
+            CARRIES_NO_BODY.includes(status) ? null : Readable.toWeb(answer),
+            { status, headers: headersOf(answer.headers) }
+          )
+        );
+      } catch (unreadable) {
+        answer.destroy();
+        fail(new Error(`${url} answered with something HTTP cannot carry`, { cause: unreadable }));
+      }
+    });
+    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/verify.ts
+var HTTP_TIMEOUT_MS2 = 15e3;
+var ISSUED_SKEW_SECS = 300;
+var NAMES_AN_ADDRESS = ["text/identifier", "text/email"];
+var DEFAULT_WRAP_PROPORTION = 0.01;
+var DEFAULT_WRAP_BASE_MSAT = 1e3;
+async function proveOrigin(payment, asked, askedAt) {
+  const cheat = (code) => new GatewayCheatError(code, payment.id);
+  const listed2 = asked.paidTo.find((address) => equalIgnoringCase(address, payment.lnAddress));
+  if (listed2 === void 0) {
+    throw cheat("address_not_requested");
+  }
+  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 !== asked.amountMsat) {
+    throw cheat("amount_mismatch");
+  }
+  if (askedAt !== void 0 && (invoice.issuedAt ?? 0) < askedAt - ISSUED_SKEW_SECS) {
+    throw cheat("invoice_stale");
+  }
+  const payRequest = await payRequestFor(listed2, payment);
+  if (typeof payRequest.metadata !== "string" || typeof payRequest.callback !== "string") {
+    throw new UnverifiedRecipientError(payment.lnAddress, payment.id, "no payRequest served");
+  }
+  if (!namesTheAddress(payRequest.metadata, listed2)) {
+    throw new UnverifiedRecipientError(
+      payment.lnAddress,
+      payment.id,
+      "its metadata names no text/identifier for this address, so no invoice binds to it"
+    );
+  }
+  if (invoice.descriptionHash !== sha256Hex(payRequest.metadata)) {
+    throw cheat("description_hash_mismatch");
+  }
+  if (!sameOrigin(payment.verifyUrl, payRequest.callback)) {
+    throw cheat("verify_url_foreign");
+  }
+  const issued = await reachable(payment.verifyUrl, payment);
+  if (typeof issued.pr !== "string" || !equalIgnoringCase(issued.pr, payment.bolt11)) {
+    throw cheat("invoice_not_issued");
+  }
+  if (askedAt !== void 0 && issued.settled === true) {
+    throw cheat("invoice_settled");
+  }
+}
+function namesTheAddress(metadata, address) {
+  try {
+    const entries = JSON.parse(metadata);
+    return Array.isArray(entries) && entries.some(
+      (entry) => Array.isArray(entry) && NAMES_AN_ADDRESS.includes(entry[0]) && typeof entry[1] === "string" && equalIgnoringCase(entry[1], address)
+    );
+  } catch {
+    return false;
+  }
+}
+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;
+  }
+  if (!preimageMatchesHash(verified.preimage, payment.paymentHash)) {
+    throw new GatewayCheatError("preimage_mismatch", payment.id);
+  }
+  return verified.preimage;
+}
+function carriesProof(report) {
+  if (report.status !== "paid" || report.preimage === null) {
+    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(report.preimage, report.paymentHash);
+}
+function wrapFeeCeiling(amountMsat, allowance) {
+  const proportional = amountMsat * (allowance?.proportion ?? DEFAULT_WRAP_PROPORTION);
+  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 refuse2 = (code, detail) => {
+    throw new WrapRefusedError(code, detail);
+  };
+  if (offered.paymentHash === null || offered.amountMsat === null || offered.expiresAt === null) {
+    refuse2("undecodable", "the wrapped invoice carries no hash, amount or expiry");
+  }
+  if (owed.paymentHash === null || owed.amountMsat === null || owed.expiresAt === null) {
+    refuse2("undecodable", "the recipient's invoice carries no hash, amount or expiry");
+  }
+  if (offered.paymentHash?.toLowerCase() !== owed.paymentHash?.toLowerCase()) {
+    refuse2("hash_mismatch", "settling the wrap would not settle the recipient");
+  }
+  const asked = offered.amountMsat ?? 0;
+  const due = owed.amountMsat ?? 0;
+  if (asked < due) {
+    refuse2("amount_below_recipient", `${asked} msat cannot forward ${due} msat`);
+  }
+  const ceiling = wrapFeeCeiling(due, allowance);
+  if (asked - due > ceiling) {
+    refuse2("fee_above_allowance", `${asked - due} msat over ${due}, and ${ceiling} was allowed`);
+  }
+  if ((owed.expiresAt ?? 0) <= (offered.expiresAt ?? 0)) {
+    refuse2("recipient_expires_first", "the operator could be paid and find it cannot deliver");
+  }
+}
+async function payRequestFor(listed2, payment) {
+  const at = listed2.indexOf("@");
+  const name = listed2.slice(0, at);
+  const domain = listed2.slice(at + 1).toLowerCase();
+  if (at < 1 || !publicHttps(`https://${domain}/`)) {
+    throw new UnverifiedRecipientError(payment.lnAddress, payment.id, "not a usable address");
+  }
+  return reachable(`https://${domain}/.well-known/lnurlp/${name}`, payment);
+}
+async function reachable(url, payment) {
+  try {
+    if (!publicHttps(url)) {
+      throw new Error(`${url} is not a public https URL`);
+    }
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(HTTP_TIMEOUT_MS2),
+      headers: { accept: "application/json" }
+    });
+    if (response.redirected && !sameOrigin(response.url, url)) {
+      throw new Error(`redirected off its own origin, to ${response.url}`);
+    }
+    if (!response.ok) {
+      throw new Error(`answered ${response.status}`);
+    }
+    const body = JSON.parse(await boundedText(response));
+    if (body === null || typeof body !== "object") {
+      throw new Error("answered with no JSON object");
+    }
+    return body;
+  } catch (cause) {
+    throw new UnverifiedRecipientError(payment.lnAddress, payment.id, cause);
+  }
+}
+async function boundedText(response) {
+  const reader = response.body?.getReader();
+  const decoder = new TextDecoder();
+  let text3 = "";
+  let bytes = 0;
+  for (let chunk = await reader?.read(); chunk && !chunk.done; chunk = await reader?.read()) {
+    bytes += chunk.value.length;
+    if (bytes > BODY_LIMIT_BYTES) {
+      await reader?.cancel();
+      throw new Error(`answered with more than the ${BODY_LIMIT_BYTES} bytes a proof reads`);
+    }
+    text3 += decoder.decode(chunk.value, { stream: true });
+  }
+  return text3 + decoder.decode();
+}
+function equalIgnoringCase(one, other) {
+  return one.toLowerCase() === other.toLowerCase();
+}
+
+// src/wire.ts
+var ASSET_CODE = "BTC";
+var ASSET_SCALE = 11;
+var REASONS = /* @__PURE__ */ new Set([
+  "address-unusable",
+  "unreachable",
+  "amount-not-accepted",
+  "cannot-prove-delivery",
+  "invoice-refused"
+]);
+function createRequestBody(priced2, webhookUrl, trigger, replay) {
   return JSON.stringify({
-    payment_hash: params.paymentHash,
-    verify_url: params.verifyUrl,
-    expires_at: expiresAt.toISOString(),
+    ln_addresses: priced2.paidTo,
+    incoming_amount: toAmount(priced2.amountMsat),
+    webhook: webhookUrl ? { url: webhookUrl } : void 0,
     trigger: trigger ?? void 0,
-    replay: params.replay,
-    sealed: params.sealed,
-    webhook: params.webhookUrl ? { url: params.webhookUrl } : void 0
+    replay
   });
 }
-function settlementFromWire(body) {
+function quoteRequestBody(priced2) {
+  return JSON.stringify({
+    ln_addresses: priced2.paidTo,
+    amount: toAmount(priced2.amountMsat)
+  });
+}
+function quoteFromWire(body) {
   const wire = asObject(body);
   if (wire === null) {
     return null;
   }
-  const id = text(wire["id"]);
-  const paymentHash = text(wire["payment_hash"]);
-  const settledAt = secondsFrom(wire["settled_at"]);
-  const status = wire["status"];
-  const preimage = wire["preimage"] ?? null;
-  if (id === null || paymentHash === null || settledAt === null || !isStatus(status)) {
+  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 = text2(wire["metadata"]);
+  const refusals3 = refusalsFrom(wire["refusals"]);
+  if (lnAddress === null || amountMsat === null || feeMsat === null) {
     return null;
   }
-  if (preimage !== null && typeof preimage !== "string") {
+  if (minMsat === null || maxMsat === null || metadata === null || refusals3 === null) {
     return null;
   }
-  return { id, status, paymentHash, preimage, settledAt };
+  return { lnAddress, amountMsat, feeMsat, minMsat, maxMsat, metadata, refusals: refusals3 };
 }
-function triggerEventFromWire(body) {
+function paymentFromWire(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 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"];
@@ -802,41 +1674,80 @@ function triggerEventFromWire(body) {
   if (sealed !== null && typeof sealed !== "string") {
     return null;
   }
-  return {
+  const reported = {
     id,
-    kind: kindOf(wire),
+    status,
     paymentHash,
     verifyUrl,
-    status,
     preimage,
     expiresAt,
     createdAt,
-    sealed,
-    lnAddress: text(wire["ln_address"]),
-    amountMsat: wire["incoming_amount"] === void 0 ? null : msatFrom(wire["incoming_amount"], 1)
+    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(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 ${handover.expiresAt}`
+    );
+  }
+  return JSON.stringify({
+    payment_hash: handover.paymentHash,
+    verify_url: handover.verifyUrl,
+    expires_at: expiresAt.toISOString(),
+    trigger: trigger ?? void 0,
+    replay: handover.replay,
+    sealed: handover.sealed,
+    webhook: handover.webhookUrl ? { url: handover.webhookUrl } : void 0
+  });
+}
+function settlementFromWire(body) {
+  const wire = asObject(body);
+  if (wire === null) {
+    return null;
+  }
+  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;
+  if (id === null || paymentHash === null || settledAt === null || !isStatus(status)) {
+    return null;
+  }
+  if (preimage !== null && typeof preimage !== "string") {
+    return null;
+  }
+  return { id, status, paymentHash, preimage, settledAt };
 }
 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)) {
@@ -844,7 +1755,7 @@ function asObject(value) {
   }
   return value;
 }
-function text(value) {
+function text2(value) {
   return typeof value === "string" ? value : null;
 }
 function msatFrom(value, least) {
@@ -859,8 +1770,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)) {
@@ -869,7 +1780,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;
@@ -890,118 +1801,70 @@ 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 : proved(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 : proved(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 {
+  if (!recent(timestamp, options.toleranceSecs ?? DEFAULT_TOLERANCE_SECS)) {
     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 (!signature.startsWith(GATEWAY_KEY_PREFIX)) {
     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);
+  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 answerWebhookChallenge(body, signature, credential, timestamp, options = {}) {
-  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) {
-    return null;
-  }
-  const nonce = challenged(typeof body === "string" ? body : new TextDecoder().decode(body));
-  return nonce === null ? null : JSON.stringify({ nonce });
+function proved(read) {
+  return read !== null && read.status === "paid" && !carriesProof(read) ? null : read;
 }
-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;
     }
@@ -1010,17 +1873,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)) {
@@ -1028,14 +1880,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
@@ -1044,83 +1890,120 @@ 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) {
+var MAX_REFERENCE_CHARS = 60;
+async function bankTransfer(gateway, params) {
   const currency = params.currency ?? DEFAULT_CURRENCY;
-  refuseUnusable(params, currency);
-  await refuseAnOpenGateway(params);
-  const spd = shortPaymentDescriptor(params, currency);
-  const subject = subjectOf(params.reference, params.amountMinor, currency);
-  const polling = new URL(params.verifyUrl);
-  polling.searchParams.set("ref", params.reference);
-  polling.searchParams.set("minor", String(params.amountMinor));
-  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({
-    paymentHash: hashOf(await hmacHex(params.secret, `preimage|${subject}`)),
+  const iban = accountOf(params.iban);
+  refuseUnusable(params, iban, currency);
+  await refuseAnOpenGateway(gateway, params);
+  const spd = shortPaymentDescriptor(params, iban, currency);
+  const subject = subjectOf({
+    iban,
+    amountMinor: params.amountMinor,
+    currency,
+    expiresAt: params.expiresAt,
+    reference: params.reference
+  });
+  const verifyUrl = await answeredAt(params, subject);
+  const paymentHash = hashOf(await hmacHex(params.secret, `preimage|${subject}`));
+  const watched = await gateway.watch({
+    paymentHash,
     verifyUrl,
     expiresAt: params.expiresAt,
     trigger: params.trigger,
     replay: params.replay,
-    sealed: params.sealed,
+    sealed: params.sealed ? await seal(params.sealed.secret, JSON.stringify(params.sealed.data), paymentHash) : void 0,
     webhookUrl: params.webhookUrl
   });
-  return { id: watched.id, paymentHash: watched.paymentHash, verifyUrl, spd };
+  return { id: watched.id, paymentHash, verifyUrl, spd };
 }
 function bankVerifyEndpoint(config) {
+  refuseAWeakSecret(config.secret);
+  const answersFor = accountOf(config.iban);
+  if (!IBAN.test(answersFor)) {
+    throw new Error(`${config.iban} is not an IBAN, so this endpoint answers for no account`);
+  }
   const paced = {
     "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;
     }
-    const asked = readQuery(new URL(request.url));
-    if (asked === null) {
+    const sealed = new URL(request.url).searchParams.get("q");
+    if (sealed === null) {
       return Response.json({ settled: false }, { status: 400 });
     }
-    const subject = subjectOf(asked.reference, asked.amountMinor, asked.currency);
-    const expected = await hmacHex(config.secret, `verify|${subject}`);
-    if (!equalInConstantTime(asked.signature, expected)) {
+    const subject = await unseal(config.secret, sealed);
+    const asked = subject === null ? null : askedFrom(subject);
+    if (asked === null || asked.iban !== answersFor) {
       return Response.json({ settled: false }, { status: 403 });
     }
-    const since = unixNow() - (config.lookBackSecs ?? DEFAULT_LOOK_BACK_SECS);
-    const landed = (await config.statement(since)).some((credit) => pays(credit, asked));
-    if (!landed) {
-      return Response.json({ settled: false }, { headers: paced });
-    }
-    return Response.json(
-      { settled: true, preimage: await hmacHex(config.secret, `preimage|${subject}`) },
-      { headers: paced }
-    );
+    const preimage = await creditedPreimage({
+      secret: config.secret,
+      asked,
+      statement: config.statement,
+      lookBackSecs: config.lookBackSecs
+    });
+    return preimage === null ? Response.json({ settled: false }, { headers: paced }) : Response.json({ settled: true, preimage }, { headers: paced });
   };
 }
-function readQuery(url) {
-  const reference = url.searchParams.get("ref");
-  const minor = Number(url.searchParams.get("minor"));
-  const currency = url.searchParams.get("cc");
-  const signature = url.searchParams.get("sig");
-  if (!reference || !currency || !signature) {
+async function answeredAt(params, subject) {
+  if (params.answerBy === "agent") {
+    return `agent:${(await callerKey(params.secret)).publicKeyHex}`;
+  }
+  const polling = new URL(params.verifyUrl ?? "");
+  polling.searchParams.set("q", await sealStable(params.secret, subject));
+  return polling.toString();
+}
+async function creditedPreimage(params) {
+  const since = unixNow() - (params.lookBackSecs ?? DEFAULT_LOOK_BACK_SECS);
+  const landed = (await params.statement(since)).some((credit) => pays(credit, params.asked));
+  if (!landed) {
+    return null;
+  }
+  return await hmacHex(params.secret, `preimage|${subjectOf(params.asked)}`);
+}
+function askedFrom(subject) {
+  const [iban, minorText, currency, expiresText, ...rest] = subject.split("|");
+  const reference = rest.join("|");
+  const amountMinor = Number(minorText);
+  const expiresAt = Number(expiresText);
+  if (!iban || !currency || reference.length === 0) {
     return null;
   }
-  if (!Number.isInteger(minor) || minor <= 0) {
+  if (!Number.isInteger(amountMinor) || amountMinor <= 0 || !Number.isSafeInteger(expiresAt)) {
     return null;
   }
-  return { reference, amountMinor: minor, currency, signature };
+  return { iban, reference, amountMinor, currency, expiresAt };
 }
 function pays(credit, asked) {
-  return credit.amountMinor === asked.amountMinor && credit.currency.toUpperCase() === asked.currency.toUpperCase() && credit.reference.toUpperCase().includes(asked.reference.toUpperCase());
+  return credit.amountMinor === asked.amountMinor && credit.currency.toUpperCase() === asked.currency.toUpperCase() && namesOnly(credit.reference, asked.reference);
+}
+function namesOnly(written, reference) {
+  const wanted = reference.toUpperCase();
+  const alike = [...written.toUpperCase().matchAll(wordsShapedLike(wanted))].map(([word]) => word);
+  return alike.includes(wanted) && (!/\d/.test(wanted) || alike.every((word) => word === wanted));
+}
+function wordsShapedLike(reference) {
+  const shape = [...reference].map((char) => {
+    if (/\d/.test(char)) {
+      return "\\d";
+    }
+    return /\p{L}/u.test(char) ? "\\p{L}" : char.replace(/[\^$\\.*+?()[\]{}|/]/g, "\\$&");
+  }).join("");
+  return new RegExp(`(?<![\\p{L}\\p{N}])${shape}(?![\\p{L}\\p{N}])`, "gu");
 }
-function subjectOf(reference, amountMinor, currency) {
-  return `${reference}|${amountMinor}|${currency.toUpperCase()}`;
+function subjectOf({ iban, amountMinor, currency, expiresAt, reference }) {
+  return `${iban}|${amountMinor}|${currency.toUpperCase()}|${expiresAt}|${reference}`;
 }
 function hashOf(preimage) {
   return bytesToHex(sha256(hexToBytes(preimage)));
 }
-function shortPaymentDescriptor(params, currency) {
+function shortPaymentDescriptor(params, iban, currency) {
   const fields = [
-    `ACC:${params.iban}`,
+    `ACC:${iban}`,
     `AM:${major(params.amountMinor, currency)}`,
     `CC:${currency.toUpperCase()}`,
     `MSG:${params.reference}`
@@ -1133,27 +2016,36 @@ 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(
-    "this gateway serves callers with no token, so it is not yours, and its operator would read the amount and the reference off every verify URL. Point at one that answers 401 to a stranger, or say allowPublicGateway"
+    "this gateway serves callers with no token, so it is not yours, and its operator would learn every watch you place. Point at one that answers 401 to a stranger, or say allowPublicGateway"
   );
 }
-function refuseUnusable(params, currency) {
-  if (!IBAN.test(params.iban)) {
+function refuseUnusable(params, iban, currency) {
+  refuseAWeakSecret(params.secret);
+  if (params.answerBy !== "agent" && params.verifyUrl === void 0) {
+    throw new Error("a transfer the gateway polls needs the verify url it is polled at");
+  }
+  if (!IBAN.test(iban)) {
     throw new Error(`${params.iban} is not an IBAN`);
   }
-  if (!Number.isInteger(params.amountMinor) || params.amountMinor <= 0) {
+  if (!Number.isSafeInteger(params.amountMinor) || params.amountMinor <= 0) {
     throw new Error("amountMinor must be a whole number of minor units above zero");
   }
   if (params.reference.length === 0) {
     throw new Error("a transfer with no reference cannot be found");
   }
+  if (params.reference.length > MAX_REFERENCE_CHARS) {
+    throw new Error(
+      `a reference is at most ${MAX_REFERENCE_CHARS} characters, as many as a QR payment's message carries and its sealed query hides`
+    );
+  }
   if (params.reference.includes(FORBIDDEN_IN_SPD)) {
     throw new Error("a reference cannot contain an asterisk, it separates the QR fields");
   }
@@ -1161,226 +2053,533 @@ function refuseUnusable(params, currency) {
     throw new Error("a variable symbol is up to ten digits");
   }
 }
+function accountOf(iban) {
+  return iban.replace(/\s+/g, "").toUpperCase();
+}
 function unixNow() {
   return Math.floor(Date.now() / 1e3);
 }
 
-// ../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/qr.ts
+import { encode } from "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 paymentNamedBy(caller, paymentHash) {
-  return sha256Hex(`${caller}.payment-id.${paymentHash}`);
+function invoiceToSvg(destination, options) {
+  return svgOf(toLightningUri(destination), options);
 }
-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 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 } = 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);
+    const wallet = opened === null ? null : relayedFrom(opened);
+    if (wallet === null) {
+      return Response.json({ settled: false }, { status: 403 });
+    }
+    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 }
+    );
   };
 }
-function spoken(timestamp, method, path, body) {
-  return new TextEncoder().encode(
-    `${timestamp}.${method.toUpperCase()}.${path}.${sha256Hex(body)}`
-  );
+function relayedFrom(opened) {
+  try {
+    const said = JSON.parse(opened);
+    return typeof said?.url === "string" && typeof said.hash === "string" ? { url: said.url, hash: said.hash } : null;
+  } catch {
+    return null;
+  }
+}
+async function relayedVerifyUrl(endpoint, wallet, secret) {
+  const relayed = new URL(endpoint);
+  relayed.searchParams.set(WALLET, await seal(secret, JSON.stringify(wallet)));
+  return relayed.toString();
 }
 
-// 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;
+// 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: config.sealed && { secret: config.sealed.secret, data: config.sealed.data(order) },
+      variableSymbol: config.variableSymbol?.(order),
+      webhookUrl: config.webhookUrl,
+      allowPublicGateway: config.allowPublicGateway
+    });
+    return {
+      id: transfer.id,
+      paymentHash: transfer.paymentHash,
+      rail: config.name ?? BANK,
+      scan: transfer.spd,
+      qr: transfer.spd,
+      expiresAt
+    };
+  };
+}
+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,
+      paymentHash: payment.paymentHash,
+      rail: config.name ?? LIGHTNING,
+      scan: payment.bolt11,
+      qr: toLightningUri(payment.bolt11),
+      expiresAt: payment.expiresAt
+    };
+  };
+}
+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: config.sealed ? await seal(
+        config.sealed.secret,
+        JSON.stringify(config.sealed.data(order)),
+        resolved2.paymentHash
+      ) : void 0,
+      webhookUrl: config.webhookUrl
+    });
+    return {
+      id: watched.id,
+      paymentHash: resolved2.paymentHash,
+      rail: config.name ?? LIGHTNING,
+      scan: resolved2.bolt11,
+      qr: toLightningUri(resolved2.bolt11),
+      expiresAt: resolved2.expiresAt
+    };
+  };
+}
+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;
   }
-};
-var WrapRefusedError = class extends Error {
-  code;
-  constructor(code, detail) {
-    super(`wrapped invoice refused: ${code}, ${detail}`);
-    this.name = "WrapRefusedError";
-    this.code = code;
+}
+async function msatForOrder(order, amount, rate) {
+  if (amount !== void 0) {
+    return await amountNow(amount(order));
   }
-};
-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;
+  return msat(msatFor(order.amountMinor, await (rate ?? medianOf())(order.currency)));
+}
+var Rails = class {
+  constructor(gateway) {
+    this.gateway = gateway;
   }
-};
-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;
+  gateway;
+  /** Lightning, with the gateway minting against a priority list of addresses */
+  lightning(config) {
+    return lightningRail(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;
+  /**
+   * Lightning, with the invoice resolved here so the gateway is told neither the
+   * address nor the amount
+   */
+  blindLightning(config) {
+    return blindLightningRail(this.gateway, config);
   }
-};
-var NoWalletAvailableError = class extends ProblemError {
-  wallets;
-  constructor(problem, wallets) {
-    super({ ...problem, type: NO_WALLET_AVAILABLE });
-    this.name = "NoWalletAvailableError";
-    this.wallets = wallets;
+  /** A bank transfer, proved the way a Lightning payment is */
+  bank(config) {
+    return bankRail(this.gateway, config);
+  }
+  /**
+   * 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 DEFAULT_WRAP_PROPORTION = 0.01;
-var DEFAULT_WRAP_BASE_MSAT = 1e3;
-async function proveOrigin(payment, request) {
-  const cheat = (code) => new GatewayCheatError(code, payment.id);
-  const listed = request.lnAddresses.find(
-    (address) => equalIgnoringCase(address, payment.lnAddress)
-  );
-  if (listed === void 0) {
-    throw cheat("address_not_requested");
-  }
-  if (payment.amountMsat !== request.amountMsat) {
-    throw cheat("amount_mismatch");
-  }
-  const invoice = decodeInvoice(payment.bolt11);
-  if (invoice.paymentHash === null || !equalIgnoringCase(invoice.paymentHash, payment.paymentHash)) {
-    throw cheat("hash_mismatch");
+// 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, { ...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, { ...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 (invoice.amountMsat !== request.amountMsat) {
-    throw cheat("amount_mismatch");
+  if (ended.kind !== "minted") {
+    throw new Error(`payment ${ended.id} came back without the invoice it was minted with`);
   }
-  const payRequest = await payRequestFor(listed, payment);
-  if (typeof payRequest.metadata !== "string" || typeof payRequest.callback !== "string") {
-    throw new UnverifiedRecipientError(payment.lnAddress, payment.id, "no payRequest served");
+  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 winner = await quoted(gateway, config, least);
+  const nonce = randomNonce();
+  const callback = new URL(config.baseUrl ?? `${url.origin}${url.pathname}`);
+  callback.searchParams.set("to", winner.address);
+  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, winner.address, least, most, nonce));
+  return Response.json({
+    tag: "payRequest",
+    callback: callback.toString(),
+    metadata: winner.metadata,
+    minSendable: least,
+    maxSendable: most
+  });
+}
+async function quoted(gateway, config, amountMsat) {
+  if (config.blind) {
+    const { won } = await quote(
+      config.send ?? pinnedToTheAddressWeVerified,
+      listed(config.paidTo),
+      amountMsat
+    );
+    return won;
   }
-  if (invoice.descriptionHash !== sha256Hex(payRequest.metadata)) {
-    throw cheat("description_hash_mismatch");
+  const { lnAddress, metadata } = await gateway.quote({
+    paidTo: config.paidTo,
+    amount: msat(amountMsat)
+  });
+  return { address: lnAddress, metadata };
+}
+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");
+  }
+  if (!listed(config.paidTo).some((one) => one.toLowerCase() === address.toLowerCase())) {
+    return refuse(`${address} is not paid through this trigger`);
+  }
+  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`
+    );
   }
-  if (!sameOrigin(payment.verifyUrl, payRequest.callback)) {
-    throw cheat("verify_url_foreign");
+  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)), minted.paymentHash) : void 0
+    });
+  } catch (refused) {
+    if (!alreadyWatched(refused)) {
+      throw refused;
+    }
   }
-  const issued = await reachable(payment.verifyUrl, payment);
-  if (typeof issued.pr !== "string" || !equalIgnoringCase(issued.pr, payment.bolt11)) {
-    throw cheat("invoice_not_issued");
+  return { bolt11: resolved2.bolt11, verifyUrl: resolved2.verifyUrl };
+}
+function listed(paidTo) {
+  return typeof paidTo === "string" ? [paidTo] : paidTo;
+}
+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;
 }
-async function proveSettlement(payment, request) {
-  await proveOrigin(payment, request);
-  const verified = await reachable(payment.verifyUrl, payment);
-  if (verified.settled !== true || typeof verified.preimage !== "string") {
-    return null;
+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;
   }
-  if (!preimageMatchesHash(verified.preimage, payment.paymentHash)) {
-    throw new GatewayCheatError("preimage_mismatch", payment.id);
+  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);
   }
-  return verified.preimage;
-}
-function isProvablyPaid(payment) {
-  if (payment.status !== "paid" || payment.preimage === null) {
-    return false;
+  /** Trades the watch secret for a one minute socket ticket, refusing anyone without it */
+  watchTicket(config) {
+    return watchTicketEndpoint(this.gateway, config);
   }
-  const invoiceHash = decodeInvoice(payment.bolt11).paymentHash;
-  if (invoiceHash === null || !equalIgnoringCase(invoiceHash, payment.paymentHash)) {
-    return false;
+  /**
+   * 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);
   }
-  return preimageMatchesHash(payment.preimage, invoiceHash);
-}
-function wrapFeeCeiling(amountMsat, allowance) {
-  const proportional = amountMsat * (allowance?.proportion ?? DEFAULT_WRAP_PROPORTION);
-  return 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) => {
-    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");
+  /**
+   * 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);
   }
-  if (owed.paymentHash === null || owed.amountMsat === null || owed.expiresAt === null) {
-    refuse("undecodable", "the recipient's invoice carries no hash, amount or expiry");
+  /** The verify endpoint a bank rail is polled at, answering off your own statement */
+  bankVerify(config) {
+    return bankVerifyEndpoint(config);
   }
-  if (offered.paymentHash?.toLowerCase() !== owed.paymentHash?.toLowerCase()) {
-    refuse("hash_mismatch", "settling the wrap would not settle the recipient");
+  /**
+   * 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 });
+    };
   }
-  const asked = offered.amountMsat ?? 0;
-  const due = owed.amountMsat ?? 0;
-  if (asked < due) {
-    refuse("amount_below_recipient", `${asked} msat cannot forward ${due} msat`);
+  /** 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);
   }
-  const ceiling = wrapFeeCeiling(due, allowance);
-  if (asked - due > ceiling) {
-    refuse("fee_above_allowance", `${asked - due} msat over ${due}, and ${ceiling} was allowed`);
+  /** 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);
   }
-  if ((owed.expiresAt ?? 0) <= (offered.expiresAt ?? 0)) {
-    refuse("recipient_expires_first", "the operator could be paid and find it cannot deliver");
+  /** 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 function payRequestFor(listed, payment) {
-  const at = listed.indexOf("@");
-  const name = listed.slice(0, at);
-  const domain = listed.slice(at + 1).toLowerCase();
-  if (at < 1 || !publicHttps(`https://${domain}/`)) {
-    throw new UnverifiedRecipientError(payment.lnAddress, payment.id, "not a usable address");
+  async credential(handlers) {
+    return handlers.credential ?? { publicKey: await this.gateway.webhookKey() };
   }
-  return reachable(`https://${domain}/.well-known/lnurlp/${name}`, payment);
-}
-async function reachable(url, payment) {
-  try {
-    if (!publicHttps(url)) {
-      throw new Error(`${url} is not a public https URL`);
-    }
-    const response = await fetch(url, {
-      signal: AbortSignal.timeout(HTTP_TIMEOUT_MS),
-      headers: { accept: "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`answered ${response.status}`);
-    }
-    const body = await response.json();
-    if (body === null || typeof body !== "object") {
-      throw new Error("answered with no JSON object");
-    }
-    return body;
-  } catch (cause) {
-    throw new UnverifiedRecipientError(payment.lnAddress, payment.id, cause);
+};
+async function acted(settlement, handlers) {
+  if (carriesProof(settlement)) {
+    await handlers.onSettled?.(settlement);
+    return new Response("ok");
   }
-}
-function equalIgnoringCase(one, other) {
-  return one.toLowerCase() === other.toLowerCase();
+  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
@@ -1402,35 +2601,62 @@ 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 askFromWire(raw) {
+  let said;
+  try {
+    said = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof said !== "object" || said === null) {
+    return null;
+  }
+  const fields = said;
+  const ask2 = fields["ask"];
+  const paymentHash = fields["payment_hash"];
+  return typeof ask2 === "string" && typeof paymentHash === "string" ? { ask: ask2, paymentHash } : null;
+}
+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;
   token;
+  handedOut = /* @__PURE__ */ new Map();
   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.verify = options?.verify ?? true;
+    this.baseUrl = gatewayAt(baseUrl);
     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}`, {
@@ -1438,14 +2664,25 @@ 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 askedAt = Math.floor(Date.now() / 1e3);
+    const asked = await priced(charge);
     const sent = createRequestBody(
-      params,
+      asked,
+      charge.webhookUrl,
       options?.trigger ? sha256Hex(unguessable(options.trigger)) : null,
       options?.replay
     );
@@ -1461,10 +2698,9 @@ var ThunderBridge = class {
     if (!response.ok) {
       throw await problemFrom(response);
     }
-    const payment = await paymentFrom(response);
-    if (this.verify) {
-      await proveOrigin(payment, params);
-    }
+    const payment = await mintedFrom(response);
+    await proveOrigin(payment, asked, askedAt);
+    this.handOut(payment, options?.idempotencyKey ?? null);
     return payment;
   }
   /**
@@ -1474,8 +2710,9 @@ 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 asked = await priced(charge);
+    const sent = quoteRequestBody(asked);
     const response = await fetch(`${this.baseUrl}/quotes`, {
       method: "POST",
       headers: await this.sending("/quotes", sent),
@@ -1484,22 +2721,31 @@ var ThunderBridge = class {
     if (!response.ok) {
       throw await problemFrom(response);
     }
-    const quote = quoteFromWire(await response.json().catch(() => null));
-    if (quote === null) {
+    const quote2 = quoteFromWire(await response.json().catch(() => null));
+    if (quote2 === null) {
       throw new ProblemError({
         status: response.status,
         title: "The gateway answered with something that is not a quote"
       });
     }
-    return quote;
+    if (!asked.paidTo.some((address) => address.toLowerCase() === quote2.lnAddress.toLowerCase())) {
+      throw new GatewayCheatError("address_not_requested", "");
+    }
+    return quote2;
   }
-  /** 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);
@@ -1513,26 +2759,13 @@ 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) {
-    const path = `/incoming-payments/${encodeURIComponent(id)}`;
+  async payment(held) {
+    const path = `/incoming-payments/${encodeURIComponent(held.id)}`;
     const response = await fetch(`${this.baseUrl}${path}`, {
       headers: await this.reading("GET", path)
     });
@@ -1542,14 +2775,7 @@ var ThunderBridge = class {
     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"
-      });
-    }
-    return this.proven(watched);
+    return this.proven(await paymentFrom(response), held);
   }
   /**
    * List what this gateway is watching, newest first. Only a gateway started
@@ -1560,7 +2786,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)
@@ -1569,14 +2795,14 @@ 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;
-    if (listed === null || typeof body?.settled_scanned !== "number") {
+    const listed2 = Array.isArray(body?.payments) ? body.payments.map(paymentFromWire).filter((one) => one !== null).filter((one) => one.status !== "paid" || carriesProof(one)) : null;
+    if (listed2 === null || typeof body?.settled_scanned !== "number") {
       throw new ProblemError({
         status: response.status,
         title: "The gateway answered with something that is not a payment list"
       });
     }
-    return { payments: listed, scanned: body.settled_scanned };
+    return { payments: listed2, scanned: body.settled_scanned };
   }
   /**
    * Follow a payment over WebSocket until it is paid or expired, reconnecting
@@ -1584,34 +2810,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(held, options) {
+    const ended = paymentFromWire(await this.followed(held.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, held);
   }
   followed(id, options) {
     const base = this.baseUrl.replace(/^http/, "ws");
@@ -1678,7 +2885,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;
             }
@@ -1707,17 +2914,17 @@ 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) {
-    if (ids.length === 0) {
+  async firstSettled(held, options) {
+    if (held.length === 0) {
       return null;
     }
     const stopLosers = new AbortController();
@@ -1725,15 +2932,15 @@ var ThunderBridge = class {
     let refused = null;
     try {
       const winner = await new Promise((resolve2) => {
-        let waiting = ids.length;
+        let waiting = held.length;
         const lost = () => {
           waiting -= 1;
           if (waiting === 0) {
             resolve2(null);
           }
         };
-        for (const id of ids) {
-          this.waitForWatched(id, { ...options, signal }).then((watched) => watched.status === "paid" ? resolve2(watched) : lost()).catch((failure) => {
+        for (const leg of held) {
+          this.settled(leg, { ...options, signal }).then((watched) => watched.status === "paid" ? resolve2(watched) : lost()).catch((failure) => {
             refused ??= failure;
             lost();
           });
@@ -1753,10 +2960,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",
@@ -1766,17 +2973,20 @@ 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);
     }
+    if (watched.paymentHash.toLowerCase() !== handover.paymentHash.toLowerCase()) {
+      throw new GatewayCheatError("hash_mismatch", watched.id);
+    }
     return watched;
   }
   /**
@@ -1789,12 +2999,75 @@ var ThunderBridge = class {
   async nameFor(paymentHash) {
     return this.secret === null ? null : paymentNamedBy((await this.speaking()).publicKeyHex, paymentHash);
   }
+  /**
+   * Hold a socket open and answer what the gateway asks about this caller's own
+   * payments, so a watch addressed to this caller settles without anybody
+   * hosting a URL. Reconnects on its own until the returned function is called
+   */
+  attend(options) {
+    const base = this.baseUrl.replace(/^http/, "ws");
+    const firstDelay = options.reconnectDelayMs ?? RECONNECT_DELAY_MS;
+    let socket = null;
+    let retry;
+    let stopped = false;
+    let attempt = 0;
+    const again = () => {
+      if (stopped || options.reconnect === false) {
+        return;
+      }
+      retry = setTimeout(() => void connect(), backoffMs(firstDelay, attempt));
+    };
+    const answered3 = async (opened, raw) => {
+      const asked = askFromWire(raw);
+      if (asked === null) {
+        return;
+      }
+      const preimage = await options.answer(asked.paymentHash);
+      opened.send(
+        JSON.stringify(
+          preimage === null ? { ask: asked.ask, settled: false } : { ask: asked.ask, settled: true, preimage }
+        )
+      );
+    };
+    const connect = async () => {
+      attempt += 1;
+      let url;
+      try {
+        url = `${base}/ws/tickets/${await this.wsTicket({ agent: true })}`;
+      } catch (refused) {
+        options.onError?.(refused);
+        again();
+        return;
+      }
+      if (stopped) {
+        return;
+      }
+      const opened = new WebSocket(url);
+      socket = opened;
+      opened.onopen = () => {
+        attempt = 1;
+      };
+      opened.onmessage = (event) => {
+        void answered3(opened, String(event.data)).catch(
+          (refused) => options.onError?.(refused)
+        );
+      };
+      opened.onerror = () => options.onError?.(new Error(`could not attend ${base}`));
+      opened.onclose = again;
+    };
+    void connect();
+    return () => {
+      stopped = true;
+      clearTimeout(retry);
+      socket?.close();
+    };
+  }
   /**
    * Follow every payment made to one trigger, replayed from the recent ones on
    * 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}`;
@@ -1833,7 +3106,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));
           }
@@ -1855,17 +3128,17 @@ 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) {
-    return asked === true || this.token !== null;
+    return asked === true || this.token !== null || this.secret !== null;
   }
   async wsTicket(body) {
     return encodeURIComponent((await this.mintedTicket(body)).ticket);
@@ -1902,15 +3175,26 @@ 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);
+  handOut(payment, key) {
+    const now = Math.floor(Date.now() / 1e3);
+    for (const [hash2, earlier2] of this.handedOut) {
+      if (earlier2.expiresAt <= now) {
+        this.handedOut.delete(hash2);
+      }
+    }
+    const hash = payment.paymentHash.toLowerCase();
+    const earlier = this.handedOut.get(hash);
+    if (earlier !== void 0 && (earlier.key === null || earlier.key !== key)) {
+      throw new GatewayCheatError("invoice_reused", payment.id);
     }
-    return settled;
+    this.handedOut.set(hash, { key, expiresAt: payment.expiresAt });
   }
-  checked(payment) {
-    if (this.verify && payment.status === "paid" && !isProvablyPaid(payment)) {
+  proven(payment, held) {
+    const other = held !== void 0 && (payment.id !== held.id || payment.paymentHash.toLowerCase() !== held.paymentHash.toLowerCase());
+    if (other) {
+      throw new GatewayCheatError("hash_mismatch", payment.id);
+    }
+    if (payment.status === "paid" && !carriesProof(payment)) {
       throw new GatewayCheatError("preimage_mismatch", payment.id);
     }
     return payment;
@@ -1926,11 +3210,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");
@@ -1940,7 +3234,7 @@ async function problemFrom(response) {
   }
   return new ProblemError(document);
 }
-function refusals(wallets) {
+function refusals2(wallets) {
   if (!Array.isArray(wallets)) {
     return [];
   }
@@ -1949,118 +3243,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;
@@ -2084,10 +3266,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()) {
@@ -2109,7 +3289,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(held, options) {
     const stopLosers = new AbortController();
     const signal = options?.signal ? AbortSignal.any([stopLosers.signal, options.signal]) : stopLosers.signal;
     const unpaid = [];
@@ -2124,7 +3304,7 @@ var Gateways = class {
           }
         };
         for (const gateway of this.each) {
-          gateway.waitForWatched(id, { ...options, signal }).then((watched) => {
+          gateway.settled(held, { ...options, signal }).then((watched) => {
             if (watched.status === "paid") {
               return resolve2(watched);
             }
@@ -2148,314 +3328,29 @@ 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
-import { encode } from "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 } = 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
-    };
-  };
-}
 export {
+  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
 };