thunder-bridge 1.5.0 → 2.2.0

package/dist/nwc.cjs

@@ -25,9 +25,9 @@ __export(nwc_exports, {
   nwcHoldInvoice: () => nwcHoldInvoice,
   nwcInvoice: () => nwcInvoice,
   nwcPay: () => nwcPay,
-  nwcRail: () => nwcRail,
+  nwcRail: () => nwcRail2,
   nwcSettlement: () => nwcSettlement,
-  nwcVerifyEndpoint: () => nwcVerifyEndpoint,
+  nwcVerifyEndpoint: () => nwcVerifyEndpoint2,
   nwcVerifyUrl: () => nwcVerifyUrl
 });
 module.exports = __toCommonJS(nwc_exports);
@@ -206,6 +206,7 @@ function rotate(value, by) {
 
 // ../core/bolt11.ts
 var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
 var CHECKSUM_WORDS = 6;
 var TIMESTAMP_WORDS = 7;
 var SIGNATURE_WORDS = 104;
@@ -223,18 +224,27 @@ var HRP_MULTIPLIER_MSAT = {
   n: MSAT_PER_BTC / 1e9,
   p: MSAT_PER_BTC / 1e12
 };
-var HRP_AMOUNT = /^ln[a-z]+?(\d+)([munp]?)$/;
+var HRP = /^ln(?:bcrt|bc|tbs|tb|sb)(?:(\d+)([munp]?))?$/;
 function decodeInvoice(bolt11) {
   const parts = splitBech32(bolt11);
   if (parts === null) {
-    return { paymentHash: null, descriptionHash: null, amountMsat: null, expiresAt: null };
+    return {
+      paymentHash: null,
+      descriptionHash: null,
+      amountMsat: null,
+      issuedAt: null,
+      expiresAt: null
+    };
   }
   const tagged = taggedFields(parts.words);
+  const issuedAt = issuedAtOf(parts.words);
+  const expiry = tagged.get(EXPIRY_TAG);
   return {
     paymentHash: hexTag(tagged, PAYMENT_HASH_TAG, PAYMENT_HASH_WORDS),
     descriptionHash: hexTag(tagged, DESCRIPTION_HASH_TAG, DESCRIPTION_HASH_WORDS),
     amountMsat: amountFromHrp(parts.hrp),
-    expiresAt: expiryOf(parts.words, tagged)
+    issuedAt,
+    expiresAt: issuedAt === null ? null : issuedAt + (expiry ? readNumber(expiry) : DEFAULT_EXPIRY_SECS)
   };
 }
 function preimageMatchesHash(preimage, paymentHash) {
@@ -245,7 +255,7 @@ function preimageMatchesHash(preimage, paymentHash) {
 }
 function splitBech32(bolt11) {
   const lower = bolt11.toLowerCase();
-  if (isBolt12Encoding(lower)) {
+  if (isBolt12Encoding(lower) || bolt11 !== lower && bolt11 !== bolt11.toUpperCase()) {
     return null;
   }
   const separator = lower.lastIndexOf("1");
@@ -264,7 +274,28 @@ function splitBech32(bolt11) {
     }
     words.push(value);
   }
-  return { hrp: lower.slice(0, separator), words: words.slice(0, -CHECKSUM_WORDS) };
+  const hrp = lower.slice(0, separator);
+  if (!HRP.test(hrp) || bech32Polymod([...expandedHrp(hrp), ...words]) !== 1) {
+    return null;
+  }
+  return { hrp, words: words.slice(0, -CHECKSUM_WORDS) };
+}
+function expandedHrp(hrp) {
+  const codes = [...hrp].map((char) => char.charCodeAt(0));
+  return [...codes.map((code) => code >> 5), 0, ...codes.map((code) => code & 31)];
+}
+function bech32Polymod(values) {
+  let checksum = 1;
+  for (const value of values) {
+    const top = checksum >> 25;
+    checksum = (checksum & 33554431) << 5 ^ value;
+    for (let bit = 0; bit < 5; bit++) {
+      if (top >> bit & 1) {
+        checksum ^= BECH32_GENERATOR[bit];
+      }
+    }
+  }
+  return checksum;
 }
 function isBolt12Encoding(lower) {
   return lower.startsWith("lno") || lower.startsWith("lni") || lower.startsWith("lnr");
@@ -294,19 +325,17 @@ function hexTag(fields, tag, expectedWords) {
   }
   return bytesToHex(wordsToBytes(words));
 }
-function expiryOf(words, fields) {
+function issuedAtOf(words) {
   if (words.length < TIMESTAMP_WORDS + SIGNATURE_WORDS) {
     return null;
   }
-  const expiry = fields.get(EXPIRY_TAG);
-  return readNumber(words.slice(0, TIMESTAMP_WORDS)) + (expiry ? readNumber(expiry) : DEFAULT_EXPIRY_SECS);
+  return readNumber(words.slice(0, TIMESTAMP_WORDS));
 }
 function amountFromHrp(hrp) {
-  const match = HRP_AMOUNT.exec(hrp);
-  if (match === null) {
+  const [, digits, multiplier] = HRP.exec(hrp) ?? [];
+  if (digits === void 0 || multiplier === "p" && !digits.endsWith("0")) {
     return null;
   }
-  const [, digits, multiplier] = match;
   return multiplier ? Number(digits) * HRP_MULTIPLIER_MSAT[multiplier] : Number(digits) * MSAT_PER_BTC;
 }
 function readNumber(words) {
@@ -336,49 +365,138 @@ var WalletRefused = class extends Error {
   }
 };
 
+// ../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 asBuffer(bytes) {
+  return bytes instanceof Uint8Array && bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
+}
+
 // ../core/sealed.ts
-var VERSION = "v1";
+var VERSION = "v2";
+var UNPADDED_VERSION = "v1";
+var PURPOSE_VERSION = "v3";
 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}`);
+var SIZE_CLASSES = [256, 1024, MAX_PLAIN_BYTES];
+var END_OF_TEXT = 128;
+var INFO = "thunder-bridge/sealed";
+async function seal(secret, plaintext, paymentHash) {
+  return await sealUnder(
+    await keyFor(secret, INFO),
+    plaintext,
+    crypto.getRandomValues(new Uint8Array(IV_BYTES)),
+    VERSION,
+    boundTo(paymentHash)
+  );
+}
+async function sealFor(purpose, secret, plaintext, { stable = false } = {}) {
+  return await sealUnder(
+    await keyFor(secret, `${INFO}/${purpose}`),
+    plaintext,
+    stable ? await nonceOf(secret, plaintext) : crypto.getRandomValues(new Uint8Array(IV_BYTES)),
+    PURPOSE_VERSION,
+    new TextEncoder().encode(PURPOSE_VERSION)
+  );
+}
+async function unsealFor(purpose, secret, sealed) {
+  if (!sealed.startsWith(`${PURPOSE_VERSION}.`)) {
+    return await unseal(secret, sealed);
   }
-  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));
+  return await opened(
+    await keyFor(secret, `${INFO}/${purpose}`),
+    sealed.slice(PURPOSE_VERSION.length + 1),
+    new TextEncoder().encode(PURPOSE_VERSION)
+  );
+}
+async function nonceOf(secret, plaintext) {
+  const derived = await hmacHex(secret, `sealed-nonce|${plaintext}`);
+  const nonce = new Uint8Array(IV_BYTES);
+  for (let at = 0; at < IV_BYTES; at++) {
+    nonce[at] = Number.parseInt(derived.slice(at * 2, at * 2 + 2), 16);
+  }
+  return nonce;
+}
+async function sealUnder(key, plaintext, iv, version, additionalData) {
+  const body = padToClass(plaintext);
+  const cipher = new Uint8Array(
+    await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData }, key, body)
+  );
   const joined2 = new Uint8Array(iv.length + cipher.length);
   joined2.set(iv);
   joined2.set(cipher, iv.length);
-  return `${VERSION}.${toBase64Url(joined2)}`;
+  return `${version}.${toBase64Url(joined2)}`;
 }
-async function unseal(secret, sealed) {
-  const key = await keyFor(secret);
-  if (!sealed.startsWith(`${VERSION}.`)) {
+async function unseal(secret, sealed, paymentHash) {
+  const key = await keyFor(secret, INFO);
+  const padded2 = sealed.startsWith(`${VERSION}.`);
+  const unbound = !padded2 && sealed.startsWith(`${UNPADDED_VERSION}.`);
+  if (!padded2 && (!unbound || paymentHash !== void 0)) {
     return null;
   }
-  const joined2 = fromBase64Url(sealed.slice(VERSION.length + 1));
+  return await opened(
+    key,
+    sealed.slice(VERSION.length + 1),
+    padded2 ? boundTo(paymentHash) : void 0
+  );
+}
+async function opened(key, encoded, additionalData) {
+  const joined2 = fromBase64Url(encoded);
   if (joined2 === null || joined2.length <= IV_BYTES) {
     return null;
   }
   try {
-    const body = await crypto.subtle.decrypt(
-      { name: "AES-GCM", iv: joined2.slice(0, IV_BYTES) },
-      key,
-      joined2.slice(IV_BYTES)
+    const body = new Uint8Array(
+      await crypto.subtle.decrypt(
+        { name: "AES-GCM", iv: joined2.slice(0, IV_BYTES), additionalData },
+        key,
+        joined2.slice(IV_BYTES)
+      )
     );
-    return new TextDecoder().decode(body);
+    const text = additionalData === void 0 ? body : unpad(body);
+    return text === null ? null : new TextDecoder().decode(text);
   } catch {
     return null;
   }
 }
-async function keyFor(secret) {
+function refuseAWeakSecret(secret) {
   if (secret.length < MIN_SECRET_CHARS) {
     throw new Error(`the sealing secret needs ${MIN_SECRET_CHARS} characters of randomness`);
   }
+}
+function boundTo(paymentHash) {
+  return new TextEncoder().encode(
+    paymentHash === void 0 ? VERSION : `${VERSION}|${paymentHash.toLowerCase()}`
+  );
+}
+function padToClass(plaintext) {
+  const text = new TextEncoder().encode(plaintext);
+  const size = SIZE_CLASSES.find((limit) => text.length <= limit);
+  if (size === void 0) {
+    throw new Error(`sealed takes at most ${MAX_PLAIN_BYTES} bytes, this was ${text.length}`);
+  }
+  const body = new Uint8Array(size + 1);
+  body.set(text);
+  body[text.length] = END_OF_TEXT;
+  return body;
+}
+function unpad(body) {
+  const end = body.lastIndexOf(END_OF_TEXT);
+  return end === -1 ? null : body.subarray(0, end);
+}
+async function keyFor(secret, info) {
+  refuseAWeakSecret(secret);
   const material = await crypto.subtle.importKey(
     "raw",
     new TextEncoder().encode(secret),
@@ -387,7 +505,12 @@ async function keyFor(secret) {
     ["deriveKey"]
   );
   return crypto.subtle.deriveKey(
-    { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: INFO },
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt: new Uint8Array(0),
+      info: new TextEncoder().encode(info)
+    },
     material,
     { name: "AES-GCM", length: 256 },
     false,
@@ -421,7 +544,7 @@ function fromBase64Url(text) {
 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_hmac2 = 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;
@@ -479,7 +602,7 @@ function encryptNip44(conversationKey, plaintext) {
 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));
+  const mac = (0, import_hmac2.hmac)(import_sha2.sha256, keys.hmacKey, joined(nonce, ciphertext));
   return toBase64(joined(Uint8Array.of(NIP44_VERSION), nonce, ciphertext, mac));
 }
 function decryptNip44(conversationKey, payload) {
@@ -497,7 +620,7 @@ function decryptNip44(conversationKey, payload) {
   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)) {
+  if (!sameBytes((0, import_hmac2.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));
@@ -796,6 +919,15 @@ async function amountNow(amount) {
 
 // ../core/ed25519.ts
 var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
+var SMALL_ORDER = [
+  "00".repeat(32),
+  `01${"00".repeat(31)}`,
+  "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05",
+  "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a",
+  `ec${"ff".repeat(30)}7f`,
+  `ed${"ff".repeat(30)}7f`,
+  `ee${"ff".repeat(30)}7f`
+];
 
 // src/webhook.ts
 var VERIFY_CHALLENGE = "verify-challenge";
@@ -803,7 +935,7 @@ async function answerVerifyChallenge(request) {
   if (request.method !== "POST") {
     return null;
   }
-  const nonce = nonceOf(await request.clone().text(), VERIFY_CHALLENGE);
+  const nonce = nonceOf2(await request.clone().text(), VERIFY_CHALLENGE);
   return nonce === null ? null : answered(nonce);
 }
 function answered(nonce) {
@@ -811,7 +943,7 @@ function answered(nonce) {
     headers: { "content-type": "application/json" }
   });
 }
-function nonceOf(text, type) {
+function nonceOf2(text, type) {
   try {
     const said = JSON.parse(text);
     if (said["type"] !== type || typeof said["nonce"] !== "string") {
@@ -957,7 +1089,7 @@ function nwcVerifyEndpoint(config) {
     if (sealed === null) {
       return Response.json({ settled: false }, { status: 400 });
     }
-    const paymentHash = await unseal(config.secret, sealed);
+    const paymentHash = await unsealFor("nwc-verify", config.secret, sealed);
     if (paymentHash === null) {
       return Response.json({ settled: false }, { status: 403 });
     }
@@ -972,7 +1104,7 @@ function nwcVerifyEndpoint(config) {
 }
 async function nwcVerifyUrl(endpoint, paymentHash, secret) {
   const sealed = new URL(endpoint);
-  sealed.searchParams.set(HASH, await seal(secret, paymentHash));
+  sealed.searchParams.set(HASH, await sealFor("nwc-verify", secret, paymentHash));
   return sealed.toString();
 }
 async function askWallet(connection, method, params, timeoutMs = DEFAULT_ASK_TIMEOUT_MS) {
@@ -1126,11 +1258,16 @@ function nwcRail(gateway, config) {
       expiresAt: invoice.expiresAt,
       trigger: config.trigger,
       replay: config.replay,
-      sealed: await config.sealed?.(order),
+      sealed: config.sealed ? await seal(
+        config.sealed.secret,
+        JSON.stringify(config.sealed.data(order)),
+        invoice.paymentHash
+      ) : void 0,
       webhookUrl: config.webhookUrl
     });
     return {
       id: watched.id,
+      paymentHash: invoice.paymentHash,
       rail: config.name ?? "lightning",
       scan: invoice.bolt11,
       qr: toLightningUri(invoice.bolt11),
@@ -1138,6 +1275,10 @@ function nwcRail(gateway, config) {
     };
   };
 }
+
+// src/entry/nwc.ts
+var nwcRail2 = nwcRail;
+var nwcVerifyEndpoint2 = nwcVerifyEndpoint;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   askWallet,

package/dist/nwc.d.cts

@@ -1,120 +1,19 @@
-import { A as Amount, T as Ticker } from './types-BNPmVnA7.cjs';
-import { R as RailConfig, O as Order, T as ThunderBridge, a as Rail } from './client-CzGZcByI.cjs';
+import { n as nwcRail$1, f as nwcVerifyEndpoint$1 } from './bank-Bg6RjuO-.cjs';
+export { N as NwcConnection, g as NwcInvoice, h as NwcRailConfig, i as NwcVerifyConfig, j as askWallet, k as nwcConnection, l as nwcHoldInvoice, m as nwcInvoice, o as nwcPay, p as nwcSettlement, q as nwcVerifyUrl } from './bank-Bg6RjuO-.cjs';
 import './qr-CF-YeXU1.cjs';
-import './bank-B3mHISn1.cjs';
+import './types-DYZ9EkmJ.cjs';
 
-/** A wallet reachable over NIP-47, as its `nostr+walletconnect://` URI describes it */
-interface NwcConnection {
-    /** The wallet service's public key, which is what its answers have to be signed by */
-    walletPubkey: string;
-    /** Where to reach it, tried in order until one answers */
-    relays: string[];
-    /** Our own private key on this connection, and the only thing that authorises it */
-    secret: string;
-}
-/** A minted invoice and everything needed to watch it */
-interface NwcInvoice {
-    bolt11: string;
-    paymentHash: string;
-    expiresAt: number;
-}
-/** The endpoint the gateway polls for an NWC payment, answering off your own wallet */
-interface NwcVerifyConfig {
-    /** The wallet this endpoint speaks for. It never leaves this process */
-    connection: NwcConnection;
-    /** The secret the payment hash was sealed with, and nothing else uses it */
-    secret: string;
-    /** How often the gateway should ask, in seconds, sent as `Cache-Control: max-age`, `5` by default */
-    pollEverySecs?: number;
-    /** How long one `lookup_invoice` may take before the wallet counts as unreachable, `10_000` by default */
-    askTimeoutMs?: number;
-}
 /**
- * Read a `nostr+walletconnect://` URI. Refuses a relay that is not `wss`, for the
- * reason the gateway refuses a verify URL that is not https
- */
-declare function nwcConnection(uri: string): NwcConnection;
-/** Mint an invoice on the connected wallet, decoded so the caller need not trust its word */
-declare function nwcInvoice(connection: NwcConnection, amountMsat: number, description: string, timeoutMs?: number): Promise<NwcInvoice>;
-/**
- * Mint a hold invoice on a hash the wallet does not hold the preimage for, which
- * is what lets an operator be paid only by paying somebody else first. The hash
- * has to come from the recipient's own invoice, and the invoice that comes back
- * is decoded rather than believed
- */
-declare function nwcHoldInvoice(connection: NwcConnection, held: {
-    paymentHash: string;
-    amountMsat: number;
-    description: string;
-    expirySecs: number;
-    minCltvExpiryDelta?: number;
-}, timeoutMs?: number): Promise<NwcInvoice>;
-/**
- * The preimage the wallet released for this hash, null while it has released
- * none. A preimage that does not hash to what was asked for is a lie rather than
- * an answer, so it throws instead of being passed on
- */
-declare function nwcSettlement(connection: NwcConnection, paymentHash: string, timeoutMs?: number): Promise<string | null>;
-/**
- * Pay an invoice and keep the preimage the network handed back. Whoever pays
- * learns it, which is what makes delivery provable to a recipient publishing no
- * LUD-21 of their own. A preimage that does not hash to the invoice's own hash is
- * a lie rather than a receipt, so it throws instead of being passed on
- */
-declare function nwcPay(connection: NwcConnection, bolt11: string, timeoutMs?: number): Promise<string>;
-/**
- * A verify endpoint of your own that asks your wallet over NIP-47, so the gateway
- * polls you and never learns the connection, the relay, or which wallet it is.
- *
- * `nwcVerifyUrl` seals the payment hash into the query with your secret, which is
- * what stops a stranger driving your wallet through this handler. It answers the
- * LUD-21 shape the gateway already speaks, so nothing on that side changes.
+ * The NWC rail as a free function, which is how it was reached before 2.2.0
  *
- * A wallet it cannot reach answers `502` rather than "not settled", because those
- * are different claims and only one of them is true.
- */
-declare function nwcVerifyEndpoint(config: NwcVerifyConfig): (request: Request) => Promise<Response>;
-/**
- * The URL to hand the gateway, with the payment hash sealed inside it. Point it at
- * wherever `nwcVerifyEndpoint` is mounted
- */
-declare function nwcVerifyUrl(endpoint: string, paymentHash: string, secret: string): Promise<string>;
-/**
- * One NIP-47 call, for a method this SDK does not wrap. The wallet's own info
- * event lists what it will answer, and anything it refuses comes back as a
- * `WalletRefused` whose `reason` says which kind of refusal it was
+ * @deprecated Use `gateway.rails.nwc(config)`, the same rail beside every other one
  */
-declare function askWallet(connection: NwcConnection, method: string, params: Record<string, unknown>, timeoutMs?: number): Promise<Record<string, unknown>>;
-/** A Lightning rail minting on a wallet of your own over NIP-47, bound once per shop */
-interface NwcRailConfig extends RailConfig {
-    /** The wallet that mints, which never leaves this process */
-    connection: NwcConnection;
-    /**
-     * What to charge for one order, the order's own price converted at `rate` by
-     * default. Give it a function and the price is whatever you say
-     */
-    amount?: (order: Order) => Amount;
-    /** Where the default conversion gets its rate, the median of four venues by default */
-    rate?: Ticker;
-    /** Where `nwcVerifyEndpoint` is mounted, and the secret the hash is sealed with */
-    verifyThrough: {
-        endpoint: string;
-        secret: string;
-    };
-    /** What the payer's wallet shows, the order's reference by default */
-    description?: (order: Order) => string;
-    /** Sealed before the gateway sees it, the way the blind Lightning rail does */
-    sealed?: (order: Order) => string | Promise<string>;
-}
+declare const nwcRail: typeof nwcRail$1;
 /**
- * Sell for Lightning against a wallet of your own over NIP-47, for a wallet that
- * has no LUD-21 address to be watched at. Your node mints the invoice and releases
- * the preimage, so the proof comes from one hop nearer than any hosted address can
- * manage, and the gateway sees a hash and a URL of yours.
+ * The NWC verify endpoint as a free function, which is how it was reached before 2.2.0
  *
- * This rail lives here rather than on `gateway.rails` because NIP-47 needs the
- * nostr crypto in this module, and a browser showing a QR should not download it
+ * @deprecated Use `gateway.serve.nwcVerify(config)`, beside every other verify endpoint
  */
-declare function nwcRail(gateway: ThunderBridge, config: NwcRailConfig): Rail;
+declare const nwcVerifyEndpoint: typeof nwcVerifyEndpoint$1;
 
-export { type NwcConnection, type NwcInvoice, type NwcRailConfig, type NwcVerifyConfig, askWallet, nwcConnection, nwcHoldInvoice, nwcInvoice, nwcPay, nwcRail, nwcSettlement, nwcVerifyEndpoint, nwcVerifyUrl };
+export { nwcRail, nwcVerifyEndpoint };

package/dist/nwc.d.ts

@@ -1,120 +1,19 @@
-import { A as Amount, T as Ticker } from './types-BNPmVnA7.js';
-import { R as RailConfig, O as Order, T as ThunderBridge, a as Rail } from './client-Cc5gtjGV.js';
+import { n as nwcRail$1, f as nwcVerifyEndpoint$1 } from './bank-B5MxT_6u.js';
+export { N as NwcConnection, g as NwcInvoice, h as NwcRailConfig, i as NwcVerifyConfig, j as askWallet, k as nwcConnection, l as nwcHoldInvoice, m as nwcInvoice, o as nwcPay, p as nwcSettlement, q as nwcVerifyUrl } from './bank-B5MxT_6u.js';
 import './qr-CF-YeXU1.js';
-import './bank-B3mHISn1.js';
+import './types-DYZ9EkmJ.js';
 
-/** A wallet reachable over NIP-47, as its `nostr+walletconnect://` URI describes it */
-interface NwcConnection {
-    /** The wallet service's public key, which is what its answers have to be signed by */
-    walletPubkey: string;
-    /** Where to reach it, tried in order until one answers */
-    relays: string[];
-    /** Our own private key on this connection, and the only thing that authorises it */
-    secret: string;
-}
-/** A minted invoice and everything needed to watch it */
-interface NwcInvoice {
-    bolt11: string;
-    paymentHash: string;
-    expiresAt: number;
-}
-/** The endpoint the gateway polls for an NWC payment, answering off your own wallet */
-interface NwcVerifyConfig {
-    /** The wallet this endpoint speaks for. It never leaves this process */
-    connection: NwcConnection;
-    /** The secret the payment hash was sealed with, and nothing else uses it */
-    secret: string;
-    /** How often the gateway should ask, in seconds, sent as `Cache-Control: max-age`, `5` by default */
-    pollEverySecs?: number;
-    /** How long one `lookup_invoice` may take before the wallet counts as unreachable, `10_000` by default */
-    askTimeoutMs?: number;
-}
 /**
- * Read a `nostr+walletconnect://` URI. Refuses a relay that is not `wss`, for the
- * reason the gateway refuses a verify URL that is not https
- */
-declare function nwcConnection(uri: string): NwcConnection;
-/** Mint an invoice on the connected wallet, decoded so the caller need not trust its word */
-declare function nwcInvoice(connection: NwcConnection, amountMsat: number, description: string, timeoutMs?: number): Promise<NwcInvoice>;
-/**
- * Mint a hold invoice on a hash the wallet does not hold the preimage for, which
- * is what lets an operator be paid only by paying somebody else first. The hash
- * has to come from the recipient's own invoice, and the invoice that comes back
- * is decoded rather than believed
- */
-declare function nwcHoldInvoice(connection: NwcConnection, held: {
-    paymentHash: string;
-    amountMsat: number;
-    description: string;
-    expirySecs: number;
-    minCltvExpiryDelta?: number;
-}, timeoutMs?: number): Promise<NwcInvoice>;
-/**
- * The preimage the wallet released for this hash, null while it has released
- * none. A preimage that does not hash to what was asked for is a lie rather than
- * an answer, so it throws instead of being passed on
- */
-declare function nwcSettlement(connection: NwcConnection, paymentHash: string, timeoutMs?: number): Promise<string | null>;
-/**
- * Pay an invoice and keep the preimage the network handed back. Whoever pays
- * learns it, which is what makes delivery provable to a recipient publishing no
- * LUD-21 of their own. A preimage that does not hash to the invoice's own hash is
- * a lie rather than a receipt, so it throws instead of being passed on
- */
-declare function nwcPay(connection: NwcConnection, bolt11: string, timeoutMs?: number): Promise<string>;
-/**
- * A verify endpoint of your own that asks your wallet over NIP-47, so the gateway
- * polls you and never learns the connection, the relay, or which wallet it is.
- *
- * `nwcVerifyUrl` seals the payment hash into the query with your secret, which is
- * what stops a stranger driving your wallet through this handler. It answers the
- * LUD-21 shape the gateway already speaks, so nothing on that side changes.
+ * The NWC rail as a free function, which is how it was reached before 2.2.0
  *
- * A wallet it cannot reach answers `502` rather than "not settled", because those
- * are different claims and only one of them is true.
- */
-declare function nwcVerifyEndpoint(config: NwcVerifyConfig): (request: Request) => Promise<Response>;
-/**
- * The URL to hand the gateway, with the payment hash sealed inside it. Point it at
- * wherever `nwcVerifyEndpoint` is mounted
- */
-declare function nwcVerifyUrl(endpoint: string, paymentHash: string, secret: string): Promise<string>;
-/**
- * One NIP-47 call, for a method this SDK does not wrap. The wallet's own info
- * event lists what it will answer, and anything it refuses comes back as a
- * `WalletRefused` whose `reason` says which kind of refusal it was
+ * @deprecated Use `gateway.rails.nwc(config)`, the same rail beside every other one
  */
-declare function askWallet(connection: NwcConnection, method: string, params: Record<string, unknown>, timeoutMs?: number): Promise<Record<string, unknown>>;
-/** A Lightning rail minting on a wallet of your own over NIP-47, bound once per shop */
-interface NwcRailConfig extends RailConfig {
-    /** The wallet that mints, which never leaves this process */
-    connection: NwcConnection;
-    /**
-     * What to charge for one order, the order's own price converted at `rate` by
-     * default. Give it a function and the price is whatever you say
-     */
-    amount?: (order: Order) => Amount;
-    /** Where the default conversion gets its rate, the median of four venues by default */
-    rate?: Ticker;
-    /** Where `nwcVerifyEndpoint` is mounted, and the secret the hash is sealed with */
-    verifyThrough: {
-        endpoint: string;
-        secret: string;
-    };
-    /** What the payer's wallet shows, the order's reference by default */
-    description?: (order: Order) => string;
-    /** Sealed before the gateway sees it, the way the blind Lightning rail does */
-    sealed?: (order: Order) => string | Promise<string>;
-}
+declare const nwcRail: typeof nwcRail$1;
 /**
- * Sell for Lightning against a wallet of your own over NIP-47, for a wallet that
- * has no LUD-21 address to be watched at. Your node mints the invoice and releases
- * the preimage, so the proof comes from one hop nearer than any hosted address can
- * manage, and the gateway sees a hash and a URL of yours.
+ * The NWC verify endpoint as a free function, which is how it was reached before 2.2.0
  *
- * This rail lives here rather than on `gateway.rails` because NIP-47 needs the
- * nostr crypto in this module, and a browser showing a QR should not download it
+ * @deprecated Use `gateway.serve.nwcVerify(config)`, beside every other verify endpoint
  */
-declare function nwcRail(gateway: ThunderBridge, config: NwcRailConfig): Rail;
+declare const nwcVerifyEndpoint: typeof nwcVerifyEndpoint$1;
 
-export { type NwcConnection, type NwcInvoice, type NwcRailConfig, type NwcVerifyConfig, askWallet, nwcConnection, nwcHoldInvoice, nwcInvoice, nwcPay, nwcRail, nwcSettlement, nwcVerifyEndpoint, nwcVerifyUrl };
+export { nwcRail, nwcVerifyEndpoint };