thunder-bridge 1.1.0 → 1.4.0

package/dist/server.cjs

@@ -30,18 +30,31 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server.ts
 var server_exports = {};
 __export(server_exports, {
+  askWallet: () => askWallet,
   blindLightningRail: () => blindLightningRail,
   invoiceFrom: () => invoiceFrom,
   lightningVerifyEndpoint: () => lightningVerifyEndpoint,
   lnurlPayEndpoint: () => lnurlPayEndpoint,
-  relayedVerifyUrl: () => relayedVerifyUrl
+  nwcConnection: () => nwcConnection,
+  nwcHoldInvoice: () => nwcHoldInvoice,
+  nwcInvoice: () => nwcInvoice,
+  nwcPay: () => nwcPay,
+  nwcRail: () => nwcRail,
+  nwcSettlement: () => nwcSettlement,
+  nwcVerifyEndpoint: () => nwcVerifyEndpoint,
+  nwcVerifyUrl: () => nwcVerifyUrl,
+  publicWatchTicketEndpoint: () => publicWatchTicketEndpoint,
+  relayedVerifyUrl: () => relayedVerifyUrl,
+  watchTicketEndpoint: () => watchTicketEndpoint
 });
 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");
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
   return hex;
 }
 function hexToBytes(hex) {
@@ -55,29 +68,6 @@ function isHex(text2) {
   return /^[0-9a-f]+$/i.test(text2) && text2.length % 2 === 0;
 }
 
-// ../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,
@@ -159,11 +149,11 @@ 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 padded2 = withPadding(bytes);
+  const reader = new DataView(padded2.buffer);
   const state = Uint32Array.from(INITIAL_STATE);
   const schedule = new Uint32Array(SCHEDULE_WORDS);
-  for (let block = 0; block < padded.length; block += BLOCK_BYTES) {
+  for (let block = 0; block < padded2.length; block += BLOCK_BYTES) {
     fillSchedule(schedule, reader, block);
     compress(state, schedule);
   }
@@ -173,16 +163,18 @@ function sha256Hex(text2) {
   return bytesToHex(sha256(new TextEncoder().encode(text2)));
 }
 function withPadding(bytes) {
-  const padded = new Uint8Array(
+  const padded2 = 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;
+  padded2.set(bytes);
+  padded2[bytes.length] = 128;
+  new DataView(padded2.buffer).setUint32(padded2.length - 4, bytes.length * 8, false);
+  return padded2;
 }
 function fillSchedule(schedule, reader, block) {
-  for (let at = 0; at < 16; at++) schedule[at] = reader.getUint32(block + at * 4, false);
+  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];
@@ -216,12 +208,16 @@ function compress(state, schedule) {
     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;
+  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);
+  for (let at = 0; at < state.length; at++) {
+    writer.setUint32(at * 4, state[at], false);
+  }
   return digest;
 }
 function rotate(value, by) {
@@ -262,20 +258,30 @@ function decodeInvoice(bolt11) {
   };
 }
 function preimageMatchesHash(preimage, paymentHash) {
-  if (!isHex(preimage)) return false;
+  if (!isHex(preimage)) {
+    return false;
+  }
   return bytesToHex(sha256(hexToBytes(preimage))) === paymentHash.toLowerCase();
 }
 function splitBech32(bolt11) {
   const lower = bolt11.toLowerCase();
-  if (isBolt12Encoding(lower)) return null;
+  if (isBolt12Encoding(lower)) {
+    return null;
+  }
   const separator = lower.lastIndexOf("1");
-  if (separator < 1) return null;
+  if (separator < 1) {
+    return null;
+  }
   const dataChars = lower.slice(separator + 1);
-  if (dataChars.length < CHECKSUM_WORDS) return null;
+  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;
+    if (value === -1) {
+      return null;
+    }
     words.push(value);
   }
   return { hrp: lower.slice(0, separator), words: words.slice(0, -CHECKSUM_WORDS) };
@@ -291,25 +297,35 @@ function taggedFields(words) {
     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));
+    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;
+  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;
+  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;
+  if (match === null) {
+    return null;
+  }
   const [, digits, multiplier] = match;
   return multiplier ? Number(digits) * HRP_MULTIPLIER_MSAT[multiplier] : Number(digits) * MSAT_PER_BTC;
 }
@@ -331,172 +347,751 @@ function wordsToBytes(words) {
   return Uint8Array.from(bytes);
 }
 
-// ../core/url.ts
-var PRIVATE_SUFFIXES = ["localhost", "local", "internal", "lan", "arpa", "test", "invalid"];
-function publicHttps(raw) {
-  let url;
+// ../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/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 joined2 = new Uint8Array(iv.length + cipher.length);
+  joined2.set(iv);
+  joined2.set(cipher, iv.length);
+  return `${VERSION}.${toBase64Url(joined2)}`;
+}
+async function unseal(secret, sealed) {
+  const key = await keyFor(secret);
+  if (!sealed.startsWith(`${VERSION}.`)) {
+    return null;
+  }
+  const joined2 = fromBase64Url(sealed.slice(VERSION.length + 1));
+  if (joined2 === null || joined2.length <= IV_BYTES) {
+    return null;
+  }
   try {
-    url = new URL(raw);
+    const body = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: joined2.slice(0, IV_BYTES) },
+      key,
+      joined2.slice(IV_BYTES)
+    );
+    return new TextDecoder().decode(body);
   } catch {
-    return false;
+    return null;
   }
-  return url.protocol === "https:" && hostIsPublic(url.hostname.toLowerCase());
 }
-function sameOrigin(one, other) {
+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 {
-    return new URL(one).origin === new URL(other).origin;
+    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 false;
+    return null;
   }
 }
-function publicAddress(literal) {
-  return literal.includes(":") ? ipv6IsGlobal(literal) : ipv4IsGlobal(literal);
+
+// src/nostr.ts
+var import_chacha = require("@noble/ciphers/chacha.js");
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_hkdf = require("@noble/hashes/hkdf.js");
+var import_hmac = require("@noble/hashes/hmac.js");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var NIP44_SALT = new TextEncoder().encode("nip44-v2");
+var NIP44_VERSION = 2;
+var NONCE_BYTES = 32;
+var MAC_BYTES = 32;
+var MESSAGE_KEYS_BYTES = 76;
+var CHACHA_KEY_END = 32;
+var CHACHA_NONCE_END = 44;
+var LENGTH_PREFIX_BYTES = 2;
+var SMALLEST_PAD = 32;
+var CHUNKS_STAY_SMALL_TO = 256;
+var MAX_PLAINTEXT_BYTES = 65535;
+function publicKeyFor(privateKeyHex) {
+  return bytesToHex(import_secp256k1.schnorr.getPublicKey(hexToBytes(privateKeyHex)));
+}
+function conversationKeyFor(privateKeyHex, publicKeyHex) {
+  const shared = import_secp256k1.secp256k1.getSharedSecret(
+    hexToBytes(privateKeyHex),
+    hexToBytes(`02${publicKeyHex}`)
+  );
+  return (0, import_hkdf.extract)(import_sha2.sha256, shared.subarray(1, 33), NIP44_SALT);
 }
-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 signEvent(privateKeyHex, draft) {
+  const pubkey = publicKeyFor(privateKeyHex);
+  const id = idOf(pubkey, draft);
+  return {
+    id,
+    pubkey,
+    created_at: draft.created_at,
+    kind: draft.kind,
+    tags: draft.tags,
+    content: draft.content,
+    sig: bytesToHex(import_secp256k1.schnorr.sign(hexToBytes(id), hexToBytes(privateKeyHex)))
+  };
 }
-function ipv4IsGlobal(literal) {
-  const parts = literal.split(".").map(Number);
-  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+function verifyEvent(event) {
+  try {
+    return idOf(event.pubkey, event) === event.id && import_secp256k1.schnorr.verify(hexToBytes(event.sig), hexToBytes(event.id), hexToBytes(event.pubkey));
+  } catch {
     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 idOf(pubkey, draft) {
+  return bytesToHex(
+    (0, import_sha2.sha256)(
+      new TextEncoder().encode(
+        JSON.stringify([0, pubkey, draft.created_at, draft.kind, draft.tags, draft.content])
+      )
+    )
+  );
 }
-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));
+function encryptNip44(conversationKey, plaintext) {
+  return sealNip44(conversationKey, plaintext, crypto.getRandomValues(new Uint8Array(NONCE_BYTES)));
 }
-
-// ../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;
+function sealNip44(conversationKey, plaintext, nonce) {
+  const keys = messageKeysFrom(conversationKey, nonce);
+  const ciphertext = (0, import_chacha.chacha20)(keys.chachaKey, keys.chachaNonce, padded(plaintext));
+  const mac = (0, import_hmac.hmac)(import_sha2.sha256, keys.hmacKey, joined(nonce, ciphertext));
+  return toBase64(joined(Uint8Array.of(NIP44_VERSION), nonce, ciphertext, mac));
+}
+function decryptNip44(conversationKey, payload) {
+  if (payload.startsWith("#")) {
+    throw new Error("nip44 payload announces an encryption version we do not speak");
   }
-  throw new Error(`${url} redirected more than ${HOPS_FOLLOWED} times`);
+  const raw = fromBase64(payload);
+  if (raw.length < 1 + NONCE_BYTES + MAC_BYTES) {
+    throw new Error(`nip44 payload is ${raw.length} bytes, too short to hold a nonce and a mac`);
+  }
+  if (raw[0] !== NIP44_VERSION) {
+    throw new Error(`nip44 payload is version ${raw[0]}, not ${NIP44_VERSION}`);
+  }
+  const nonce = raw.subarray(1, 1 + NONCE_BYTES);
+  const ciphertext = raw.subarray(1 + NONCE_BYTES, raw.length - MAC_BYTES);
+  const mac = raw.subarray(raw.length - MAC_BYTES);
+  const keys = messageKeysFrom(conversationKey, nonce);
+  if (!sameBytes((0, import_hmac.hmac)(import_sha2.sha256, keys.hmacKey, joined(nonce, ciphertext)), mac)) {
+    throw new Error("nip44 payload failed its mac, so it was not written with this key");
+  }
+  return unpadded((0, import_chacha.chacha20)(keys.chachaKey, keys.chachaNonce, ciphertext));
 }
-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`);
+function messageKeysFrom(conversationKey, nonce) {
+  if (conversationKey.length !== NONCE_BYTES || nonce.length !== NONCE_BYTES) {
+    throw new Error("a nip44 conversation key and nonce are both 32 bytes");
   }
-  return found;
+  const keys = (0, import_hkdf.expand)(import_sha2.sha256, conversationKey, nonce, MESSAGE_KEYS_BYTES);
+  return {
+    chachaKey: keys.subarray(0, CHACHA_KEY_END),
+    chachaNonce: keys.subarray(CHACHA_KEY_END, CHACHA_NONCE_END),
+    hmacKey: keys.subarray(CHACHA_NONCE_END)
+  };
 }
-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 ?? [];
+function paddedLengthFor(unpadded2) {
+  if (unpadded2 <= SMALLEST_PAD) {
+    return SMALLEST_PAD;
+  }
+  const nextPower = 1 << Math.floor(Math.log2(unpadded2 - 1)) + 1;
+  const chunk = nextPower <= CHUNKS_STAY_SMALL_TO ? SMALLEST_PAD : nextPower / 8;
+  return chunk * (Math.floor((unpadded2 - 1) / chunk) + 1);
 }
-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;
+function padded(plaintext) {
+  const body = new TextEncoder().encode(plaintext);
+  if (body.length === 0 || body.length > MAX_PLAINTEXT_BYTES) {
+    throw new Error(`nip44 takes 1 to ${MAX_PLAINTEXT_BYTES} bytes, this was ${body.length}`);
   }
-  await reader.cancel();
-  return { status, ok, body: text(read), truncated: true, headers };
+  const buffer = new Uint8Array(LENGTH_PREFIX_BYTES + paddedLengthFor(body.length));
+  buffer.set(Uint8Array.of(body.length >>> 8, body.length & 255));
+  buffer.set(body, LENGTH_PREFIX_BYTES);
+  return buffer;
+}
+function unpadded(buffer) {
+  const length = (buffer[0] ?? 0) << 8 | (buffer[1] ?? 0);
+  if (length === 0 || buffer.length !== LENGTH_PREFIX_BYTES + paddedLengthFor(length)) {
+    throw new Error("nip44 plaintext does not match the length its own padding declares");
+  }
+  return new TextDecoder().decode(
+    buffer.subarray(LENGTH_PREFIX_BYTES, LENGTH_PREFIX_BYTES + length)
+  );
 }
-function withoutBody(sent) {
-  const headers = { ...sent.headers };
-  delete headers["content-type"];
-  return { ...sent, method: "GET", headers, body: void 0 };
+function joined(...parts) {
+  const whole = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
+  let at = 0;
+  for (const part of parts) {
+    whole.set(part, at);
+    at += part.length;
+  }
+  return whole;
 }
-function withoutCredentials(sent) {
-  const headers = { ...sent.headers };
-  for (const named of CREDENTIALS) delete headers[named];
-  return { ...sent, headers };
+function sameBytes(left, right) {
+  let different = left.length ^ right.length;
+  for (let at = 0; at < left.length && at < right.length; at++) {
+    different |= (left[at] ?? 0) ^ (right[at] ?? 0);
+  }
+  return different === 0;
 }
-function text(chunks) {
-  const decoder = new TextDecoder();
-  let decoded = "";
-  for (const chunk of chunks) decoded += decoder.decode(chunk, { stream: true });
-  return decoded + decoder.decode();
+function toBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
 }
-
-// ../core/refusal.ts
-var WalletRefused = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.reason = reason;
+function fromBase64(text2) {
+  const binary = atob(text2);
+  const bytes = new Uint8Array(binary.length);
+  for (let at = 0; at < bytes.length; at++) {
+    bytes[at] = binary.charCodeAt(at);
   }
-};
-var NoWalletAvailable = class extends Error {
-  wallets;
-  constructor(wallets) {
-    super(wallets.map((wallet) => `${wallet.address} ${wallet.reason}`).join(", "));
-    this.wallets = wallets;
+  return bytes;
+}
+
+// ../core/ed25519.ts
+var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
+
+// src/webhook.ts
+var VERIFY_CHALLENGE = "verify-challenge";
+function nonceOf(text2, type) {
+  try {
+    const said = JSON.parse(text2);
+    if (said["type"] !== type || typeof said["nonce"] !== "string") {
+      return null;
+    }
+    return said["nonce"];
+  } catch {
+    return null;
+  }
+}
+function answerVerifyChallenge(body) {
+  const nonce = nonceOf(body, VERIFY_CHALLENGE);
+  return nonce === null ? null : JSON.stringify({ nonce });
+}
+async function answerVerifyChallengeRequest(request) {
+  if (request.method !== "POST") {
+    return null;
   }
+  const answer = answerVerifyChallenge(await request.clone().text());
+  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
+}
+
+// src/nwc.ts
+var REQUEST_KIND = 23194;
+var RESPONSE_KIND = 23195;
+var NIP44_V2 = "nip44_v2";
+var SCHEME = "nostr+walletconnect:";
+var HEX_32_BYTES = /^[0-9a-f]{64}$/i;
+var DEFAULT_ASK_TIMEOUT_MS = 1e4;
+var PAY_TIMEOUT_MS = 9e4;
+var DEFAULT_POLL_EVERY_SECS = 5;
+var HASH = "h";
+var REFUSAL_BY_CODE = {
+  INSUFFICIENT_BALANCE: "amount-not-accepted",
+  QUOTA_EXCEEDED: "amount-not-accepted",
+  RESTRICTED: "address-unusable",
+  UNAUTHORIZED: "address-unusable",
+  UNSUPPORTED_ENCRYPTION: "address-unusable"
 };
+function nwcConnection(uri) {
+  const parsed = parsedUri(uri);
+  const walletPubkey = parsed.pathname.replace(/^\/+/, "") || parsed.host;
+  const secret = parsed.searchParams.get("secret") ?? "";
+  const relays = parsed.searchParams.getAll("relay");
+  if (!HEX_32_BYTES.test(walletPubkey)) {
+    throw new WalletRefused("address-unusable", "an nwc uri names a 32-byte wallet pubkey");
+  }
+  if (!HEX_32_BYTES.test(secret)) {
+    throw new WalletRefused("address-unusable", "an nwc uri carries a 32-byte hex secret");
+  }
+  if (relays.length === 0 || !relays.every(isSecureRelay)) {
+    throw new WalletRefused("address-unusable", "every nwc relay has to be a wss URL");
+  }
+  return { walletPubkey: walletPubkey.toLowerCase(), relays, secret: secret.toLowerCase() };
+}
+async function nwcInvoice(connection, amountMsat, description, timeoutMs = DEFAULT_ASK_TIMEOUT_MS) {
+  const answered2 = await askWallet(
+    connection,
+    "make_invoice",
+    { amount: amountMsat, description },
+    timeoutMs
+  );
+  const bolt11 = String(answered2.invoice ?? "");
+  const issued = decodeInvoice(bolt11);
+  if (issued.paymentHash === null || issued.expiresAt === null) {
+    throw new WalletRefused("invoice-refused", "the nwc wallet issued an invoice we cannot decode");
+  }
+  if (issued.amountMsat !== amountMsat) {
+    throw new WalletRefused(
+      "invoice-refused",
+      `the nwc wallet issued an invoice for ${issued.amountMsat} msat, not ${amountMsat}`
+    );
+  }
+  return { bolt11, paymentHash: issued.paymentHash, expiresAt: issued.expiresAt };
+}
+async function nwcHoldInvoice(connection, held, timeoutMs = DEFAULT_ASK_TIMEOUT_MS) {
+  const answered2 = await askWallet(
+    connection,
+    "make_hold_invoice",
+    {
+      amount: held.amountMsat,
+      description: held.description,
+      payment_hash: held.paymentHash,
+      expiry: held.expirySecs,
+      ...held.minCltvExpiryDelta === void 0 ? {} : { min_cltv_expiry_delta: held.minCltvExpiryDelta }
+    },
+    timeoutMs
+  );
+  const bolt11 = String(answered2.invoice ?? "");
+  const issued = decodeInvoice(bolt11);
+  if (issued.paymentHash === null || issued.expiresAt === null) {
+    throw new WalletRefused("invoice-refused", "the nwc wallet held an invoice we cannot decode");
+  }
+  if (issued.paymentHash.toLowerCase() !== held.paymentHash.toLowerCase()) {
+    throw new WalletRefused(
+      "invoice-refused",
+      `the nwc wallet held ${issued.paymentHash} rather than the ${held.paymentHash} asked for`
+    );
+  }
+  if (issued.amountMsat !== held.amountMsat) {
+    throw new WalletRefused(
+      "invoice-refused",
+      `the nwc wallet held an invoice for ${issued.amountMsat} msat, not ${held.amountMsat}`
+    );
+  }
+  return { bolt11, paymentHash: issued.paymentHash, expiresAt: issued.expiresAt };
+}
+async function nwcSettlement(connection, paymentHash, timeoutMs = DEFAULT_ASK_TIMEOUT_MS) {
+  const answered2 = await askWallet(
+    connection,
+    "lookup_invoice",
+    { payment_hash: paymentHash },
+    timeoutMs
+  );
+  const preimage = answered2.preimage;
+  if (typeof preimage !== "string" || preimage.length === 0) {
+    return null;
+  }
+  if (!preimageMatchesHash(preimage, paymentHash)) {
+    throw new Error(`the nwc wallet returned a preimage that does not hash to ${paymentHash}`);
+  }
+  return preimage;
+}
+async function nwcPay(connection, bolt11, timeoutMs = PAY_TIMEOUT_MS) {
+  const owed = decodeInvoice(bolt11);
+  if (owed.paymentHash === null) {
+    throw new WalletRefused("invoice-refused", "the invoice to pay carries no payment hash");
+  }
+  const answered2 = await askWallet(connection, "pay_invoice", { invoice: bolt11 }, timeoutMs);
+  const preimage = answered2.preimage;
+  if (typeof preimage !== "string" || !preimageMatchesHash(preimage, owed.paymentHash)) {
+    throw new Error(`the nwc wallet paid and returned no preimage hashing to ${owed.paymentHash}`);
+  }
+  return preimage;
+}
+function nwcVerifyEndpoint(config) {
+  const paced = {
+    "cache-control": `max-age=${config.pollEverySecs ?? DEFAULT_POLL_EVERY_SECS}`
+  };
+  return async (request) => {
+    const consented = await answerVerifyChallengeRequest(request);
+    if (consented !== null) {
+      return consented;
+    }
+    const sealed = new URL(request.url).searchParams.get(HASH);
+    if (sealed === null) {
+      return Response.json({ settled: false }, { status: 400 });
+    }
+    const paymentHash = await unseal(config.secret, sealed);
+    if (paymentHash === null) {
+      return Response.json({ settled: false }, { status: 403 });
+    }
+    const preimage = await nwcSettlement(config.connection, paymentHash, config.askTimeoutMs).catch(
+      () => void 0
+    );
+    if (preimage === void 0) {
+      return Response.json({ settled: false }, { status: 502 });
+    }
+    return Response.json({ settled: preimage !== null, preimage }, { headers: paced });
+  };
+}
+async function nwcVerifyUrl(endpoint, paymentHash, secret) {
+  const sealed = new URL(endpoint);
+  sealed.searchParams.set(HASH, await seal(secret, paymentHash));
+  return sealed.toString();
+}
+async function askWallet(connection, method, params, timeoutMs = DEFAULT_ASK_TIMEOUT_MS) {
+  const key = conversationKeyFor(connection.secret, connection.walletPubkey);
+  const request = signEvent(connection.secret, {
+    kind: REQUEST_KIND,
+    tags: [
+      ["p", connection.walletPubkey],
+      ["encryption", NIP44_V2]
+    ],
+    content: encryptNip44(key, JSON.stringify({ method, params })),
+    created_at: Math.floor(Date.now() / 1e3)
+  });
+  const answer = await overFirstRelayThatAnswers(connection, request, timeoutMs);
+  return resultOf(JSON.parse(decryptNip44(key, answer.content)), method);
+}
+function resultOf(said, method) {
+  const failure = said.error;
+  if (failure) {
+    throw new WalletRefused(
+      REFUSAL_BY_CODE[failure.code ?? ""] ?? "invoice-refused",
+      `the nwc wallet refused ${method}: ${failure.code ?? "unknown"} ${failure.message ?? ""}`.trim()
+    );
+  }
+  const result = said.result;
+  if (result === null || typeof result !== "object") {
+    throw new WalletRefused("invoice-refused", `the nwc wallet answered ${method} with no result`);
+  }
+  return result;
+}
+async function overFirstRelayThatAnswers(connection, request, timeoutMs) {
+  const deadline = AbortSignal.timeout(timeoutMs);
+  let lastFailure = null;
+  for (const relay of connection.relays) {
+    if (deadline.aborted) {
+      break;
+    }
+    try {
+      return await overRelay(relay, connection, request, deadline);
+    } catch (failure) {
+      lastFailure = failure;
+    }
+  }
+  throw new WalletRefused("unreachable", `no nwc relay answered: ${String(lastFailure)}`);
+}
+function overRelay(relay, connection, request, deadline) {
+  return new Promise((resolve2, reject) => {
+    const socket = new WebSocket(relay);
+    const subscription = request.id.slice(0, 16);
+    const expired = () => {
+      close();
+      reject(new Error(`${relay} did not answer before the deadline`));
+    };
+    deadline.addEventListener("abort", expired);
+    function close() {
+      deadline.removeEventListener("abort", expired);
+      socket.close();
+    }
+    socket.addEventListener("open", () => {
+      socket.send(
+        JSON.stringify([
+          "REQ",
+          subscription,
+          {
+            kinds: [RESPONSE_KIND],
+            authors: [connection.walletPubkey],
+            "#p": [publicKeyFor(connection.secret)],
+            "#e": [request.id]
+          }
+        ])
+      );
+      socket.send(JSON.stringify(["EVENT", request]));
+    });
+    socket.addEventListener("error", () => {
+      close();
+      reject(new Error(`${relay} could not be reached`));
+    });
+    socket.addEventListener("message", (delivered) => {
+      const frame = String(delivered.data);
+      const rejection = rejectionOf(frame, request.id);
+      if (rejection !== null) {
+        close();
+        reject(new Error(`${relay} refused the request: ${rejection}`));
+        return;
+      }
+      const answer = answeredEvent(frame, subscription, connection, request.id);
+      if (answer === null) {
+        return;
+      }
+      close();
+      resolve2(answer);
+    });
+  });
+}
+function rejectionOf(frame, requestId) {
+  const parsed = parsedFrame(frame);
+  if (parsed === null || parsed[0] !== "OK" || parsed[1] !== requestId || parsed[2] !== false) {
+    return null;
+  }
+  return typeof parsed[3] === "string" && parsed[3].length > 0 ? parsed[3] : "no reason given";
+}
+function answeredEvent(frame, subscription, connection, requestId) {
+  const parsed = parsedFrame(frame);
+  if (parsed === null || parsed[0] !== "EVENT" || parsed[1] !== subscription) {
+    return null;
+  }
+  const event = parsed[2];
+  const answers = event?.kind === RESPONSE_KIND && event.pubkey === connection.walletPubkey && Array.isArray(event.tags) && event.tags.some((tag) => tag?.[0] === "e" && tag[1] === requestId) && verifyEvent(event);
+  return answers ? event : null;
+}
+function parsedFrame(frame) {
+  try {
+    const parsed = JSON.parse(frame);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parsedUri(uri) {
+  try {
+    const parsed = new URL(uri);
+    if (parsed.protocol !== SCHEME) {
+      throw new Error(parsed.protocol);
+    }
+    return parsed;
+  } catch {
+    throw new WalletRefused("address-unusable", `an nwc uri starts with ${SCHEME}//`);
+  }
+}
+function isSecureRelay(relay) {
+  try {
+    return new URL(relay).protocol === "wss:";
+  } catch {
+    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"];
@@ -517,11 +1112,15 @@ async function firstThatServes(addresses, attempt) {
   const deadline = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
   const refusals = [];
   for (const address of addresses) {
-    if (deadline.aborted) break;
+    if (deadline.aborted) {
+      break;
+    }
     try {
       return { won: await attempt(address, deadline), refusals };
     } catch (refusal) {
-      if (!(refusal instanceof WalletRefused)) throw refusal;
+      if (!(refusal instanceof WalletRefused)) {
+        throw refusal;
+      }
       console.warn(`wallet ${address} refused, ${refusal.reason}: ${refusal.message}`);
       refusals.push({ address, reason: refusal.reason });
     }
@@ -533,10 +1132,7 @@ async function probe(address, amountMsat, deadline) {
   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
-  );
+  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`);
   }
@@ -551,7 +1147,9 @@ async function probe(address, amountMsat, deadline) {
 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.pr) {
+    throw new WalletRefused("unreachable", `${address} returned no invoice`);
+  }
   if (!invoice.verify || !publicHttps(invoice.verify)) {
     throw new WalletRefused(
       "cannot-prove-delivery",
@@ -599,7 +1197,9 @@ async function checkSettled(verifyUrl, paymentHash) {
     pace: paceAskedFor(answer.headers),
     ceiling: ceilingAskedFor(answer.headers)
   };
-  if (!answer.said.settled || !answer.said.preimage) return { preimage: null, ...asked };
+  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}`);
   }
@@ -607,15 +1207,21 @@ async function checkSettled(verifyUrl, paymentHash) {
 }
 function paceAskedFor(headers) {
   const asked = /max-age\s*=\s*(\d+)/i.exec(headers.get("cache-control") ?? "");
-  if (!asked) return null;
+  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;
+  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;
+  if (perWindow === 0 || window === 0) {
+    return null;
+  }
   return Math.min(Math.max(perWindow / window, MIN_PER_SECOND), MAX_PER_SECOND);
 }
 function cannotReleaseAPreimage(host) {
@@ -635,95 +1241,53 @@ function splitAddress(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/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 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;
+function isNothingButAHost(domain) {
   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);
+    const parsed = new URL(`https://${domain}/`);
+    return parsed.host === domain.toLowerCase() && parsed.pathname === "/" && parsed.search === "" && parsed.hash === "";
   } catch {
-    return null;
+    return false;
   }
 }
-async function keyFor(secret) {
-  if (secret.length < MIN_SECRET_CHARS) {
-    throw new Error(`the sealing secret needs ${MIN_SECRET_CHARS} characters of randomness`);
+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}`);
   }
-  const material = await crypto.subtle.importKey(
+  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",
-    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 },
+    asBuffer(raw),
+    { name: "HMAC", hash: "SHA-256" },
     false,
-    ["encrypt", "decrypt"]
+    ["sign"]
   );
+  const message = typeof payload === "string" ? new TextEncoder().encode(payload) : payload;
+  return bytesToHex(new Uint8Array(await crypto.subtle.sign("HMAC", key, asBuffer(message))));
 }
-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;
+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
@@ -756,8 +1320,124 @@ var NoWalletAvailableError = class extends ProblemError {
   }
 };
 
+// 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/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) {
+  return async (order) => {
+    const invoice = await nwcInvoice(
+      config.connection,
+      await config.amountMsat(order),
+      config.description?.(order) ?? order.reference
+    );
+    const watched = await config.gateway.watchPayment({
+      paymentHash: invoice.paymentHash,
+      verifyUrl: await nwcVerifyUrl(
+        config.verifyThrough.endpoint,
+        invoice.paymentHash,
+        config.verifyThrough.secret
+      ),
+      expiresAt: invoice.expiresAt,
+      trigger: config.trigger,
+      replay: config.replay,
+      sealed: await config.sealed?.(order),
+      webhookUrl: config.webhookUrl
+    });
+    return {
+      id: watched.id,
+      rail: config.name ?? LIGHTNING,
+      scan: invoice.bolt11,
+      qr: encodeForQr(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_BYTES = 16;
+var NONCE_BYTES2 = 16;
 function lnurlPayEndpoint(config) {
   return async (request) => {
     const url = new URL(request.url);
@@ -769,6 +1449,18 @@ function lnurlPayEndpoint(config) {
     }
   };
 }
+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({
@@ -794,7 +1486,9 @@ async function mint(config, url, address) {
   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");
+  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`);
@@ -810,7 +1504,7 @@ async function mint(config, url, address) {
 async function mintThroughGateway(config, address, amountMsat, nonce) {
   const payment = await config.gateway.createPayment(
     { lnAddresses: [address], amountMsat },
-    { idempotencyKey: nonce, trigger: config.watchSecret }
+    { idempotencyKey: nonce, trigger: config.watchSecret, replay: config.replay }
   );
   return { bolt11: payment.bolt11, verifyUrl: payment.verifyUrl };
 }
@@ -824,10 +1518,13 @@ async function mintBlind(config, address, amountMsat) {
       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;
+    if (!alreadyWatched(refused)) {
+      throw refused;
+    }
   }
   return { bolt11: resolved2.bolt11, verifyUrl: resolved2.verifyUrl };
 }
@@ -838,121 +1535,46 @@ function sign(secret, address, amountMsat, nonce) {
   return hmacHex(secret, `${address}|${amountMsat}|${nonce}`);
 }
 function randomNonce() {
-  const bytes = crypto.getRandomValues(new Uint8Array(NONCE_BYTES));
+  const bytes = crypto.getRandomValues(new Uint8Array(NONCE_BYTES2));
   let hex = "";
-  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
   return hex;
 }
 function refuse(reason) {
   return Response.json({ status: "ERROR", reason });
 }
-
-// ../core/ed25519.ts
-var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
-
-// src/webhook.ts
-var VERIFY_CHALLENGE = "verify-challenge";
-function nonceOf(text2, type) {
-  try {
-    const said = JSON.parse(text2);
-    if (said["type"] !== type || typeof said["nonce"] !== "string") return null;
-    return said["nonce"];
-  } catch {
-    return null;
-  }
-}
-function answerVerifyChallenge(body) {
-  const nonce = nonceOf(body, VERIFY_CHALLENGE);
-  return nonce === null ? null : JSON.stringify({ nonce });
-}
-async function answerVerifyChallengeRequest(request) {
-  if (request.method !== "POST") return null;
-  const answer = answerVerifyChallenge(await request.clone().text());
-  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
-}
-
-// 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/relay.ts
-var DEFAULT_POLL_EVERY_SECS = 5;
-var WALLET = "w";
-function lightningVerifyEndpoint(config) {
-  const paced = {
-    "cache-control": `max-age=${config.pollEverySecs ?? DEFAULT_POLL_EVERY_SECS}`
-  };
-  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,
-      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
-    };
-  };
+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 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;
-  }
+async function offeredSecret(request) {
+  const body = await request.json().catch(() => null);
+  return typeof body?.secret === "string" ? body.secret : "";
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  askWallet,
   blindLightningRail,
   invoiceFrom,
   lightningVerifyEndpoint,
   lnurlPayEndpoint,
-  relayedVerifyUrl
+  nwcConnection,
+  nwcHoldInvoice,
+  nwcInvoice,
+  nwcPay,
+  nwcRail,
+  nwcSettlement,
+  nwcVerifyEndpoint,
+  nwcVerifyUrl,
+  publicWatchTicketEndpoint,
+  relayedVerifyUrl,
+  watchTicketEndpoint
 });