thunder-bridge 0.8.0

package/dist/index.js

@@ -0,0 +1,1419 @@
+// 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;
+  }
+};
+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 {
+  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;
+  }
+};
+var NO_WALLET_AVAILABLE = "urn:problem-type:thunder-bridge-direct:no-wallet-available";
+var REQUEST_IN_FLIGHT = "urn:problem-type:thunder-bridge-direct:request-in-flight";
+var IDEMPOTENCY_KEY_REUSED = "urn:problem-type:thunder-bridge-direct:idempotency-key-reused";
+var PAYMENT_ALREADY_WATCHED = "urn:problem-type:thunder-bridge-direct: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;
+  }
+};
+
+// ../core/bytes.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length >> 1);
+  for (let at = 0; at < bytes.length; at++) {
+    bytes[at] = parseInt(hex.slice(at * 2, at * 2 + 2), 16);
+  }
+  return bytes;
+}
+function isHex(text2) {
+  return /^[0-9a-f]+$/i.test(text2) && text2.length % 2 === 0;
+}
+
+// ../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 recent2 = schedule[at - 15];
+    const distant = schedule[at - 2];
+    const mixedRecent = rotate(recent2, 7) ^ rotate(recent2, 18) ^ recent2 >>> 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 preimageMatchesHash(preimage, paymentHash) {
+  if (!isHex(preimage)) return false;
+  return bytesToHex(sha256(hexToBytes(preimage))) === paymentHash.toLowerCase();
+}
+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 hostIsPublic(host) {
+  if (host.startsWith("[")) return ipv6IsGlobal(host.slice(1, -1));
+  const name = host.replace(/\.$/, "");
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) return ipv4IsGlobal(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));
+}
+
+// src/verify.ts
+var HTTP_TIMEOUT_MS = 15e3;
+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");
+  }
+  if (invoice.amountMsat !== request.amountMsat) throw cheat("amount_mismatch");
+  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");
+  }
+  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");
+  }
+}
+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;
+  if (!preimageMatchesHash(verified.preimage, payment.paymentHash)) {
+    throw new GatewayCheatError("preimage_mismatch", payment.id);
+  }
+  return verified.preimage;
+}
+function isProvablyPaid(payment) {
+  if (payment.status !== "paid" || payment.preimage === null) return false;
+  const invoiceHash = decodeInvoice(payment.bolt11).paymentHash;
+  if (invoiceHash === null || !equalIgnoringCase(invoiceHash, payment.paymentHash)) return false;
+  return preimageMatchesHash(payment.preimage, invoiceHash);
+}
+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");
+  }
+  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);
+  }
+}
+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(params, trigger) {
+  return JSON.stringify({
+    ln_addresses: params.lnAddresses,
+    incoming_amount: toAmount(params.amountMsat),
+    webhook: params.webhookUrl ? { url: params.webhookUrl, secret: params.webhookSecret } : void 0,
+    trigger: trigger ?? void 0
+  });
+}
+function quoteRequestBody(params) {
+  return JSON.stringify({
+    ln_addresses: params.lnAddresses,
+    amount: toAmount(params.amountMsat)
+  });
+}
+function quoteFromWire(body) {
+  const wire = asObject(body);
+  if (wire === null) return null;
+  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 refusals2 = refusalsFrom(wire["refusals"]);
+  if (lnAddress === null || amountMsat === null || feeMsat === null) return null;
+  if (minMsat === null || maxMsat === null || metadata === null || refusals2 === null) return null;
+  return { lnAddress, amountMsat, feeMsat, minMsat, maxMsat, metadata, refusals: refusals2 };
+}
+function paymentFromWire(body) {
+  const wire = asObject(body);
+  if (wire === null) return null;
+  const id = text(wire["id"]);
+  const lnAddress = text(wire["ln_address"]);
+  const bolt11 = text(wire["bolt11"]);
+  const paymentHash = text(wire["payment_hash"]);
+  const verifyUrl = text(wire["verify_url"]);
+  const amountMsat = msatFrom(wire["incoming_amount"], 1);
+  const expiresAt = secondsFrom(wire["expires_at"]);
+  const createdAt = secondsFrom(wire["created_at"]);
+  const status = wire["status"];
+  const preimage = wire["preimage"] ?? null;
+  if (id === null || lnAddress === null || bolt11 === null) return null;
+  if (paymentHash === null || verifyUrl === null) return null;
+  if (amountMsat === null || expiresAt === null || createdAt === null) return null;
+  if (!isStatus(status)) return null;
+  if (preimage !== null && typeof preimage !== "string") return null;
+  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}`);
+  }
+  return JSON.stringify({
+    payment_hash: params.paymentHash,
+    verify_url: params.verifyUrl,
+    expires_at: expiresAt.toISOString(),
+    trigger: trigger ?? void 0,
+    sealed: params.sealed
+  });
+}
+function triggerEventFromWire(body) {
+  const wire = asObject(body);
+  if (wire === null) return null;
+  const id = text(wire["id"]);
+  const paymentHash = text(wire["payment_hash"]);
+  const verifyUrl = text(wire["verify_url"]);
+  const expiresAt = secondsFrom(wire["expires_at"]);
+  const createdAt = secondsFrom(wire["created_at"]);
+  const status = wire["status"];
+  const preimage = wire["preimage"] ?? null;
+  const sealed = wire["sealed"] ?? null;
+  if (id === null || paymentHash === null || verifyUrl === null) return null;
+  if (expiresAt === null || createdAt === null || !isStatus(status)) return null;
+  if (preimage !== null && typeof preimage !== "string") return null;
+  if (sealed !== null && typeof sealed !== "string") return null;
+  return {
+    id,
+    paymentHash,
+    verifyUrl,
+    status,
+    preimage,
+    expiresAt,
+    createdAt,
+    sealed,
+    lnAddress: text(wire["ln_address"]),
+    amountMsat: wire["incoming_amount"] === void 0 ? null : msatFrom(wire["incoming_amount"], 1)
+  };
+}
+function toAmount(msat) {
+  return { value: String(msat), asset_code: ASSET_CODE, asset_scale: ASSET_SCALE };
+}
+function asObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  return value;
+}
+function text(value) {
+  return typeof value === "string" ? value : null;
+}
+function msatFrom(value, least) {
+  const amount = asObject(value);
+  if (amount === null) return null;
+  if (amount["asset_code"] !== ASSET_CODE || amount["asset_scale"] !== ASSET_SCALE) return null;
+  const digits = amount["value"];
+  if (typeof digits !== "string" || !/^[0-9]+$/.test(digits)) return null;
+  const msat = Number(digits);
+  return Number.isSafeInteger(msat) && msat >= least ? msat : null;
+}
+function refusalsFrom(value) {
+  if (!Array.isArray(value)) return null;
+  const refusals2 = [];
+  for (const entry of value) {
+    const failure = asObject(entry);
+    const address = failure === null ? null : text(failure["address"]);
+    const reason = failure?.["reason"];
+    if (address === null || typeof reason !== "string" || !REASONS.has(reason)) return null;
+    refusals2.push({ address, reason });
+  }
+  return refusals2;
+}
+function secondsFrom(value) {
+  if (typeof value !== "string") return null;
+  const milliseconds = Date.parse(value);
+  return Number.isNaN(milliseconds) ? null : Math.floor(milliseconds / 1e3);
+}
+function isStatus(value) {
+  return value === "pending" || value === "paid" || value === "expired";
+}
+
+// src/client.ts
+var TERMINAL = /* @__PURE__ */ new Set(["paid", "expired"]);
+var RECONNECT_DELAY_MS = 3e3;
+var RECONNECT_CAP_MS = 3e4;
+var UNANSWERED_ATTEMPTS = 5;
+function backoffMs(firstDelay, attempt) {
+  const grown = Math.min(firstDelay * 2 ** (attempt - 1), RECONNECT_CAP_MS);
+  return Math.round(grown * (0.5 + Math.random() / 2));
+}
+var ThunderBridge = class {
+  baseUrl;
+  verify;
+  token;
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.verify = options?.verify ?? true;
+    this.token = options?.token ?? null;
+  }
+  /**
+   * 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) {
+    const headers = this.sending();
+    if (options?.idempotencyKey) headers["idempotency-key"] = options.idempotencyKey;
+    const response = await fetch(`${this.baseUrl}/incoming-payments`, {
+      method: "POST",
+      headers,
+      body: createRequestBody(params, options?.trigger ? sha256Hex(options.trigger) : null)
+    });
+    if (!response.ok) throw await problemFrom(response);
+    const payment = await paymentFrom(response);
+    if (this.verify) await proveOrigin(payment, params);
+    return payment;
+  }
+  /**
+   * Ask which address would serve an amount without minting anything, throws
+   * `NoWalletAvailableError` when none would. A quote is a probe and not a
+   * promise: the address it names can still be refused at create time, because
+   * whether a wallet returns a provable invoice cannot be known without asking
+   * it for one, and asking mints it
+   */
+  async createQuote(params) {
+    const response = await fetch(`${this.baseUrl}/quotes`, {
+      method: "POST",
+      headers: this.sending(),
+      body: quoteRequestBody(params)
+    });
+    if (!response.ok) throw await problemFrom(response);
+    const quote = quoteFromWire(await response.json().catch(() => null));
+    if (quote === null) {
+      throw new ProblemError({
+        status: response.status,
+        title: "The gateway answered with something that is not a quote"
+      });
+    }
+    return quote;
+  }
+  /** Read a payment back, null when the gateway has never heard of it */
+  async getPayment(id) {
+    const response = await fetch(`${this.baseUrl}/incoming-payments/${encodeURIComponent(id)}`, {
+      headers: this.reading()
+    });
+    if (response.status === 404) return null;
+    if (!response.ok) throw await problemFrom(response);
+    return this.checked(await paymentFrom(response));
+  }
+  /**
+   * List what this gateway is watching, newest first. Only a gateway started
+   * with `GATEWAY_TOKEN` serves this, because on a shared one it would hand
+   * every caller everyone else's payments, so a public gateway answers 404.
+   *
+   * `scanned` says how many settled records were looked at to build the page.
+   * Anything older than that window is not in the answer, and the list does not
+   * pretend otherwise
+   */
+  async listPayments(limit) {
+    const query = limit === void 0 ? "" : `?limit=${limit}`;
+    const response = await fetch(`${this.baseUrl}/incoming-payments${query}`, {
+      headers: this.reading()
+    });
+    if (!response.ok) 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") {
+      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 };
+  }
+  /**
+   * Follow a payment over WebSocket until it is paid or expired, reconnecting
+   * through a drop. A payment that never answers gives up after a few tries, and
+   * one that has answered is followed until its own expiry, so the wait always
+   * ends by itself
+   */
+  waitForPayment(id, options) {
+    const base = this.baseUrl.replace(/^http/, "ws");
+    const direct = `${base}/ws/incoming-payments/${encodeURIComponent(id)}`;
+    return new Promise((resolve2, reject) => {
+      const aborted = () => new Error(`waiting for payment ${id} was aborted`);
+      if (options?.signal?.aborted) {
+        reject(aborted());
+        return;
+      }
+      let socket = null;
+      let settled = false;
+      let attempt = 0;
+      let expiresAt = null;
+      let retry;
+      const abort = () => settle(() => reject(aborted()));
+      const settle = (finish) => {
+        if (settled) return;
+        settled = true;
+        options?.signal?.removeEventListener("abort", abort);
+        clearTimeout(retry);
+        finish();
+        socket?.close();
+      };
+      const again = () => {
+        if (settled) return;
+        if (expiresAt === null && attempt >= UNANSWERED_ATTEMPTS) {
+          settle(() => reject(new Error(`no gateway answered for payment ${id}`)));
+          return;
+        }
+        if (expiresAt !== null && Date.now() >= expiresAt * 1e3) {
+          settle(() => reject(new Error(`payment ${id} went unreported past its expiry`)));
+          return;
+        }
+        retry = setTimeout(() => void connect(), backoffMs(RECONNECT_DELAY_MS, attempt));
+      };
+      const connect = async () => {
+        if (settled) return;
+        attempt += 1;
+        let url = direct;
+        if (this.needsTicket(options?.tickets)) {
+          try {
+            url = `${base}/ws/tickets/${await this.wsTicket({ payment_id: id })}`;
+          } catch (refused) {
+            if (refused instanceof ProblemError) settle(() => reject(refused));
+            else again();
+            return;
+          }
+        }
+        if (settled) return;
+        const opened = new WebSocket(url);
+        socket = opened;
+        opened.onmessage = (event) => {
+          try {
+            const payment = paymentFromWire(JSON.parse(String(event.data)));
+            if (payment === null) return;
+            expiresAt = payment.expiresAt;
+            attempt = 1;
+            if (!TERMINAL.has(payment.status)) return;
+            const checked = this.checked(payment);
+            settle(() => resolve2(checked));
+          } catch (refused) {
+            settle(() => reject(refused));
+          }
+        };
+        opened.onclose = again;
+      };
+      options?.signal?.addEventListener("abort", abort, { once: true });
+      void connect();
+    });
+  }
+  /**
+   * Hand over an invoice you obtained yourself so the gateway watches it without
+   * being told the address or the amount. It can then only refuse everyone
+   * 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) {
+    const response = await fetch(`${this.baseUrl}/watched-payments`, {
+      method: "POST",
+      headers: this.sending(),
+      body: watchRequestBody(params, params.trigger ? sha256Hex(params.trigger) : null)
+    });
+    if (!response.ok) throw await problemFrom(response);
+    const watched = triggerEventFromWire(await response.json().catch(() => null));
+    if (watched === null) {
+      throw new ProblemError({
+        status: response.status,
+        title: "The gateway answered with something that is not a watched payment"
+      });
+    }
+    return watched;
+  }
+  /**
+   * 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) {
+    const base = this.baseUrl.replace(/^http/, "ws");
+    const direct = `${base}/ws/triggers/${encodeURIComponent(secret)}`;
+    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 connect = async () => {
+      attempt += 1;
+      let url = direct;
+      if (this.needsTicket(options.tickets)) {
+        try {
+          url = `${base}/ws/tickets/${await this.wsTicket({ trigger_secret: secret })}`;
+        } catch (refused) {
+          options.onError?.(refused);
+          again();
+          return;
+        }
+      }
+      if (stopped) return;
+      socket = new WebSocket(url);
+      socket.onopen = () => {
+        attempt = 1;
+      };
+      socket.onmessage = (event) => {
+        try {
+          const settled = triggerEventFromWire(JSON.parse(String(event.data)));
+          if (settled !== null) options.onPayment(this.proven(settled));
+        } catch (refused) {
+          options.onError?.(refused);
+        }
+      };
+      socket.onerror = () => options.onError?.(new Error(`could not follow trigger at ${base}`));
+      socket.onclose = again;
+    };
+    void connect();
+    return () => {
+      stopped = true;
+      clearTimeout(retry);
+      socket?.close();
+    };
+  }
+  needsTicket(asked) {
+    return asked === true || this.token !== null;
+  }
+  async wsTicket(body) {
+    const response = await fetch(`${this.baseUrl}/ws-tickets`, {
+      method: "POST",
+      headers: this.sending(),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) throw await problemFrom(response);
+    const minted = await response.json().catch(() => null);
+    if (typeof minted?.ticket !== "string") {
+      throw new ProblemError({
+        status: response.status,
+        title: "The gateway answered with something that is not a ticket"
+      });
+    }
+    return encodeURIComponent(minted.ticket);
+  }
+  sending() {
+    return { "content-type": "application/json", ...this.reading() };
+  }
+  reading() {
+    return this.token === null ? {} : { authorization: `Bearer ${this.token}` };
+  }
+  proven(settled) {
+    const unproven = settled.status === "paid" && (settled.preimage === null || !preimageMatchesHash(settled.preimage, settled.paymentHash));
+    if (this.verify && unproven) throw new GatewayCheatError("preimage_mismatch", settled.id);
+    return settled;
+  }
+  checked(payment) {
+    if (this.verify && payment.status === "paid" && !isProvablyPaid(payment)) {
+      throw new GatewayCheatError("preimage_mismatch", payment.id);
+    }
+    return payment;
+  }
+};
+async function paymentFrom(response) {
+  const payment = paymentFromWire(await response.json().catch(() => null));
+  if (payment === null) {
+    throw new ProblemError({
+      status: response.status,
+      title: "The gateway answered with something that is not a payment"
+    });
+  }
+  return payment;
+}
+async function problemFrom(response) {
+  const problem = await response.json().catch(() => ({}));
+  const document = { ...problem, status: response.status };
+  if (problem.type === NO_WALLET_AVAILABLE) {
+    return new NoWalletAvailableError(document, refusals(problem.wallets));
+  }
+  if (problem.type === REQUEST_IN_FLIGHT) {
+    return new IdempotencyConflictError(document, "request-in-flight");
+  }
+  if (problem.type === IDEMPOTENCY_KEY_REUSED) {
+    return new IdempotencyConflictError(document, "key-reused");
+  }
+  return new ProblemError(document);
+}
+function refusals(wallets) {
+  if (!Array.isArray(wallets)) return [];
+  return wallets.filter((wallet) => {
+    return typeof wallet === "object" && wallet !== null && "address" in wallet;
+  });
+}
+
+// ../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-direct/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 unseal(secret, sealed) {
+  const key = await keyFor(secret);
+  if (!sealed.startsWith(`${VERSION}.`)) return null;
+  const joined = fromBase64Url(sealed.slice(VERSION.length + 1));
+  if (joined === null || joined.length <= IV_BYTES) return null;
+  try {
+    const body = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: joined.slice(0, IV_BYTES) },
+      key,
+      joined.slice(IV_BYTES)
+    );
+    return new TextDecoder().decode(body);
+  } catch {
+    return null;
+  }
+}
+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(/=+$/, "");
+}
+function fromBase64Url(text2) {
+  if (text2.length === 0 || !/^[A-Za-z0-9_-]+$/.test(text2)) return null;
+  try {
+    const binary = atob(text2.replace(/-/g, "+").replace(/_/g, "/"));
+    const bytes = new Uint8Array(binary.length);
+    for (let at = 0; at < bytes.length; at++) bytes[at] = binary.charCodeAt(at);
+    return bytes;
+  } catch {
+    return null;
+  }
+}
+
+// ../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/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 HTTP_TIMEOUT_MS2 = 15e3;
+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";
+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 refusals2 = [];
+  for (const address of addresses) {
+    if (deadline.aborted) break;
+    try {
+      return { won: await attempt(address, deadline), refusals: refusals2 };
+    } catch (refusal) {
+      if (!(refusal instanceof WalletRefused)) throw refusal;
+      console.warn(`wallet ${address} refused, ${refusal.reason}: ${refusal.message}`);
+      refusals2.push({ address, reason: refusal.reason });
+    }
+  }
+  throw new NoWalletAvailable(refusals2);
+}
+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 toLnurl(endpoint) {
+  const scheme = parsedScheme(endpoint);
+  if (scheme !== "https:" && scheme !== "http:") {
+    throw new Error(`${endpoint} is not an http or https URL`);
+  }
+  const words = toWords(new TextEncoder().encode(endpoint));
+  const data = [...words, ...checksumWords(LNURL_HRP, words)];
+  return `${LNURL_HRP}1${data.map((word) => BECH32_CHARSET2[word]).join("")}`.toUpperCase();
+}
+function parsedScheme(endpoint) {
+  try {
+    return new URL(endpoint).protocol;
+  } catch {
+    return null;
+  }
+}
+function toWords(bytes) {
+  const words = [];
+  let accumulator = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    accumulator = accumulator << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      words.push(accumulator >> bits & 31);
+    }
+  }
+  if (bits > 0) words.push(accumulator << 5 - bits & 31);
+  return words;
+}
+function checksumWords(hrp, words) {
+  const expanded = [...hrp].map((char) => char.charCodeAt(0));
+  const values = [
+    ...expanded.map((code) => code >> 5),
+    0,
+    ...expanded.map((code) => code & 31),
+    ...words,
+    ...CHECKSUM_SLOTS.map(() => 0)
+  ];
+  const polymod = bech32Polymod(values) ^ 1;
+  return CHECKSUM_SLOTS.map((slot) => polymod >> 5 * (5 - slot) & 31);
+}
+function bech32Polymod(values) {
+  let checksum = 1;
+  for (const value of values) {
+    const top = checksum >> 25;
+    checksum = (checksum & 33554431) << 5 ^ value;
+    for (let bit = 0; bit < 5; bit++) {
+      if (top >> bit & 1) checksum ^= BECH32_GENERATOR[bit];
+    }
+  }
+  return checksum;
+}
+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) {
+  if (!publicHttps(url)) throw new Error(`${url} is not a public https URL`);
+  const capped = AbortSignal.timeout(HTTP_TIMEOUT_MS2);
+  const response = await fetch(url, {
+    signal: deadline ? AbortSignal.any([deadline, capped]) : capped,
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) throw new Error(`${url} answered ${response.status}`);
+  return await response.json();
+}
+
+// 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 && refused.type === 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
+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 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/webhook.ts
+var SIGNATURE_HEADER = "x-signature";
+var TIMESTAMP_HEADER = "x-timestamp";
+var SIGNATURE_PREFIX = "sha256=";
+var DEFAULT_TOLERANCE_SECS = 300;
+async function verifyWebhookSignature(body, signature, secret, timestamp, options = {}) {
+  if (!recent(timestamp, options.toleranceSecs ?? DEFAULT_TOLERANCE_SECS)) return false;
+  const received = signature.startsWith(SIGNATURE_PREFIX) ? signature.slice(SIGNATURE_PREFIX.length) : signature;
+  return equalInConstantTime(await sign2(secret, timestamp, body), received.toLowerCase());
+}
+async function parseWebhook(body, signature, secret, timestamp, options = {}) {
+  if (!await verifyWebhookSignature(body, signature, secret, 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 parseWebhookRequest(request, secret, 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, secret, timestamp, options);
+}
+function recent(timestamp, toleranceSecs) {
+  const sent = Number(timestamp);
+  if (!Number.isFinite(sent)) return false;
+  return Math.abs(Math.floor(Date.now() / 1e3) - sent) <= toleranceSecs;
+}
+async function sign2(secret, timestamp, body) {
+  return hmacHex(secret, signed(timestamp, body));
+}
+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;
+}
+export {
+  GatewayCheatError,
+  IDEMPOTENCY_KEY_REUSED,
+  IdempotencyConflictError,
+  NO_WALLET_AVAILABLE,
+  NoWalletAvailableError,
+  PAYMENT_ALREADY_WATCHED,
+  ProblemError,
+  REQUEST_IN_FLIGHT,
+  ThunderBridge,
+  UnverifiedRecipientError,
+  decodeInvoice,
+  invoiceToDataUrl,
+  invoiceToSvg,
+  isProvablyPaid,
+  lnurlPayEndpoint,
+  lnurlToDataUrl,
+  lnurlToSvg,
+  parseWebhook,
+  parseWebhookRequest,
+  preimageMatchesHash,
+  proveOrigin,
+  proveSettlement,
+  seal,
+  toLnurl,
+  unseal,
+  verifyWebhookSignature
+};