thunder-bridge 0.8.2 → 0.8.4

package/dist/server.cjs

@@ -0,0 +1,807 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  blindLightningRail: () => blindLightningRail,
+  lnurlPayEndpoint: () => lnurlPayEndpoint
+});
+module.exports = __toCommonJS(server_exports);
+
+// ../core/bytes.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+
+// ../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);
+}
+
+// ../core/sha256.ts
+var ROUND_CONSTANTS = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var BLOCK_BYTES = 64;
+var LENGTH_BYTES = 8;
+var SCHEDULE_WORDS = 64;
+function sha256(bytes) {
+  const padded = withPadding(bytes);
+  const reader = new DataView(padded.buffer);
+  const state = Uint32Array.from(INITIAL_STATE);
+  const schedule = new Uint32Array(SCHEDULE_WORDS);
+  for (let block = 0; block < padded.length; block += BLOCK_BYTES) {
+    fillSchedule(schedule, reader, block);
+    compress(state, schedule);
+  }
+  return asBytes(state);
+}
+function sha256Hex(text2) {
+  return bytesToHex(sha256(new TextEncoder().encode(text2)));
+}
+function withPadding(bytes) {
+  const padded = new Uint8Array(
+    bytes.length + 1 + LENGTH_BYTES + BLOCK_BYTES - 1 & ~(BLOCK_BYTES - 1)
+  );
+  padded.set(bytes);
+  padded[bytes.length] = 128;
+  new DataView(padded.buffer).setUint32(padded.length - 4, bytes.length * 8, false);
+  return padded;
+}
+function fillSchedule(schedule, reader, block) {
+  for (let at = 0; at < 16; at++) schedule[at] = reader.getUint32(block + at * 4, false);
+  for (let at = 16; at < SCHEDULE_WORDS; at++) {
+    const recent = schedule[at - 15];
+    const distant = schedule[at - 2];
+    const mixedRecent = rotate(recent, 7) ^ rotate(recent, 18) ^ recent >>> 3;
+    const mixedDistant = rotate(distant, 17) ^ rotate(distant, 19) ^ distant >>> 10;
+    schedule[at] = schedule[at - 16] + mixedRecent + schedule[at - 7] + mixedDistant | 0;
+  }
+}
+function compress(state, schedule) {
+  let a = state[0];
+  let b = state[1];
+  let c = state[2];
+  let d = state[3];
+  let e = state[4];
+  let f = state[5];
+  let g = state[6];
+  let h = state[7];
+  for (let round = 0; round < SCHEDULE_WORDS; round++) {
+    const choose = e & f ^ ~e & g;
+    const majority = a & b ^ a & c ^ b & c;
+    const mixedE = rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25);
+    const mixedA = rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22);
+    const carried = h + mixedE + choose + ROUND_CONSTANTS[round] + schedule[round] | 0;
+    h = g;
+    g = f;
+    f = e;
+    e = d + carried | 0;
+    d = c;
+    c = b;
+    b = a;
+    a = carried + (mixedA + majority | 0) | 0;
+  }
+  const rolling = [a, b, c, d, e, f, g, h];
+  for (let at = 0; at < state.length; at++) state[at] = state[at] + rolling[at] | 0;
+}
+function asBytes(state) {
+  const digest = new Uint8Array(state.length * 4);
+  const writer = new DataView(digest.buffer);
+  for (let at = 0; at < state.length; at++) writer.setUint32(at * 4, state[at], false);
+  return digest;
+}
+function rotate(value, by) {
+  return value >>> by | value << 32 - by;
+}
+
+// ../core/bolt11.ts
+var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var CHECKSUM_WORDS = 6;
+var TIMESTAMP_WORDS = 7;
+var SIGNATURE_WORDS = 104;
+var TAGGED_FIELD_LENGTH_WORDS = 2;
+var PAYMENT_HASH_TAG = 1;
+var PAYMENT_HASH_WORDS = 52;
+var EXPIRY_TAG = 6;
+var DESCRIPTION_HASH_TAG = 23;
+var DESCRIPTION_HASH_WORDS = 52;
+var DEFAULT_EXPIRY_SECS = 3600;
+var MSAT_PER_BTC = 1e11;
+var HRP_MULTIPLIER_MSAT = {
+  m: MSAT_PER_BTC / 1e3,
+  u: MSAT_PER_BTC / 1e6,
+  n: MSAT_PER_BTC / 1e9,
+  p: MSAT_PER_BTC / 1e12
+};
+var HRP_AMOUNT = /^ln[a-z]+?(\d+)([munp]?)$/;
+function decodeInvoice(bolt11) {
+  const parts = splitBech32(bolt11);
+  if (parts === null) {
+    return { paymentHash: null, descriptionHash: null, amountMsat: null, expiresAt: null };
+  }
+  const tagged = taggedFields(parts.words);
+  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)
+  };
+}
+function splitBech32(bolt11) {
+  const lower = bolt11.toLowerCase();
+  if (isBolt12Encoding(lower)) return null;
+  const separator = lower.lastIndexOf("1");
+  if (separator < 1) return null;
+  const dataChars = lower.slice(separator + 1);
+  if (dataChars.length < CHECKSUM_WORDS) return null;
+  const words = [];
+  for (const char of dataChars) {
+    const value = BECH32_CHARSET.indexOf(char);
+    if (value === -1) return null;
+    words.push(value);
+  }
+  return { hrp: lower.slice(0, separator), words: words.slice(0, -CHECKSUM_WORDS) };
+}
+function isBolt12Encoding(lower) {
+  return lower.startsWith("lno") || lower.startsWith("lni") || lower.startsWith("lnr");
+}
+function taggedFields(words) {
+  const fields = /* @__PURE__ */ new Map();
+  const signatureStart = words.length - SIGNATURE_WORDS;
+  let cursor = TIMESTAMP_WORDS;
+  while (cursor + 1 + TAGGED_FIELD_LENGTH_WORDS <= signatureStart) {
+    const lengthWords = words[cursor + 1] * 32 + words[cursor + 2];
+    const dataStart = cursor + 1 + TAGGED_FIELD_LENGTH_WORDS;
+    const dataEnd = dataStart + lengthWords;
+    if (dataEnd > signatureStart) return fields;
+    if (!fields.has(words[cursor])) fields.set(words[cursor], words.slice(dataStart, dataEnd));
+    cursor = dataEnd;
+  }
+  return fields;
+}
+function hexTag(fields, tag, expectedWords) {
+  const words = fields.get(tag);
+  if (words === void 0 || words.length !== expectedWords) return null;
+  return bytesToHex(wordsToBytes(words));
+}
+function expiryOf(words, fields) {
+  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);
+}
+function amountFromHrp(hrp) {
+  const match = HRP_AMOUNT.exec(hrp);
+  if (match === null) return null;
+  const [, digits, multiplier] = match;
+  return multiplier ? Number(digits) * HRP_MULTIPLIER_MSAT[multiplier] : Number(digits) * MSAT_PER_BTC;
+}
+function readNumber(words) {
+  return words.reduce((total, word) => total * 32 + word, 0);
+}
+function wordsToBytes(words) {
+  const bytes = [];
+  let accumulator = 0;
+  let bits = 0;
+  for (const word of words) {
+    accumulator = accumulator << 5 | word;
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(accumulator >>> bits & 255);
+    }
+  }
+  return Uint8Array.from(bytes);
+}
+
+// ../core/url.ts
+var PRIVATE_SUFFIXES = ["localhost", "local", "internal", "lan", "arpa", "test", "invalid"];
+function publicHttps(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return false;
+  }
+  return url.protocol === "https:" && hostIsPublic(url.hostname.toLowerCase());
+}
+function sameOrigin(one, other) {
+  try {
+    return new URL(one).origin === new URL(other).origin;
+  } catch {
+    return false;
+  }
+}
+function publicAddress(literal) {
+  return literal.includes(":") ? ipv6IsGlobal(literal) : ipv4IsGlobal(literal);
+}
+function hostIsPublic(host) {
+  if (host.startsWith("[")) return publicAddress(host.slice(1, -1));
+  const name = host.replace(/\.$/, "");
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) return publicAddress(name);
+  const labels = name.split(".");
+  if (labels.length < 2 || labels.some((label) => label === "")) return false;
+  return !PRIVATE_SUFFIXES.includes(labels[labels.length - 1]);
+}
+function ipv4IsGlobal(literal) {
+  const parts = literal.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return false;
+  }
+  const [a, b] = parts;
+  if (a === 0 || a === 10 || a === 127 || a >= 240) return false;
+  if (a === 100 && b >= 64 && b < 128) return false;
+  if (a === 169 && b === 254) return false;
+  if (a === 172 && b >= 16 && b < 32) return false;
+  if (a === 192 && b === 168) return false;
+  return true;
+}
+function ipv6IsGlobal(literal) {
+  const groups = ipv6Groups(literal.toLowerCase());
+  if (groups.length !== 8 || groups.some(Number.isNaN)) return false;
+  const leading = groups.slice(0, 5).every((group) => group === 0);
+  if (leading && groups[5] === 0 && groups[6] === 0 && groups[7] <= 1) return false;
+  if (leading && groups[5] === 65535) {
+    const [high, low] = [groups[6], groups[7]];
+    return ipv4IsGlobal(`${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`);
+  }
+  const first = groups[0];
+  if ((first & 65024) === 64512) return false;
+  if ((first & 65472) === 65152) return false;
+  return true;
+}
+function ipv6Groups(address) {
+  const [head = "", tail] = address.split("::");
+  const left = head.split(":").filter((group) => group !== "");
+  const right = (tail ?? "").split(":").filter((group) => group !== "");
+  const gap = tail === void 0 ? [] : Array(8 - left.length - right.length).fill("0");
+  return [...left, ...gap, ...right].map((group) => parseInt(group, 16));
+}
+
+// ../core/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(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) {
+    await refuseUnlessPublic(target);
+    const response = await fetch(target, {
+      method: carried.method ?? "GET",
+      headers: carried.headers ?? {},
+      body: carried.body,
+      redirect: "manual",
+      signal
+    });
+    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 resolvesNothingPrivate(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 !== null && found.every((one) => publicAddress(one.address));
+}
+async function refuseUnlessPublic(url) {
+  if (!publicHttps(url)) throw new Error(`${url} is not a public https URL`);
+  if (!await resolvesNothingPrivate(url)) throw new Error(`${url} resolves to an address we do not reach`);
+}
+async function answerOf(response) {
+  const { status, ok } = response;
+  const reader = response.body?.getReader();
+  if (!reader) return { status, ok, body: "", truncated: false };
+  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 };
+    read.push(value);
+    bytes += value.length;
+  }
+  await reader.cancel();
+  return { status, ok, body: text(read), truncated: true };
+}
+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/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;
+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 };
+}
+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 || !publicHttps(`https://${domain}/`)) {
+    throw new WalletRefused("address-unusable", `${address} is not a usable lightning address`);
+  }
+  return [user, domain];
+}
+async function fetchJson(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 JSON.parse(answer.body);
+}
+
+// ../core/sealed.ts
+var VERSION = "v1";
+var IV_BYTES = 12;
+var MIN_SECRET_CHARS = 32;
+var MAX_PLAIN_BYTES = 3e3;
+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}`);
+  }
+  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 joined = new Uint8Array(iv.length + cipher.length);
+  joined.set(iv);
+  joined.set(cipher, iv.length);
+  return `${VERSION}.${toBase64Url(joined)}`;
+}
+async function keyFor(secret) {
+  if (secret.length < MIN_SECRET_CHARS) {
+    throw new Error(`the sealing secret needs ${MIN_SECRET_CHARS} characters of randomness`);
+  }
+  const material = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    "HKDF",
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: INFO },
+    material,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+function toBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// 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/trigger.ts
+var NONCE_BYTES = 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");
+    }
+  };
+}
+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 }
+  );
+  return { bolt11: payment.bolt11, verifyUrl: payment.verifyUrl };
+}
+async function mintBlind(config, address, amountMsat) {
+  const resolved = await resolve([address], amountMsat);
+  const minted = { ...resolved, amountMsat, lnAddress: resolved.address };
+  const locked = config.sealed;
+  try {
+    await config.gateway.watchPayment({
+      paymentHash: resolved.paymentHash,
+      verifyUrl: resolved.verifyUrl,
+      expiresAt: resolved.expiresAt,
+      trigger: config.watchSecret,
+      sealed: locked ? await seal(locked.secret, JSON.stringify(locked.data(minted))) : void 0
+    });
+  } catch (refused) {
+    if (!alreadyWatched(refused)) throw refused;
+  }
+  return { bolt11: resolved.bolt11, verifyUrl: resolved.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_BYTES));
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function refuse(reason) {
+  return Response.json({ status: "ERROR", reason });
+}
+
+// src/qr.ts
+var import_uqr = require("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/rail.ts
+var LIGHTNING = "lightning";
+function blindLightningRail(config) {
+  return async (order) => {
+    const resolved = await invoiceFrom(config.lnAddresses, await config.amountMsat(order));
+    const watched = await config.gateway.watchPayment({
+      paymentHash: resolved.paymentHash,
+      verifyUrl: resolved.verifyUrl,
+      expiresAt: resolved.expiresAt,
+      trigger: config.trigger,
+      sealed: await config.sealed?.(order),
+      webhookUrl: config.webhookUrl,
+      webhookSecret: config.webhookSecret
+    });
+    return {
+      id: watched.id,
+      rail: config.name ?? LIGHTNING,
+      scan: resolved.bolt11,
+      qr: encodeForQr(resolved.bolt11),
+      expiresAt: resolved.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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blindLightningRail,
+  lnurlPayEndpoint
+});