thunder-bridge 1.4.2 → 2.1.1

package/dist/{server.js → nwc.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(text) {
+  return /^[0-9a-f]+$/i.test(text) && text.length % 2 === 0;
 }
 
 // ../core/sha256.ts
@@ -108,9 +108,6 @@ function sha256(bytes) {
   }
   return asBytes(state);
 }
-function sha256Hex(text2) {
-  return bytesToHex(sha256(new TextEncoder().encode(text2)));
-}
 function withPadding(bytes) {
   const padded2 = new Uint8Array(
     bytes.length + 1 + LENGTH_BYTES + BLOCK_BYTES - 1 & ~(BLOCK_BYTES - 1)
@@ -175,6 +172,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 +190,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 +221,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 +240,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 +291,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) {
@@ -304,36 +330,40 @@ var WalletRefused = class extends Error {
     this.reason = reason;
   }
 };
-var NoWalletAvailable = class extends Error {
-  wallets;
-  constructor(wallets) {
-    super(wallets.map((wallet) => `${wallet.address} ${wallet.reason}`).join(", "));
-    this.wallets = wallets;
-  }
-};
 
 // ../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 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 joined2 = new Uint8Array(iv.length + cipher.length);
   joined2.set(iv);
   joined2.set(cipher, iv.length);
   return `${VERSION}.${toBase64Url(joined2)}`;
 }
-async function unseal(secret, sealed) {
+async function unseal(secret, sealed, paymentHash) {
   const key = await keyFor(secret);
-  if (!sealed.startsWith(`${VERSION}.`)) {
+  const padded2 = sealed.startsWith(`${VERSION}.`);
+  const unbound = !padded2 && sealed.startsWith(`${UNPADDED_VERSION}.`);
+  if (!padded2 && (!unbound || paymentHash !== void 0)) {
     return null;
   }
   const joined2 = fromBase64Url(sealed.slice(VERSION.length + 1));
@@ -341,20 +371,50 @@ async function unseal(secret, sealed) {
     return null;
   }
   try {
-    const body = await crypto.subtle.decrypt(
-      { name: "AES-GCM", iv: joined2.slice(0, IV_BYTES) },
-      key,
-      joined2.slice(IV_BYTES)
+    const body = new Uint8Array(
+      await crypto.subtle.decrypt(
+        {
+          name: "AES-GCM",
+          iv: joined2.slice(0, IV_BYTES),
+          additionalData: padded2 ? boundTo(paymentHash) : void 0
+        },
+        key,
+        joined2.slice(IV_BYTES)
+      )
     );
-    return new TextDecoder().decode(body);
+    const text = padded2 ? unpad(body) : body;
+    return text === null ? null : new TextDecoder().decode(text);
   } 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 text = new TextEncoder().encode(plaintext);
+  const size = SIZE_CLASSES.find((limit) => text.length <= limit);
+  if (size === void 0) {
+    throw new Error(`sealed takes at most ${MAX_PLAIN_BYTES} bytes, this was ${text.length}`);
+  }
+  const body = new Uint8Array(size + 1);
+  body.set(text);
+  body[text.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),
@@ -377,12 +437,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(text) {
+  if (text.length === 0 || !/^[A-Za-z0-9_-]+$/.test(text)) {
     return null;
   }
   try {
-    const binary = atob(text2.replace(/-/g, "+").replace(/_/g, "/"));
+    const binary = atob(text.replace(/-/g, "+").replace(/_/g, "/"));
     const bytes = new Uint8Array(binary.length);
     for (let at = 0; at < bytes.length; at++) {
       bytes[at] = binary.charCodeAt(at);
@@ -539,8 +599,8 @@ function toBase64(bytes) {
   }
   return btoa(binary);
 }
-function fromBase64(text2) {
-  const binary = atob(text2);
+function fromBase64(text) {
+  const binary = atob(text);
   const bytes = new Uint8Array(binary.length);
   for (let at = 0; at < bytes.length; at++) {
     bytes[at] = binary.charCodeAt(at);
@@ -548,14 +608,257 @@ function fromBase64(text2) {
   return bytes;
 }
 
+// src/qr.ts
+import { encode } from "uqr";
+function toLightningUri(destination) {
+  const scanned = isLnAddress(destination) ? destination : destination.toUpperCase();
+  return `LIGHTNING:${scanned}`;
+}
+function isLnAddress(destination) {
+  const at = destination.indexOf("@");
+  return at > 0 && destination.slice(at + 1).includes(".");
+}
+
+// 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;
+  }
+  code;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "AmountError";
+    this.code = code;
+  }
+};
+
+// src/currency.ts
+var ISO_4217_MINOR_UNITS = {
+  BHD: 3,
+  BIF: 0,
+  CLP: 0,
+  CZK: 2,
+  DJF: 0,
+  EUR: 2,
+  GBP: 2,
+  ISK: 0,
+  IQD: 3,
+  JOD: 3,
+  JPY: 0,
+  KRW: 0,
+  KWD: 3,
+  LYD: 3,
+  OMR: 3,
+  PLN: 2,
+  PYG: 0,
+  RWF: 0,
+  TND: 3,
+  UGX: 0,
+  USD: 2,
+  VND: 0,
+  VUV: 0,
+  XAF: 0,
+  XOF: 0,
+  XPF: 0
+};
+function minorUnitsOf(currency) {
+  const digits = ISO_4217_MINOR_UNITS[currency.toUpperCase()];
+  if (digits === void 0) {
+    throw new AmountError(
+      "unknown-currency",
+      `${currency.toUpperCase()} is not a currency this knows the ISO 4217 minor unit of`
+    );
+  }
+  return digits;
+}
+function minorScaleOf(currency) {
+  return 10 ** minorUnitsOf(currency);
+}
+
+// src/price.ts
+var MSAT_PER_BTC2 = 1e11;
+var BASIS_POINTS = 1e4;
+var DEFAULT_HOLD_SECS = 60;
+var DEFAULT_MIN_VENUES = 2;
+var DEFAULT_MAX_SPREAD_BPS = 200;
+var MILLIS = 1e3;
+function coinbase(baseUrl = "https://api.coinbase.com") {
+  return async (currency) => {
+    const asked = currency.toUpperCase();
+    const answer = await asJson(`${baseUrl}/v2/prices/BTC-${asked}/spot`, "coinbase");
+    const quoted = answer.data;
+    if (quoted?.currency !== asked) {
+      throw new Error(`coinbase quoted ${quoted?.currency} when asked for ${asked}`);
+    }
+    return asMinor(quoted.amount, "coinbase", asked);
+  };
+}
+function kraken(baseUrl = "https://api.kraken.com") {
+  return async (currency) => {
+    const asked = currency.toUpperCase();
+    const answer = await asJson(`${baseUrl}/0/public/Ticker?pair=XBT${asked}`, "kraken");
+    if (answer.error?.length) {
+      throw new Error(`kraken refused XBT${asked}: ${answer.error[0]}`);
+    }
+    const pairs = Object.values(answer.result ?? {});
+    if (pairs.length !== 1) {
+      throw new Error(`kraken answered ${pairs.length} pairs for XBT${asked}`);
+    }
+    return asMinor(pairs[0]?.c?.[0], "kraken", asked);
+  };
+}
+function bitstamp(baseUrl = "https://www.bitstamp.net") {
+  return async (currency) => {
+    const pair = `btc${currency.toLowerCase()}`;
+    const answer = await asJson(`${baseUrl}/api/v2/ticker/${pair}/`, "bitstamp");
+    if (Array.isArray(answer)) {
+      throw new Error(`bitstamp has no ${pair} pair`);
+    }
+    return asMinor(answer.last, "bitstamp", currency);
+  };
+}
+function coinmate(baseUrl = "https://coinmate.io") {
+  return async (currency) => {
+    const pair = `BTC_${currency.toUpperCase()}`;
+    const answer = await asJson(`${baseUrl}/api/ticker?currencyPair=${pair}`, "coinmate");
+    if (answer.error !== false) {
+      throw new Error(`coinmate refused ${pair}: ${answer.errorMessage ?? "no reason"}`);
+    }
+    return asMinor(answer.data?.last, "coinmate", currency);
+  };
+}
+function medianOf(tickers = [coinbase(), kraken(), bitstamp(), coinmate()], options = {}) {
+  const holdFor = (options.holdForSecs ?? DEFAULT_HOLD_SECS) * MILLIS;
+  const minVenues = options.minVenues ?? DEFAULT_MIN_VENUES;
+  const maxSpread = options.maxSpreadBps ?? DEFAULT_MAX_SPREAD_BPS;
+  const held = /* @__PURE__ */ new Map();
+  return async (currency) => {
+    const asked = currency.toUpperCase();
+    const remembered = held.get(asked);
+    if (remembered && Date.now() - remembered.at < holdFor) {
+      return remembered.price;
+    }
+    const answers = await Promise.allSettled(tickers.map((ticker) => ticker(asked)));
+    const quoted = answers.filter((answer) => answer.status === "fulfilled").map((answer) => answer.value).sort((one, other) => one - other);
+    if (quoted.length < minVenues) {
+      throw new Error(
+        `${quoted.length} of ${tickers.length} venues quoted ${asked}, ${minVenues} wanted: ${refusals(answers)}`
+      );
+    }
+    const 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 msat2 = (wanted + per - 1n) / per;
+  if (msat2 > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`${amountMinor} at ${priceMinorPerBtc} is more millisatoshi than exist`);
+  }
+  return Number(msat2);
+}
+async function asJson(url, venue) {
+  const answer = await fetch(url, { headers: { accept: "application/json" } });
+  if (!answer.ok) {
+    throw new Error(`${venue} answered ${answer.status}`);
+  }
+  return answer.json();
+}
+function asMinor(quoted, venue, currency) {
+  const major = Number(quoted);
+  if (!Number.isFinite(major) || major <= 0) {
+    throw new Error(`${venue} quoted ${String(quoted)} for ${currency.toUpperCase()}`);
+  }
+  return Math.round(major * 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 msat(exact) {
+  if (!Number.isSafeInteger(exact) || exact < 1) {
+    throw new AmountError(
+      "not-whole-millisatoshi",
+      `${exact} is not a payable count of millisatoshi`
+    );
+  }
+  return exact;
+}
+async function amountNow(amount) {
+  return typeof amount === "function" ? msat(await amount()) : msat(amount);
+}
+
 // ../core/ed25519.ts
 var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
+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`
+];
 
 // src/webhook.ts
 var VERIFY_CHALLENGE = "verify-challenge";
-function nonceOf(text2, type) {
+async function answerVerifyChallenge(request) {
+  if (request.method !== "POST") {
+    return null;
+  }
+  const nonce = nonceOf(await request.clone().text(), VERIFY_CHALLENGE);
+  return nonce === null ? null : answered(nonce);
+}
+function answered(nonce) {
+  return new Response(JSON.stringify({ nonce }), {
+    headers: { "content-type": "application/json" }
+  });
+}
+function nonceOf(text, type) {
   try {
-    const said = JSON.parse(text2);
+    const said = JSON.parse(text);
     if (said["type"] !== type || typeof said["nonce"] !== "string") {
       return null;
     }
@@ -564,16 +867,13 @@ 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;
+
+// src/rail.ts
+async function msatForOrder(order, amount, rate) {
+  if (amount !== void 0) {
+    return await amountNow(amount(order));
   }
-  const answer = answerVerifyChallenge(await request.clone().text());
-  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
+  return msat(msatFor(order.amountMinor, await (rate ?? medianOf())(order.currency)));
 }
 
 // src/nwc.ts
@@ -694,7 +994,7 @@ function nwcVerifyEndpoint(config) {
     "cache-control": `max-age=${config.pollEverySecs ?? DEFAULT_POLL_EVERY_SECS}`
   };
   return async (request) => {
-    const consented = await answerVerifyChallengeRequest(request);
+    const consented = await answerVerifyChallenge(request);
     if (consented !== null) {
       return consented;
     }
@@ -854,505 +1154,14 @@ function isSecureRelay(relay) {
     return false;
   }
 }
-
-// ../core/url.ts
-var PRIVATE_SUFFIXES = ["localhost", "local", "internal", "lan", "arpa", "test", "invalid"];
-function publicHttps(raw) {
-  let url;
-  try {
-    url = new URL(raw);
-  } catch {
-    return false;
-  }
-  return url.protocol === "https:" && hostIsPublic(url.hostname.toLowerCase());
-}
-function sameOrigin(one, other) {
-  try {
-    return new URL(one).origin === new URL(other).origin;
-  } catch {
-    return false;
-  }
-}
-function publicAddress(literal) {
-  return literal.includes(":") ? ipv6IsGlobal(literal) : ipv4IsGlobal(literal);
-}
-function hostIsPublic(host) {
-  if (host.startsWith("[")) {
-    return publicAddress(host.slice(1, -1));
-  }
-  const name = host.replace(/\.$/, "");
-  if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) {
-    return publicAddress(name);
-  }
-  const labels = name.split(".");
-  if (labels.length < 2 || labels.some((label) => label === "")) {
-    return false;
-  }
-  return !PRIVATE_SUFFIXES.includes(labels[labels.length - 1]);
-}
-function ipv4IsGlobal(literal) {
-  const parts = literal.split(".").map(Number);
-  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
-    return false;
-  }
-  const [a, b] = parts;
-  if (a === 0 || a === 10 || a === 127 || a >= 240) {
-    return false;
-  }
-  if (a === 100 && b >= 64 && b < 128) {
-    return false;
-  }
-  if (a === 169 && b === 254) {
-    return false;
-  }
-  if (a === 172 && b >= 16 && b < 32) {
-    return false;
-  }
-  if (a === 192 && b === 168) {
-    return false;
-  }
-  return true;
-}
-function ipv6IsGlobal(literal) {
-  const groups = ipv6Groups(literal.toLowerCase());
-  if (groups.length !== 8 || groups.some(Number.isNaN)) {
-    return false;
-  }
-  const leading = groups.slice(0, 5).every((group) => group === 0);
-  if (leading && groups[5] === 0 && groups[6] === 0 && groups[7] <= 1) {
-    return false;
-  }
-  if (leading && groups[5] === 65535) {
-    const [high, low] = [groups[6], groups[7]];
-    return ipv4IsGlobal(`${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`);
-  }
-  const first = groups[0];
-  if ((first & 65024) === 64512) {
-    return false;
-  }
-  if ((first & 65472) === 65152) {
-    return false;
-  }
-  return true;
-}
-function ipv6Groups(address) {
-  const [head = "", tail] = address.split("::");
-  const left = head.split(":").filter((group) => group !== "");
-  const right = (tail ?? "").split(":").filter((group) => group !== "");
-  const gap = tail === void 0 ? [] : Array(8 - left.length - right.length).fill("0");
-  return [...left, ...gap, ...right].map((group) => parseInt(group, 16));
-}
-
-// ../core/outbound.ts
-var HTTP_TIMEOUT_MS = 15e3;
-var LOOKUP_TIMEOUT_MS = 5e3;
-var HOPS_FOLLOWED = 2;
-var REDIRECTS = [301, 302, 303, 307, 308];
-var KEEPS_THE_METHOD = [307, 308];
-var CREDENTIALS = ["authorization", "cookie", "proxy-authorization"];
-var BODY_LIMIT_BYTES = 262144;
-var throughFetch = (url, sent, signal) => fetch(url, {
-  method: sent.method ?? "GET",
-  headers: sent.headers ?? {},
-  body: sent.body,
-  redirect: "manual",
-  signal
-});
-var send = throughFetch;
-async function ask(url, sent = {}) {
-  const capped = AbortSignal.timeout(HTTP_TIMEOUT_MS);
-  const signal = sent.deadline ? AbortSignal.any([sent.deadline, capped]) : capped;
-  let target = url;
-  let carried = sent;
-  for (let hop = 0; hop <= HOPS_FOLLOWED; hop += 1) {
-    const at = await addressesToReach(target);
-    const response = await send(target, carried, signal, at);
-    if (!REDIRECTS.includes(response.status)) {
-      return await answerOf(response);
-    }
-    const location = response.headers.get("location");
-    if (location === null) {
-      throw new Error(`${target} answered ${response.status} without saying where to`);
-    }
-    await response.body?.cancel();
-    const next = new URL(location, target).toString();
-    carried = KEEPS_THE_METHOD.includes(response.status) ? carried : withoutBody(carried);
-    carried = sameOrigin(target, next) ? carried : withoutCredentials(carried);
-    target = next;
-  }
-  throw new Error(`${url} redirected more than ${HOPS_FOLLOWED} times`);
-}
-async function addressesToReach(url) {
-  if (!publicHttps(url)) {
-    throw new Error(`${url} is not a public https URL`);
-  }
-  const found = await resolved(url);
-  if (found.length === 0 || !found.every((one) => publicAddress(one.address))) {
-    throw new Error(`${url} resolves to an address we do not reach`);
-  }
-  return found;
-}
-async function resolved(url) {
-  const { lookup } = await import("dns/promises");
-  const { setTimeout: sleep } = await import("timers/promises");
-  const host = new URL(url).hostname.replace(/^\[|]$/g, "");
-  const found = await Promise.race([
-    lookup(host, { all: true, verbatim: true }).catch(() => []),
-    sleep(LOOKUP_TIMEOUT_MS, null, { ref: false })
-  ]);
-  return found ?? [];
-}
-async function answerOf(response) {
-  const { status, ok, headers } = response;
-  const reader = response.body?.getReader();
-  if (!reader) {
-    return { status, ok, body: "", truncated: false, headers };
-  }
-  const read = [];
-  let bytes = 0;
-  while (bytes <= BODY_LIMIT_BYTES) {
-    const { done, value } = await reader.read();
-    if (done) {
-      return { status, ok, body: text(read), truncated: false, headers };
-    }
-    read.push(value);
-    bytes += value.length;
-  }
-  await reader.cancel();
-  return { status, ok, body: text(read), truncated: true, headers };
-}
-function withoutBody(sent) {
-  const headers = { ...sent.headers };
-  delete headers["content-type"];
-  return { ...sent, method: "GET", headers, body: void 0 };
-}
-function withoutCredentials(sent) {
-  const headers = { ...sent.headers };
-  for (const named of CREDENTIALS) {
-    delete headers[named];
-  }
-  return { ...sent, headers };
-}
-function text(chunks) {
-  const decoder = new TextDecoder();
-  let decoded = "";
-  for (const chunk of chunks) {
-    decoded += decoder.decode(chunk, { stream: true });
-  }
-  return decoded + decoder.decode();
-}
-
-// ../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(addresses, amountMsat) {
-  const served = await firstThatServes(
-    addresses,
-    (address, deadline) => resolveAddress(address, amountMsat, deadline)
-  );
-  return served.won;
-}
-async function firstThatServes(addresses, attempt) {
-  const deadline = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
-  const refusals = [];
-  for (const address of addresses) {
-    if (deadline.aborted) {
-      break;
-    }
-    try {
-      return { won: await attempt(address, deadline), refusals };
-    } catch (refusal) {
-      if (!(refusal instanceof WalletRefused)) {
-        throw refusal;
-      }
-      console.warn(`wallet ${address} refused, ${refusal.reason}: ${refusal.message}`);
-      refusals.push({ address, reason: refusal.reason });
-    }
-  }
-  throw new NoWalletAvailable(refusals);
-}
-async function probe(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(`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(address, amountMsat, deadline) {
-  const { pay } = await probe(address, amountMsat, deadline);
-  const invoice = await answered(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(url, deadline) {
-  try {
-    return await fetchJson(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(verifyUrl, paymentHash) {
-  const answer = await answeredJson(verifyUrl);
-  const asked = {
-    pace: paceAskedFor(answer.headers),
-    ceiling: ceilingAskedFor(answer.headers)
-  };
-  if (!answer.said.settled || !answer.said.preimage) {
-    return { preimage: null, ...asked };
-  }
-  if (!preimageMatchesHash(answer.said.preimage, paymentHash)) {
-    throw new Error(`verify returned a preimage that does not hash to ${paymentHash}`);
-  }
-  return { preimage: answer.said.preimage, ...asked };
-}
-function paceAskedFor(headers) {
-  const asked = /max-age\s*=\s*(\d+)/i.exec(headers.get("cache-control") ?? "");
-  if (!asked) {
-    return null;
-  }
-  return Math.min(Math.max(Number(asked[1]), MIN_PACE_SECS), MAX_PACE_SECS);
-}
-function ceilingAskedFor(headers) {
-  const asked = /^\s*(\d+)\s*(?:;\s*w\s*=\s*(\d+))?/i.exec(headers.get("ratelimit-limit") ?? "");
-  if (!asked) {
-    return null;
-  }
-  const perWindow = Number(asked[1]);
-  const window = asked[2] === void 0 ? 1 : Number(asked[2]);
-  if (perWindow === 0 || window === 0) {
-    return null;
-  }
-  return Math.min(Math.max(perWindow / window, MIN_PER_SECOND), MAX_PER_SECOND);
-}
-function cannotReleaseAPreimage(host) {
-  const lowered = host.toLowerCase();
-  return VERIFY_WITHOUT_PREIMAGE.some(
-    (known) => lowered === known || lowered.endsWith(`.${known}`)
-  );
-}
-function withAmount(callback, amountMsat) {
-  const separator = callback.includes("?") ? "&" : "?";
-  return `${callback}${separator}amount=${amountMsat}`;
-}
-function splitAddress(address) {
-  const [user, domain, ...rest] = address.split("@");
-  if (!user || !domain || rest.length > 0 || !NAMES_ONE_ACCOUNT.test(user) || !isNothingButAHost(domain) || !publicHttps(`https://${domain}/`)) {
-    throw new WalletRefused("address-unusable", `${address} is not a usable lightning address`);
-  }
-  return [user, domain];
-}
-function isNothingButAHost(domain) {
-  try {
-    const parsed = new URL(`https://${domain}/`);
-    return parsed.host === domain.toLowerCase() && parsed.pathname === "/" && parsed.search === "" && parsed.hash === "";
-  } catch {
-    return false;
-  }
-}
-async function fetchJson(url, deadline) {
-  return (await answeredJson(url, deadline)).said;
-}
-async function answeredJson(url, deadline) {
-  const answer = await ask(url, { headers: { accept: "application/json" }, deadline });
-  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/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;
-  }
-  let difference = 0;
-  for (let at = 0; at < one.length; at++) {
-    difference |= one.charCodeAt(at) ^ other.charCodeAt(at);
-  }
-  return difference === 0;
-}
-function asBuffer(bytes) {
-  return bytes instanceof Uint8Array && bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
-}
-
-// src/errors.ts
-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;
-  }
-};
-function isProblemType(problem, type) {
-  return problem.type === type;
-}
-var NO_WALLET_AVAILABLE = "urn:problem-type:thunder-bridge:no-wallet-available";
-var PAYMENT_ALREADY_WATCHED = "urn:problem-type:thunder-bridge:payment-already-watched";
-var NoWalletAvailableError = class extends ProblemError {
-  wallets;
-  constructor(problem, wallets) {
-    super({ ...problem, type: NO_WALLET_AVAILABLE });
-    this.name = "NoWalletAvailableError";
-    this.wallets = wallets;
-  }
-};
-
-// src/qr.ts
-import { encode } from "uqr";
-function encodeForQr(destination) {
-  const scanned = isLnAddress(destination) ? destination : destination.toUpperCase();
-  return `LIGHTNING:${scanned}`;
-}
-function isLnAddress(destination) {
-  const at = destination.indexOf("@");
-  return at > 0 && destination.slice(at + 1).includes(".");
-}
-
-// 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 answerVerifyChallengeRequest(request);
-    if (consented !== null) {
-      return consented;
-    }
-    const sealed = new URL(request.url).searchParams.get(WALLET);
-    if (sealed === null) {
-      return Response.json({ settled: false }, { status: 400 });
-    }
-    const opened = await unseal(config.secret, sealed);
-    if (opened === null) {
-      return Response.json({ settled: false }, { status: 403 });
-    }
-    const wallet = JSON.parse(opened);
-    const asked = await checkSettled(wallet.url, wallet.hash).catch(() => null);
-    if (asked === null) {
-      return Response.json({ settled: false }, { status: 502 });
-    }
-    return Response.json(
-      { settled: asked.preimage !== null, preimage: asked.preimage },
-      { headers: paced }
-    );
-  };
-}
-async function relayedVerifyUrl(endpoint, wallet, secret) {
-  const relayed = new URL(endpoint);
-  relayed.searchParams.set(WALLET, await seal(secret, JSON.stringify(wallet)));
-  return relayed.toString();
-}
-
-// src/rail.ts
-var LIGHTNING = "lightning";
-function blindLightningRail(config) {
-  return async (order) => {
-    const resolved2 = await invoiceFrom(config.lnAddresses, await config.amountMsat(order));
-    const relay = config.relayVerifyThrough;
-    const watched = await config.gateway.watchPayment({
-      paymentHash: resolved2.paymentHash,
-      verifyUrl: relay ? await relayedVerifyUrl(
-        relay.endpoint,
-        { url: resolved2.verifyUrl, hash: resolved2.paymentHash },
-        relay.secret
-      ) : resolved2.verifyUrl,
-      expiresAt: resolved2.expiresAt,
-      trigger: config.trigger,
-      replay: config.replay,
-      sealed: await config.sealed?.(order),
-      webhookUrl: config.webhookUrl
-    });
-    return {
-      id: watched.id,
-      rail: config.name ?? LIGHTNING,
-      scan: resolved2.bolt11,
-      qr: encodeForQr(resolved2.bolt11),
-      expiresAt: resolved2.expiresAt
-    };
-  };
-}
-function nwcRail(config) {
+function nwcRail(gateway, config) {
   return async (order) => {
     const invoice = await nwcInvoice(
       config.connection,
-      await config.amountMsat(order),
+      await msatForOrder(order, config.amount, config.rate),
       config.description?.(order) ?? order.reference
     );
-    const watched = await config.gateway.watchPayment({
+    const watched = await gateway.watch({
       paymentHash: invoice.paymentHash,
       verifyUrl: await nwcVerifyUrl(
         config.verifyThrough.endpoint,
@@ -1362,158 +1171,25 @@ function nwcRail(config) {
       expiresAt: invoice.expiresAt,
       trigger: config.trigger,
       replay: config.replay,
-      sealed: await config.sealed?.(order),
+      sealed: config.sealed ? await seal(
+        config.sealed.secret,
+        JSON.stringify(config.sealed.data(order)),
+        invoice.paymentHash
+      ) : void 0,
       webhookUrl: config.webhookUrl
     });
     return {
       id: watched.id,
-      rail: config.name ?? LIGHTNING,
+      paymentHash: invoice.paymentHash,
+      rail: config.name ?? "lightning",
       scan: invoice.bolt11,
-      qr: encodeForQr(invoice.bolt11),
+      qr: toLightningUri(invoice.bolt11),
       expiresAt: invoice.expiresAt
     };
   };
 }
-async function invoiceFrom(lnAddresses, amountMsat) {
-  try {
-    return await resolve(lnAddresses, amountMsat);
-  } catch (refused) {
-    if (refused instanceof NoWalletAvailable) {
-      throw new NoWalletAvailableError({ title: refused.message }, refused.wallets);
-    }
-    throw refused;
-  }
-}
-
-// src/trigger.ts
-var NONCE_BYTES2 = 16;
-function lnurlPayEndpoint(config) {
-  return async (request) => {
-    const url = new URL(request.url);
-    const asked = url.searchParams.get("to");
-    try {
-      return asked === null ? await offer(config, url) : await mint(config, url, asked);
-    } catch (failure) {
-      return refuse(failure instanceof Error ? failure.message : "the trigger could not be served");
-    }
-  };
-}
-function watchTicketEndpoint(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(config);
-  };
-}
-function publicWatchTicketEndpoint(config) {
-  return () => issue(config);
-}
-async function offer(config, url) {
-  const amountMsat = await config.amountMsat();
-  const quote = await config.gateway.createQuote({
-    lnAddresses: config.lnAddresses,
-    amountMsat
-  });
-  const nonce = randomNonce();
-  const callback = new URL(config.baseUrl ?? `${url.origin}${url.pathname}`);
-  callback.searchParams.set("to", quote.lnAddress);
-  callback.searchParams.set("msat", String(amountMsat));
-  callback.searchParams.set("n", nonce);
-  callback.searchParams.set("sig", await sign(config.secret, quote.lnAddress, amountMsat, nonce));
-  return Response.json({
-    tag: "payRequest",
-    callback: callback.toString(),
-    metadata: quote.metadata,
-    minSendable: amountMsat,
-    maxSendable: amountMsat
-  });
-}
-async function mint(config, url, address) {
-  const amountMsat = Number(url.searchParams.get("msat"));
-  const nonce = url.searchParams.get("n") ?? "";
-  const signature = url.searchParams.get("sig") ?? "";
-  const expected = await sign(config.secret, address, amountMsat, nonce);
-  if (!equalInConstantTime(signature, expected)) {
-    return refuse("this callback was not signed here");
-  }
-  const wanted = url.searchParams.get("amount");
-  if (wanted !== null && Number(wanted) !== amountMsat) {
-    return refuse(`this trigger costs exactly ${amountMsat} msat`);
-  }
-  const minted = config.blind ? await mintBlind(config, address, amountMsat) : await mintThroughGateway(config, address, amountMsat, nonce);
-  return Response.json({
-    status: "OK",
-    pr: minted.bolt11,
-    routes: [],
-    verify: minted.verifyUrl
-  });
-}
-async function mintThroughGateway(config, address, amountMsat, nonce) {
-  const payment = await config.gateway.createPayment(
-    { lnAddresses: [address], amountMsat },
-    { idempotencyKey: nonce, trigger: config.watchSecret, replay: config.replay }
-  );
-  return { bolt11: payment.bolt11, verifyUrl: payment.verifyUrl };
-}
-async function mintBlind(config, address, amountMsat) {
-  const resolved2 = await resolve([address], amountMsat);
-  const minted = { ...resolved2, amountMsat, lnAddress: resolved2.address };
-  const locked = config.sealed;
-  try {
-    await config.gateway.watchPayment({
-      paymentHash: resolved2.paymentHash,
-      verifyUrl: resolved2.verifyUrl,
-      expiresAt: resolved2.expiresAt,
-      trigger: config.watchSecret,
-      replay: config.replay,
-      sealed: locked ? await seal(locked.secret, JSON.stringify(locked.data(minted))) : void 0
-    });
-  } catch (refused) {
-    if (!alreadyWatched(refused)) {
-      throw refused;
-    }
-  }
-  return { bolt11: resolved2.bolt11, verifyUrl: resolved2.verifyUrl };
-}
-function alreadyWatched(refused) {
-  return refused instanceof ProblemError && isProblemType(refused, PAYMENT_ALREADY_WATCHED);
-}
-function sign(secret, address, amountMsat, nonce) {
-  return hmacHex(secret, `${address}|${amountMsat}|${nonce}`);
-}
-function randomNonce() {
-  const bytes = crypto.getRandomValues(new Uint8Array(NONCE_BYTES2));
-  let hex = "";
-  for (const byte of bytes) {
-    hex += byte.toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-function refuse(reason) {
-  return Response.json({ status: "ERROR", reason });
-}
-async function issue(config) {
-  const issued = await config.gateway.createSocketTicket({
-    trigger: 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 : "";
-}
 export {
   askWallet,
-  blindLightningRail,
-  invoiceFrom,
-  lightningVerifyEndpoint,
-  lnurlPayEndpoint,
   nwcConnection,
   nwcHoldInvoice,
   nwcInvoice,
@@ -1521,8 +1197,5 @@ export {
   nwcRail,
   nwcSettlement,
   nwcVerifyEndpoint,
-  nwcVerifyUrl,
-  publicWatchTicketEndpoint,
-  relayedVerifyUrl,
-  watchTicketEndpoint
+  nwcVerifyUrl
 };