thunder-bridge 0.8.1 → 0.8.2

package/dist/index.js

@@ -34,10 +34,8 @@ var ProblemError = class extends Error {
     this.detail = problem.detail ?? null;
   }
 };
-var NAMESPACE = "urn:problem-type:thunder-bridge:";
-var NAMESPACE_BEFORE_THE_RENAME = "urn:problem-type:thunder-bridge-direct:";
 function isProblemType(problem, type) {
-  return problem.type === type || problem.type === type.replace(NAMESPACE, NAMESPACE_BEFORE_THE_RENAME);
+  return problem.type === type;
 }
 var NO_WALLET_AVAILABLE = "urn:problem-type:thunder-bridge:no-wallet-available";
 var REQUEST_IN_FLIGHT = "urn:problem-type:thunder-bridge:request-in-flight";
@@ -73,8 +71,8 @@ function hexToBytes(hex) {
   }
   return bytes;
 }
-function isHex(text2) {
-  return /^[0-9a-f]+$/i.test(text2) && text2.length % 2 === 0;
+function isHex(text3) {
+  return /^[0-9a-f]+$/i.test(text3) && text3.length % 2 === 0;
 }
 
 // ../core/sha256.ts
@@ -168,8 +166,8 @@ function sha256(bytes) {
   }
   return asBytes(state);
 }
-function sha256Hex(text2) {
-  return bytesToHex(sha256(new TextEncoder().encode(text2)));
+function sha256Hex(text3) {
+  return bytesToHex(sha256(new TextEncoder().encode(text3)));
 }
 function withPadding(bytes) {
   const padded = new Uint8Array(
@@ -348,10 +346,13 @@ function sameOrigin(one, other) {
     return false;
   }
 }
+function publicAddress(literal) {
+  return literal.includes(":") ? ipv6IsGlobal(literal) : ipv4IsGlobal(literal);
+}
 function hostIsPublic(host) {
-  if (host.startsWith("[")) return ipv6IsGlobal(host.slice(1, -1));
+  if (host.startsWith("[")) return publicAddress(host.slice(1, -1));
   const name = host.replace(/\.$/, "");
-  if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) return ipv4IsGlobal(name);
+  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]);
@@ -616,6 +617,16 @@ var TERMINAL = /* @__PURE__ */ new Set(["paid", "expired"]);
 var RECONNECT_DELAY_MS = 3e3;
 var RECONNECT_CAP_MS = 3e4;
 var UNANSWERED_ATTEMPTS = 5;
+var TRIGGER_MIN_CHARS = 16;
+var STRANGER_PROBE = "is-this-gateway-yours";
+function unguessable(trigger) {
+  if (trigger.length < TRIGGER_MIN_CHARS) {
+    throw new Error(
+      `a trigger secret is the only thing guarding its stream, and nothing rate limits a guess at it, so it has to be at least ${TRIGGER_MIN_CHARS} characters nobody can predict`
+    );
+  }
+  return trigger;
+}
 function backoffMs(firstDelay, attempt) {
   const grown = Math.min(firstDelay * 2 ** (attempt - 1), RECONNECT_CAP_MS);
   return Math.round(grown * (0.5 + Math.random() / 2));
@@ -624,6 +635,7 @@ var ThunderBridge = class {
   baseUrl;
   verify;
   token;
+  strangers = null;
   constructor(baseUrl, options) {
     this.baseUrl = baseUrl.replace(/\/+$/, "");
     this.verify = options?.verify ?? true;
@@ -637,6 +649,21 @@ var ThunderBridge = class {
   get isPrivate() {
     return this.token !== null;
   }
+  /**
+   * Whether the gateway turns away a caller carrying no token, asked by making
+   * one unauthenticated read it would have to refuse. `isPrivate` answers only
+   * whether you configured a token, which is your side of the arrangement and
+   * says nothing about the gateway's, so a made-up token against a public
+   * instance reads as private and is not. Asked once and remembered, because an
+   * instance does not change its mind. Anything other than a refusal counts as
+   * open, so an unreachable gateway fails closed
+   */
+  async refusesStrangers() {
+    this.strangers ??= fetch(`${this.baseUrl}/incoming-payments/${STRANGER_PROBE}`, {
+      headers: { accept: "application/json" }
+    }).then((answer) => answer.status === 401).catch(() => false);
+    return await this.strangers;
+  }
   /**
    * 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
@@ -648,7 +675,10 @@ var ThunderBridge = class {
     const response = await fetch(`${this.baseUrl}/incoming-payments`, {
       method: "POST",
       headers,
-      body: createRequestBody(params, options?.trigger ? sha256Hex(options.trigger) : null)
+      body: createRequestBody(
+        params,
+        options?.trigger ? sha256Hex(unguessable(options.trigger)) : null
+      )
     });
     if (!response.ok) throw await problemFrom(response);
     const payment = await paymentFrom(response);
@@ -890,7 +920,10 @@ var ThunderBridge = class {
     const response = await fetch(`${this.baseUrl}/watched-payments`, {
       method: "POST",
       headers: this.sending(),
-      body: watchRequestBody(params, params.trigger ? sha256Hex(params.trigger) : null)
+      body: watchRequestBody(
+        params,
+        params.trigger ? sha256Hex(unguessable(params.trigger)) : null
+      )
     });
     if (!response.ok) throw await problemFrom(response);
     const watched = triggerEventFromWire(await response.json().catch(() => null));
@@ -909,7 +942,7 @@ var ThunderBridge = class {
    */
   followTrigger(secret, options) {
     const base = this.baseUrl.replace(/^http/, "ws");
-    const direct = `${base}/ws/triggers/${encodeURIComponent(secret)}`;
+    const direct = `${base}/ws/triggers/${encodeURIComponent(unguessable(secret))}`;
     const firstDelay = options.reconnectDelayMs ?? RECONNECT_DELAY_MS;
     let socket = null;
     let retry;
@@ -1081,10 +1114,10 @@ function toBase64Url(bytes) {
   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;
+function fromBase64Url(text3) {
+  if (text3.length === 0 || !/^[A-Za-z0-9_-]+$/.test(text3)) return null;
   try {
-    const binary = atob(text2.replace(/-/g, "+").replace(/_/g, "/"));
+    const binary = atob(text3.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;
@@ -1116,6 +1149,87 @@ function asBuffer(bytes) {
   return bytes instanceof Uint8Array && bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
 }
 
+// ../core/outbound.ts
+import { lookup } from "dns/promises";
+import { setTimeout as sleep } from "timers/promises";
+var HTTP_TIMEOUT_MS2 = 15e3;
+var LOOKUP_TIMEOUT_MS = 5e3;
+var HOPS_FOLLOWED = 2;
+var REDIRECTS = [301, 302, 303, 307, 308];
+var KEEPS_THE_METHOD = [307, 308];
+var CREDENTIALS = ["authorization", "cookie", "proxy-authorization"];
+var BODY_LIMIT_BYTES = 262144;
+async function ask(url, sent = {}) {
+  const capped = AbortSignal.timeout(HTTP_TIMEOUT_MS2);
+  const signal = sent.deadline ? AbortSignal.any([sent.deadline, capped]) : capped;
+  let target = url;
+  let carried = sent;
+  for (let hop = 0; hop <= HOPS_FOLLOWED; hop += 1) {
+    await refuseUnlessPublic(target);
+    const response = await fetch(target, {
+      method: carried.method ?? "GET",
+      headers: carried.headers ?? {},
+      body: carried.body,
+      redirect: "manual",
+      signal
+    });
+    if (!REDIRECTS.includes(response.status)) return await answerOf(response);
+    const location = response.headers.get("location");
+    if (location === null) {
+      throw new Error(`${target} answered ${response.status} without saying where to`);
+    }
+    await response.body?.cancel();
+    const next = new URL(location, target).toString();
+    carried = KEEPS_THE_METHOD.includes(response.status) ? carried : withoutBody(carried);
+    carried = sameOrigin(target, next) ? carried : withoutCredentials(carried);
+    target = next;
+  }
+  throw new Error(`${url} redirected more than ${HOPS_FOLLOWED} times`);
+}
+async function resolvesNothingPrivate(url) {
+  const host = new URL(url).hostname.replace(/^\[|]$/g, "");
+  const found = await Promise.race([
+    lookup(host, { all: true, verbatim: true }).catch(() => []),
+    sleep(LOOKUP_TIMEOUT_MS, null, { ref: false })
+  ]);
+  return found !== null && found.every((one) => publicAddress(one.address));
+}
+async function refuseUnlessPublic(url) {
+  if (!publicHttps(url)) throw new Error(`${url} is not a public https URL`);
+  if (!await resolvesNothingPrivate(url)) throw new Error(`${url} resolves to an address we do not reach`);
+}
+async function answerOf(response) {
+  const { status, ok } = response;
+  const reader = response.body?.getReader();
+  if (!reader) return { status, ok, body: "", truncated: false };
+  const read = [];
+  let bytes = 0;
+  while (bytes <= BODY_LIMIT_BYTES) {
+    const { done, value } = await reader.read();
+    if (done) return { status, ok, body: text2(read), truncated: false };
+    read.push(value);
+    bytes += value.length;
+  }
+  await reader.cancel();
+  return { status, ok, body: text2(read), truncated: true };
+}
+function withoutBody(sent) {
+  const headers = { ...sent.headers };
+  delete headers["content-type"];
+  return { ...sent, method: "GET", headers, body: void 0 };
+}
+function withoutCredentials(sent) {
+  const headers = { ...sent.headers };
+  for (const named of CREDENTIALS) delete headers[named];
+  return { ...sent, headers };
+}
+function text2(chunks) {
+  const decoder = new TextDecoder();
+  let decoded = "";
+  for (const chunk of chunks) decoded += decoder.decode(chunk, { stream: true });
+  return decoded + decoder.decode();
+}
+
 // ../core/refusal.ts
 var WalletRefused = class extends Error {
   reason;
@@ -1134,7 +1248,6 @@ var NoWalletAvailable = class extends Error {
 
 // ../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];
@@ -1299,14 +1412,12 @@ function splitAddress(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();
+  const answer = await ask(url, { headers: { accept: "application/json" }, deadline });
+  if (!answer.ok) throw new Error(`${url} answered ${answer.status}`);
+  if (answer.truncated) {
+    throw new Error(`${url} answered with more than the ${BODY_LIMIT_BYTES} bytes we read`);
+  }
+  return JSON.parse(answer.body);
 }
 
 // src/trigger.ts
@@ -1450,6 +1561,7 @@ var FORBIDDEN_IN_SPD = "*";
 async function bankTransfer(params) {
   const currency = params.currency ?? DEFAULT_CURRENCY;
   refuseUnusable(params, currency);
+  await refuseAnOpenGateway(params);
   const spd = shortPaymentDescriptor(params, currency);
   const subject = subjectOf(params.reference, params.amountMinor, currency);
   const polling = new URL(params.verifyUrl);
@@ -1516,12 +1628,14 @@ function shortPaymentDescriptor(params, currency) {
 function major(amountMinor, currency) {
   return (amountMinor / minorScaleOf(currency)).toFixed(minorUnitsOf(currency));
 }
+async function refuseAnOpenGateway(params) {
+  if (params.allowPublicGateway === true) return;
+  if (await params.gateway.refusesStrangers()) return;
+  throw new Error(
+    "this gateway serves callers with no token, so it is not yours, and its operator would read the amount and the reference off every verify URL. Point at one that answers 401 to a stranger, or say allowPublicGateway"
+  );
+}
 function refuseUnusable(params, currency) {
-  if (!params.gateway.isPrivate && params.allowPublicGateway !== true) {
-    throw new Error(
-      "this gateway has no token, so it is not yours, and its operator would read the amount and the reference off every verify URL. Give it a token or say allowPublicGateway"
-    );
-  }
   if (!IBAN.test(params.iban)) throw new Error(`${params.iban} is not an IBAN`);
   if (!Number.isInteger(params.amountMinor) || params.amountMinor <= 0) {
     throw new Error("amountMinor must be a whole number of minor units above zero");
@@ -1560,6 +1674,7 @@ var WHERE_A_PAYER_WRITES = [
   USER_IDENTIFICATION,
   PAYER_REFERENCE
 ];
+var UTC_OFFSET = /^[+-]\d{4}$/;
 function fioStatement(config) {
   const named = typeof config.token === "string" ? [config.token] : config.token;
   if (named.length === 0) throw new Error("fioStatement needs at least one token to read with");
@@ -1612,9 +1727,21 @@ function asCredit(transaction) {
     amountMinor: Math.round(numberIn(transaction[AMOUNT]) * MINOR_UNITS),
     currency: textIn(transaction[CURRENCY]),
     reference: WHERE_A_PAYER_WRITES.map((column) => textIn(transaction[column])).filter((written) => written.length > 0).join(" "),
-    bookedAt: Math.floor(numberIn(transaction[BOOKED_AT]) / MILLIS)
+    bookedAt: bookedAtIn(transaction[BOOKED_AT])
   };
 }
+function bookedAtIn(cell) {
+  const value = cell?.value;
+  if (typeof value === "number") return Math.floor(value / MILLIS);
+  const at = Date.parse(asIso8601(textIn(cell)));
+  return Number.isFinite(at) ? Math.floor(at / MILLIS) : 0;
+}
+function asIso8601(booked) {
+  const day = booked.slice(0, DATE_CHARS);
+  const zone = booked.slice(DATE_CHARS);
+  if (!UTC_OFFSET.test(zone)) return `${day}T00:00:00Z`;
+  return `${day}T00:00:00${zone.slice(0, 3)}:${zone.slice(3)}`;
+}
 function numberIn(cell) {
   const value = Number(cell?.value ?? Number.NaN);
   return Number.isFinite(value) ? value : 0;
@@ -1627,6 +1754,149 @@ function asDate(unix) {
   return new Date(unix * MILLIS).toISOString().slice(0, DATE_CHARS);
 }
 
+// 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 spdToSvg(spd, options) {
+  return svgOf(spd, options);
+}
+function spdToDataUrl(spd, options) {
+  return asDataUrl(spdToSvg(spd, options));
+}
+function qrToSvg(payload, options) {
+  return svgOf(payload, options);
+}
+function qrToDataUrl(payload, options) {
+  return asDataUrl(qrToSvg(payload, 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/rail.ts
+var BANK = "bank";
+var LIGHTNING = "lightning";
+function bankRail(config) {
+  return async (order) => {
+    const expiresAt = config.expiresAt(order);
+    const transfer = await bankTransfer({
+      gateway: config.gateway,
+      secret: config.secret,
+      iban: config.iban,
+      verifyUrl: config.verifyUrl,
+      reference: order.reference,
+      amountMinor: order.amountMinor,
+      currency: order.currency,
+      expiresAt,
+      trigger: config.trigger,
+      sealed: await config.sealed?.(order),
+      variableSymbol: config.variableSymbol?.(order),
+      allowPublicGateway: config.allowPublicGateway
+    });
+    return {
+      id: transfer.id,
+      rail: config.name ?? BANK,
+      scan: transfer.spd,
+      qr: transfer.spd,
+      expiresAt
+    };
+  };
+}
+function lightningRail(config) {
+  return async (order) => {
+    const payment = await config.gateway.createPayment(
+      {
+        lnAddresses: config.lnAddresses,
+        amountMsat: await config.amountMsat(order),
+        webhookUrl: config.webhookUrl,
+        webhookSecret: config.webhookSecret
+      },
+      { idempotencyKey: config.idempotencyKey?.(order), trigger: config.trigger }
+    );
+    return {
+      id: payment.id,
+      rail: config.name ?? LIGHTNING,
+      scan: payment.bolt11,
+      qr: encodeForQr(payment.bolt11),
+      expiresAt: payment.expiresAt
+    };
+  };
+}
+function blindLightningRail(config) {
+  return async (order) => {
+    const resolved = await invoiceFrom(config.lnAddresses, await config.amountMsat(order));
+    const watched = await config.gateway.watchPayment({
+      paymentHash: resolved.paymentHash,
+      verifyUrl: resolved.verifyUrl,
+      expiresAt: resolved.expiresAt,
+      trigger: config.trigger,
+      sealed: await config.sealed?.(order)
+    });
+    return {
+      id: watched.id,
+      rail: config.name ?? LIGHTNING,
+      scan: resolved.bolt11,
+      qr: encodeForQr(resolved.bolt11),
+      expiresAt: resolved.expiresAt
+    };
+  };
+}
+async function invoiceFrom(lnAddresses, amountMsat) {
+  try {
+    return await resolve(lnAddresses, amountMsat);
+  } catch (refused) {
+    if (refused instanceof NoWalletAvailable) {
+      throw new NoWalletAvailableError({ title: refused.message }, refused.wallets);
+    }
+    throw refused;
+  }
+}
+
 // src/price.ts
 var MSAT_PER_BTC2 = 1e11;
 var BASIS_POINTS = 1e4;
@@ -1749,64 +2019,6 @@ function refusals2(answers) {
   ).join("; ");
 }
 
-// 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 spdToSvg(spd, options) {
-  return svgOf(spd, options);
-}
-function spdToDataUrl(spd, options) {
-  return asDataUrl(spdToSvg(spd, 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";
@@ -1819,9 +2031,9 @@ async function verifyWebhookSignature(body, signature, secret, timestamp, option
 }
 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);
+  const text3 = typeof body === "string" ? body : new TextDecoder().decode(body);
   try {
-    return paymentFromWire(JSON.parse(text2));
+    return paymentFromWire(JSON.parse(text3));
   } catch {
     return null;
   }
@@ -1860,9 +2072,11 @@ export {
   REQUEST_IN_FLIGHT,
   ThunderBridge,
   UnverifiedRecipientError,
+  bankRail,
   bankTransfer,
   bankVerifyEndpoint,
   bitstamp,
+  blindLightningRail,
   coinbase,
   coinmate,
   decodeInvoice,
@@ -1872,6 +2086,7 @@ export {
   isProblemType,
   isProvablyPaid,
   kraken,
+  lightningRail,
   lnurlPayEndpoint,
   lnurlToDataUrl,
   lnurlToSvg,
@@ -1884,6 +2099,8 @@ export {
   preimageMatchesHash,
   proveOrigin,
   proveSettlement,
+  qrToDataUrl,
+  qrToSvg,
   seal,
   spdToDataUrl,
   spdToSvg,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thunder-bridge",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Trustless JavaScript client for the Thunder Bridge Lightning payment gateway. Proves the invoice came from your own wallet before the payer sees it.",
   "author": "i-am-fatik",
   "homepage": "https://agora.gripe/en/tools/thunder-bridge",
@@ -39,10 +39,10 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.16",
-    "@types/node": "^25.5.0",
+    "@types/node": "^24.13.3",
     "tsup": "^8.0.0",
     "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
+    "vitest": "^4.1.10"
   },
   "keywords": [
     "lightning",