@arkade-os/lnurl-client 0.0.0-stage → 0.6.0

package/dist/chunk-YKBY6NCA.js

@@ -0,0 +1,1157 @@
+// packages/client/src/errors.ts
+var LnurlError = class extends Error {
+  /** Human-readable failure reason, taken from the wire `reason`/`error` field. */
+  reason;
+  /** HTTP status when the failure came with one; absent for LUD-06 bodies answered at HTTP 200. */
+  httpStatus;
+  /** Machine-readable server code, when the management surface sent one. */
+  code;
+  /** True if and only if `httpStatus === 429`; every other failure is terminal. */
+  retryable;
+  /**
+   * Creates an `LnurlError`.
+   *
+   * @param reason - Human-readable failure reason, also used as the message.
+   * @param opts - Optional `httpStatus` and `code` captured from the response.
+   */
+  constructor(reason, opts) {
+    super(reason);
+    this.name = "LnurlError";
+    this.reason = reason;
+    this.httpStatus = opts?.httpStatus;
+    this.code = opts?.code;
+    this.retryable = opts?.httpStatus === 429;
+  }
+};
+var LnurlTransportError = class extends Error {
+  /**
+   * Creates an `LnurlTransportError`.
+   *
+   * @param message - Short description of which transport step failed.
+   * @param opts - Optional `cause` carrying the original thrown value.
+   */
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "LnurlTransportError";
+  }
+};
+var LnurlTimeoutError = class extends Error {
+  /** The most recent verify snapshot seen before the deadline, when one was seen. */
+  lastSnapshot;
+  /**
+   * Creates an `LnurlTimeoutError`.
+   *
+   * @param message - Short description including the timeout that elapsed.
+   * @param opts - Optional `lastSnapshot` with the latest verify state.
+   */
+  constructor(message, opts) {
+    super(message);
+    this.name = "LnurlTimeoutError";
+    this.lastSnapshot = opts?.lastSnapshot;
+  }
+};
+
+// packages/client/src/http.ts
+async function callFetch(url, init, fetchImpl) {
+  try {
+    return await fetchImpl(url, init);
+  } catch (err) {
+    if (err instanceof LnurlError) throw err;
+    throw new LnurlTransportError("Request failed", { cause: err });
+  }
+}
+async function readBody(response) {
+  try {
+    return await response.json();
+  } catch (err) {
+    if (!response.ok) throw new LnurlError(response.statusText, { httpStatus: response.status });
+    throw new LnurlTransportError("Request failed", { cause: err });
+  }
+}
+function throwForStatus(response, body) {
+  const record = typeof body === "object" && body !== null ? body : void 0;
+  const ludReason = record?.["status"] === "ERROR" && typeof record?.["reason"] === "string" ? record["reason"] : void 0;
+  const apiReason = typeof record?.["error"] === "string" ? record["error"] : void 0;
+  const code = typeof record?.["code"] === "string" ? record["code"] : void 0;
+  const reason = ludReason ?? apiReason;
+  const httpStatus = response.ok ? void 0 : response.status;
+  if (reason !== void 0) throw new LnurlError(reason, { httpStatus, code });
+  if (!response.ok) throw new LnurlError(apiReason ?? response.statusText, { httpStatus: response.status, code });
+}
+async function fetchJson(url, init, fetchImpl) {
+  const response = await callFetch(url, init, fetchImpl);
+  const body = await readBody(response);
+  throwForStatus(response, body);
+  return body;
+}
+function lnurlFetch(url, init, fetchImpl) {
+  return fetchJson(url, init, fetchImpl);
+}
+function apiFetch(url, init, fetchImpl) {
+  return fetchJson(url, init, fetchImpl);
+}
+
+// packages/client/src/encoding.ts
+import { bech32 } from "@scure/base";
+var ADDRESS_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isLnAddress(input) {
+  return ADDRESS_PATTERN.test(input);
+}
+var LNURL_BECH32_LIMIT = 1023;
+function decodeLnurl(input) {
+  const { prefix, words } = bech32.decode(input, LNURL_BECH32_LIMIT);
+  return { prefix, text: new TextDecoder().decode(Uint8Array.from(bech32.fromWords(words))) };
+}
+function isLnUrl(input) {
+  try {
+    const { prefix, text } = decodeLnurl(input);
+    if (prefix !== "lnurl") return false;
+    return text.startsWith("https://") || text.startsWith("http://");
+  } catch {
+    return false;
+  }
+}
+function isValidLnUrl(input) {
+  return isLnAddress(input) || isLnUrl(input);
+}
+function toPayRequestUrl(input) {
+  if (isLnAddress(input)) {
+    const [user, domain] = input.split("@");
+    return { url: `https://${domain}/.well-known/lnurlp/${user.toLowerCase()}`, surface: "address" };
+  }
+  if (isLnUrl(input)) {
+    const url = decodeLnurl(input).text;
+    const surface = url.includes("/.well-known/lnurlp/") ? "address" : "session";
+    return { url, surface };
+  }
+  throw new LnurlError("Not a valid LNURL or lightning address");
+}
+
+// packages/client/src/token-options.ts
+import { base58, createBase58check } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+var CAIP19 = /^([-a-z0-9]{3,8}):([-_a-zA-Z0-9]{1,32})\/([-a-z0-9]{3,8}):([-.%a-zA-Z0-9]{1,128})$/;
+var UNIT_CODE = /^[A-Za-z0-9]{1,16}$/;
+var tronCheck = createBase58check(sha256);
+var decodes = (fn) => {
+  try {
+    return fn();
+  } catch {
+    return false;
+  }
+};
+var NAMESPACES = {
+  eip155: { assetNamespace: "erc20", chain: (r) => /^[1-9][0-9]{0,18}$/.test(r), address: (a) => /^0x[0-9a-fA-F]{40}$/.test(a) },
+  solana: {
+    assetNamespace: "token",
+    chain: () => true,
+    address: (a) => decodes(() => /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(a) && base58.decode(a).length === 32)
+  },
+  tron: {
+    assetNamespace: "trc20",
+    chain: () => true,
+    address: (a) => decodes(() => {
+      if (!/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(a)) return false;
+      const bytes = tronCheck.decode(a);
+      return bytes.length === 21 && bytes[0] === 65;
+    })
+  }
+};
+function isTokenAddress(namespace, address) {
+  return NAMESPACES[namespace]?.address(address) ?? false;
+}
+function parseAsset(id) {
+  const match = typeof id === "string" ? CAIP19.exec(id) : null;
+  if (!match) return void 0;
+  const [, namespace, chainReference, assetNamespace, reference] = match;
+  const ns = NAMESPACES[namespace];
+  if (!ns || ns.assetNamespace !== assetNamespace || !ns.chain(chainReference) || !ns.address(reference)) return void 0;
+  return { id, chainId: `${namespace}:${chainReference}`, namespace, chainReference, assetNamespace, reference };
+}
+function unitsOf(payRequest) {
+  const out = /* @__PURE__ */ new Map();
+  for (const unit of payRequest.units ?? []) {
+    const { code, decimals, name } = unit;
+    if (typeof code !== "string" || !UNIT_CODE.test(code) || !Number.isInteger(decimals) || decimals < 0 || decimals > 36) continue;
+    const key = code.toUpperCase();
+    if (out.has(key)) continue;
+    out.set(key, { code: key, decimals, ...typeof name === "string" && name.length > 0 && name.length <= 64 ? { name } : {} });
+  }
+  return out;
+}
+var msat = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : void 0;
+function tokenOptions(payRequest) {
+  const units = unitsOf(payRequest);
+  const offered = (payRequest.paymentOptions ?? []).filter((o) => typeof o?.id === "string" && o.id && typeof o.type === "string" && o.type);
+  const uses = /* @__PURE__ */ new Map();
+  for (const o of offered) uses.set(o.id, (uses.get(o.id) ?? 0) + 1);
+  return offered.flatMap((o) => {
+    const asset = parseAsset(o.asset);
+    const unit = typeof o.unit === "string" ? units.get(o.unit.toUpperCase()) : void 0;
+    if (uses.get(o.id) > 1 || !asset || asset.namespace !== o.type || !unit) return [];
+    const min = msat(o.minSendable);
+    const max = msat(o.maxSendable);
+    return [{
+      id: o.id,
+      asset,
+      unit,
+      available: o.available !== false,
+      ...typeof o.verifiable === "boolean" ? { verifiable: o.verifiable } : {},
+      ...min !== void 0 ? { minSendable: min } : {},
+      ...max !== void 0 ? { maxSendable: max } : {},
+      ...typeof o.provider === "string" && o.provider ? { provider: o.provider } : {}
+    }];
+  });
+}
+
+// packages/client/src/payer.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { hex as hex2 } from "@scure/base";
+
+// packages/client/src/bolt11.ts
+import { bech32 as bech322, hex } from "@scure/base";
+function paymentHashOf(pr) {
+  try {
+    const { words } = bech322.decode(pr.toLowerCase(), 2e3);
+    const end = words.length - 104;
+    for (let i = 7; i < end; ) {
+      const len = words[i + 1] << 5 | words[i + 2];
+      const dataEnd = i + 3 + len;
+      if (dataEnd > end) return null;
+      if (words[i] === 1 && len === 52) {
+        const bytes = bech322.fromWordsUnsafe(words.slice(i + 3, dataEnd));
+        return bytes ? hex.encode(bytes.slice(0, 32)) : null;
+      }
+      i = dataEnd;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var MULTIPLIER_DIVISOR = { m: 1000n, u: 1000000n, n: 1000000000n, p: 1000000000000n };
+function amountMsatOf(pr) {
+  let prefix;
+  try {
+    ({ prefix } = bech322.decode(pr.toLowerCase(), 2e3));
+  } catch {
+    return void 0;
+  }
+  const match = /^ln[a-z]+(\d+)([munp])?$/.exec(prefix);
+  if (!match) return null;
+  const [, digits, mult] = match;
+  const divisor = mult ? MULTIPLIER_DIVISOR[mult] : 1n;
+  const numerator = BigInt(digits) * 100000000000n;
+  if (numerator % divisor !== 0n) return void 0;
+  const msat2 = numerator / divisor;
+  return msat2 <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(msat2) : void 0;
+}
+
+// packages/client/src/payer.ts
+function preimageOpens(preimage, pr) {
+  const hash = paymentHashOf(pr);
+  if (!hash || !/^[0-9a-f]{64}$/i.test(preimage)) return false;
+  return hex2.encode(sha2562(hex2.decode(preimage.toLowerCase()))) === hash;
+}
+function assertTokenAnswer(token, answer) {
+  if (answer.paymentOption !== token.id) throw new LnurlError(`The callback answered for ${answer.paymentOption}, not ${token.id}`);
+  if (!answer.paymentDestination || !isTokenAddress(token.asset.namespace, answer.paymentDestination)) {
+    throw new LnurlError(`The callback returned no ${token.asset.namespace} address to pay`);
+  }
+  const payment = answer.paymentQuote?.payment;
+  const whole = typeof payment?.amount === "string" && /^[0-9]{1,78}$/.test(payment.amount) && /[1-9]/.test(payment.amount);
+  if (!whole || typeof payment?.unit !== "string" || payment.unit.toUpperCase() !== token.unit.code) {
+    throw new LnurlError(`The callback quoted no whole amount of ${token.unit.code}`);
+  }
+}
+async function resolve(input, fetchImpl) {
+  const source = toPayRequestUrl(input);
+  const body = await lnurlFetch(source.url, void 0, fetchImpl);
+  if (body.tag !== "payRequest") throw new LnurlError(`Expected a payRequest, got "${String(body.tag)}"`);
+  return { ...body, source };
+}
+async function requestInvoice(payRequest, opts, fetchImpl) {
+  const unadvertised = opts.paymentOption !== void 0 && !payRequest.paymentOptions || opts.unit !== void 0 && !payRequest.units;
+  if (payRequest.source.surface === "session" && unadvertised) {
+    throw new LnurlError("paymentOption and unit need a session payRequest that advertises them; this one does not");
+  }
+  const amountMsat = opts.amountSat * 1e3;
+  const selected = opts.paymentOption ? payRequest.paymentOptions?.find((option) => option.id === opts.paymentOption) : void 0;
+  const token = selected?.asset !== void 0 ? tokenOptions(payRequest).find((o) => o.id === selected.id) : void 0;
+  if (selected?.asset !== void 0 && !token) throw new LnurlError(`paymentOption ${selected.id} is not a token this client can pay`);
+  const min = selected?.minSendable ?? payRequest.minSendable;
+  const max = selected?.maxSendable ?? payRequest.maxSendable;
+  if (!Number.isSafeInteger(amountMsat)) {
+    throw new LnurlError("Amount must be a whole number of millisats");
+  }
+  if (amountMsat < min || amountMsat > max) {
+    throw new LnurlError(`Amount must be between ${min} and ${max} millisats`);
+  }
+  if (opts.comment !== void 0 && opts.comment.length > 0) {
+    const allowed = payRequest.commentAllowed ?? 0;
+    if (allowed === 0) throw new LnurlError("This payRequest does not accept comments");
+    if (opts.comment.length > allowed) {
+      throw new LnurlError(`Comment must be at most ${allowed} characters`);
+    }
+  }
+  const params = new URLSearchParams();
+  params.set("amount", String(amountMsat));
+  if (opts.comment) params.set("comment", opts.comment);
+  if (opts.paymentOption !== void 0) params.set("paymentOption", opts.paymentOption);
+  if (opts.unit !== void 0) params.set("unit", opts.unit);
+  const sep = payRequest.callback.includes("?") ? "&" : "?";
+  const body = await lnurlFetch(`${payRequest.callback}${sep}${params.toString()}`, void 0, fetchImpl);
+  if (typeof body.pr === "string") {
+    if (token) throw new LnurlError(`The callback answered token option ${token.id} with an invoice`);
+    const invoiceMsat = amountMsatOf(body.pr);
+    if (invoiceMsat === void 0) throw new LnurlError("The callback returned an invoice that does not decode");
+    if (invoiceMsat !== amountMsat) {
+      throw new LnurlError(`The callback returned an invoice for ${invoiceMsat ?? "no"} millisats, not the requested ${amountMsat}`);
+    }
+    const result = { kind: "bolt11", pr: body.pr, verify: typeof body.verify === "string" ? body.verify : void 0 };
+    if (typeof body.verifyBatch === "string") result.verifyBatch = body.verifyBatch;
+    if (typeof body.paymentOption === "string") result.paymentOption = body.paymentOption;
+    if (body.paymentQuote !== void 0) result.paymentQuote = body.paymentQuote;
+    return result;
+  }
+  if (typeof body.paymentOption === "string") {
+    const result = {
+      kind: "destination",
+      paymentOption: body.paymentOption,
+      ...typeof body.paymentDestination === "string" ? { paymentDestination: body.paymentDestination } : {},
+      ...typeof body.paymentDestinationTag === "string" ? { paymentDestinationTag: body.paymentDestinationTag } : {},
+      ...typeof body.paymentURI === "string" ? { paymentURI: body.paymentURI } : {},
+      ...body.paymentQuote && typeof body.paymentQuote === "object" ? { paymentQuote: body.paymentQuote } : {},
+      ...typeof body.expiresAt === "number" ? { expiresAt: body.expiresAt } : {},
+      ...typeof body.provider === "string" ? { provider: body.provider } : {},
+      ...typeof body.verify === "string" ? { verify: body.verify } : {},
+      ...typeof body.verifyBatch === "string" ? { verifyBatch: body.verifyBatch } : {}
+    };
+    if (token) assertTokenAnswer(token, result);
+    return result;
+  }
+  throw new LnurlError("Unexpected callback response");
+}
+function parseVerifyStatus(body) {
+  if (typeof body.pr === "string") {
+    const settled = body.settled === true;
+    const preimage = typeof body.preimage === "string" ? body.preimage : null;
+    if (settled && (!preimage || !preimageOpens(preimage, body.pr))) {
+      throw new LnurlError("Verify reported settled with a preimage that does not match the invoice's payment hash");
+    }
+    return { kind: "bolt11", settled, preimage, pr: body.pr };
+  }
+  if (typeof body.paymentOption !== "string") {
+    throw new LnurlTransportError("Verify response is neither a bolt11 nor a destination status");
+  }
+  return {
+    kind: "destination",
+    settled: body.settled === true,
+    paymentOption: body.paymentOption,
+    ...typeof body.paymentDestination === "string" ? { paymentDestination: body.paymentDestination } : {},
+    ...typeof body.paymentReference === "string" ? { paymentReference: body.paymentReference } : {}
+  };
+}
+function verifyStatusIsFor(status, expected) {
+  if ("pr" in expected) {
+    const hash = paymentHashOf(expected.pr);
+    return status.kind === "bolt11" && hash !== null && paymentHashOf(status.pr) === hash;
+  }
+  return status.kind === "destination" && status.paymentOption === expected.paymentOption && (status.paymentDestination === void 0 || expected.paymentDestination === void 0 || status.paymentDestination === expected.paymentDestination);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new LnurlError("Aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new LnurlError("Aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function pollVerify(verifyUrl, opts, fetchImpl) {
+  if (!verifyUrl) throw new LnurlError("verify URL is required");
+  const intervalMs = opts?.intervalMs ?? 1e3;
+  const timeoutMs = opts?.timeoutMs ?? 12e4;
+  const deadline = Date.now() + timeoutMs;
+  let lastSnapshot;
+  for (; ; ) {
+    if (opts?.signal?.aborted) throw opts.signal.reason ?? new LnurlError("Aborted");
+    const body = await lnurlFetch(verifyUrl, void 0, fetchImpl);
+    const status = parseVerifyStatus(body);
+    if (opts?.expect && !verifyStatusIsFor(status, opts.expect)) throw new LnurlError("Verify answered about a different payment");
+    lastSnapshot = status;
+    opts?.onUpdate?.(status);
+    if (status.settled) return status;
+    if (Date.now() >= deadline) throw new LnurlTimeoutError(`Verify timed out after ${timeoutMs}ms`, { lastSnapshot });
+    await sleep(intervalMs, opts?.signal);
+  }
+}
+
+// packages/client/src/sse.ts
+function parseFrame(raw) {
+  let event = "";
+  const dataLines = [];
+  for (const line of raw.split("\n")) {
+    if (line === "" || line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    if (colon === -1) continue;
+    const field = line.slice(0, colon);
+    const value = line.slice(colon + 1).startsWith(" ") ? line.slice(colon + 2) : line.slice(colon + 1);
+    if (field === "event") event = value;
+    else if (field === "data") dataLines.push(value);
+  }
+  if (dataLines.length === 0) return void 0;
+  return { event, data: dataLines.join("\n") };
+}
+function createSseParser() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk.replace(/\r\n|\r/g, "\n");
+      const frames = [];
+      let idx;
+      while ((idx = buffer.indexOf("\n\n")) !== -1) {
+        const frame = parseFrame(buffer.slice(0, idx));
+        buffer = buffer.slice(idx + 2);
+        if (frame !== void 0) frames.push(frame);
+      }
+      if (buffer.length > MAX_FRAME_CHARS) throw new LnurlTransportError(`SSE frame over ${MAX_FRAME_CHARS} characters`);
+      return frames;
+    }
+  };
+}
+var MAX_FRAME_CHARS = 1024 * 1024;
+async function readSseStream(body, onFrame, signal) {
+  const parser = createSseParser();
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  try {
+    for (; ; ) {
+      if (signal?.aborted) break;
+      const { done, value } = await reader.read();
+      if (value) for (const f of parser.push(decoder.decode(value, { stream: !done }))) onFrame(f);
+      if (done) break;
+    }
+  } catch (err) {
+    void reader.cancel(err).catch(() => void 0);
+    throw err;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// packages/client/src/verify-batch.ts
+function dedupeUrls(urls) {
+  return [...new Set(urls)];
+}
+async function batchVerify(verifyBatchUrl, verifyUrls, opts, fetchImpl) {
+  if (!verifyBatchUrl) throw new LnurlError("verifyBatch URL is required");
+  const add = dedupeUrls(verifyUrls);
+  if (add.length === 0) throw new LnurlError("at least one verify URL is required");
+  const f = fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
+  return fetchBatch(verifyBatchUrl, add, opts?.signal, f);
+}
+var TOO_LARGE = /* @__PURE__ */ new Set([414, 431]);
+async function fetchBatch(verifyBatchUrl, urls, signal, f) {
+  try {
+    const body = await lnurlFetch(withVerifyParams(verifyBatchUrl, urls), { signal }, f);
+    return parseBatchResults(body, urls);
+  } catch (err) {
+    if (urls.length < 2 || !(err instanceof LnurlError) || !TOO_LARGE.has(err.httpStatus ?? 0)) throw err;
+    const mid = Math.ceil(urls.length / 2);
+    const head = await fetchBatch(verifyBatchUrl, urls.slice(0, mid), signal, f);
+    const tail = await fetchBatch(verifyBatchUrl, urls.slice(mid), signal, f);
+    return { results: Object.assign(/* @__PURE__ */ Object.create(null), head.results, tail.results) };
+  }
+}
+function withVerifyParams(verifyBatchUrl, verifyUrls) {
+  const params = new URLSearchParams();
+  for (const url of verifyUrls) params.append("verify", url);
+  return `${verifyBatchUrl}${verifyBatchUrl.includes("?") ? "&" : "?"}${params.toString()}`;
+}
+function parseBatchResults(body, requested) {
+  const raw = typeof body.results === "object" && body.results !== null ? body.results : void 0;
+  if (!raw) throw new LnurlTransportError("Batch verify response carries no results map");
+  const results = /* @__PURE__ */ Object.create(null);
+  for (const url of requested) {
+    const entry = Object.hasOwn(raw, url) ? raw[url] : void 0;
+    if (typeof entry !== "object" || entry === null) {
+      results[url] = { kind: "error", reason: "no answer for this verify url" };
+      continue;
+    }
+    const record = entry;
+    if (record.status !== "OK") {
+      results[url] = { kind: "error", reason: typeof record.reason === "string" ? record.reason : "unknown error" };
+      continue;
+    }
+    try {
+      results[url] = { kind: "verify", status: parseVerifyStatus(record) };
+    } catch (err) {
+      results[url] = { kind: "error", reason: err.message };
+    }
+  }
+  return { results };
+}
+function openVerifyBatchStream(opts, handlers, fetchImpl) {
+  if (!opts.verifyBatchUrl) throw new LnurlError("verifyBatch URL is required");
+  const openUrls = dedupeUrls(opts.verifyUrls);
+  if (openUrls.length === 0) throw new LnurlError("at least one verify URL is required");
+  if (opts.signal?.aborted) throw opts.signal.reason ?? new LnurlError("Aborted");
+  const f = fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
+  const controller = new AbortController();
+  const onExternalAbort = () => controller.abort(opts.signal.reason);
+  opts.signal?.addEventListener("abort", onExternalAbort, { once: true });
+  let sessionId;
+  let closed = false;
+  function finish() {
+    if (closed) return;
+    closed = true;
+    controller.abort();
+    opts.signal?.removeEventListener("abort", onExternalAbort);
+    handlers.onClose?.();
+  }
+  function fail(err) {
+    if (closed) return;
+    closed = true;
+    controller.abort();
+    opts.signal?.removeEventListener("abort", onExternalAbort);
+    const error = err instanceof LnurlError ? err : err instanceof Error ? new LnurlTransportError(err.message, { cause: err }) : new LnurlTransportError("Batch stream failed");
+    handlers.onError?.(error);
+    handlers.onClose?.();
+  }
+  async function applyUpdate(add, remove) {
+    const params = new URLSearchParams();
+    params.set("session", sessionId);
+    for (const url of dedupeUrls(add)) params.append("add", url);
+    for (const url of dedupeUrls(remove)) params.append("remove", url);
+    const sep = opts.verifyBatchUrl.includes("?") ? "&" : "?";
+    try {
+      await lnurlFetch(`${opts.verifyBatchUrl}${sep}${params.toString()}`, void 0, f);
+    } catch (err) {
+      fail(err instanceof LnurlError ? err : new LnurlTransportError("Batch update failed", { cause: err }));
+    }
+  }
+  function handleFrame(event, raw) {
+    let body;
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      throw new LnurlTransportError("Batch stream carried a frame that is not JSON");
+    }
+    if (typeof body !== "object" || body === null) throw new LnurlTransportError("Batch stream carried an empty frame");
+    const record = body;
+    if (event === "session") {
+      if (typeof record.session === "string") sessionId = record.session;
+      return;
+    }
+    if (event === "removed") {
+      if (typeof record.verify === "string") handlers.onRemoved?.(record.verify);
+      return;
+    }
+    const url = typeof record.verify === "string" ? record.verify : void 0;
+    if (!url) throw new LnurlTransportError("Batch stream carried a result frame without a verify url");
+    handlers.onUpdate?.(url, parseVerifyStatus(record));
+  }
+  void (async () => {
+    try {
+      const openUrl = withVerifyParams(opts.verifyBatchUrl, openUrls);
+      let response = await f(openUrl, { headers: { Accept: "text/event-stream" }, signal: controller.signal });
+      if (response.status === 406) response = await f(openUrl, { signal: controller.signal });
+      if (!response.ok) throw new LnurlError(response.statusText, { httpStatus: response.status });
+      const contentType = response.headers.get("content-type") ?? "";
+      if (!contentType.includes("text/event-stream")) {
+        const snapshot = await response.json();
+        const parsed = parseBatchResults(snapshot, openUrls);
+        for (const [url, item] of Object.entries(parsed.results)) {
+          if (item.kind === "verify") handlers.onUpdate?.(url, item.status);
+        }
+        finish();
+        return;
+      }
+      await readSseStream(response.body, (frame) => {
+        handleFrame(frame.event, frame.data);
+      }, controller.signal);
+    } catch (err) {
+      if (opts.signal?.aborted) {
+        finish();
+        return;
+      }
+      fail(err);
+      return;
+    }
+    finish();
+  })();
+  return {
+    get sessionId() {
+      return sessionId;
+    },
+    update(add, remove = []) {
+      if (closed) throw new LnurlError("Batch stream has ended");
+      if (!sessionId) throw new LnurlError("Batch stream has not yet announced its session");
+      void applyUpdate(add, remove);
+    },
+    close() {
+      finish();
+    }
+  };
+}
+
+// packages/client/src/session.ts
+function postJson(url, token, body, fetchImpl) {
+  return apiFetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", Authorization: `Bearer ${token}` },
+    body: JSON.stringify(body)
+  }, fetchImpl).then(() => void 0);
+}
+async function openSession(baseUrl, opts, handlers, fetchImpl) {
+  const root = baseUrl.replace(/\/+$/, "");
+  const token = opts.token;
+  const reconnect = opts.reconnect;
+  const maxAttempts = reconnect === false ? 0 : reconnect?.maxAttempts ?? 5;
+  const baseDelayMs = (typeof reconnect === "object" ? reconnect.baseDelayMs : void 0) ?? 500;
+  const resumable = token !== void 0 && reconnect !== false;
+  const signal = opts.signal;
+  const backoffMs = (attempt) => Math.min(baseDelayMs * 2 ** (attempt - 1), 3e4);
+  let closed = false;
+  let timer;
+  let activeBody = null;
+  let info = null;
+  let streamDeliveredFrame = false;
+  let resolveOpened;
+  let rejectOpened;
+  const opened = new Promise((res, rej) => {
+    resolveOpened = res;
+    rejectOpened = rej;
+  });
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    const body = activeBody;
+    activeBody = null;
+    if (body) void body.cancel().catch(() => void 0);
+  };
+  const makeSession = (created) => ({
+    sessionId: created.sessionId,
+    lnurl: created.lnurl,
+    token: created.token,
+    get closed() {
+      return closed;
+    },
+    reportSettled: (preimage) => postJson(`${root}/lnurl/session/${created.sessionId}/settled`, created.token, { preimage }, fetchImpl),
+    close
+  });
+  const postSession = async () => {
+    let response;
+    try {
+      response = await fetchImpl(`${root}/lnurl/session`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(token !== void 0 ? { token } : {}),
+        signal
+      });
+    } catch (err) {
+      if (err instanceof LnurlError) throw err;
+      throw new LnurlTransportError("Session request failed", { cause: err });
+    }
+    if (!response.ok) {
+      let reason = response.statusText;
+      let code;
+      try {
+        const data = await response.json();
+        if (typeof data.error === "string") reason = data.error;
+        else if (typeof data.reason === "string") reason = data.reason;
+        if (typeof data.code === "string") code = data.code;
+      } catch {
+      }
+      throw new LnurlError(reason, { httpStatus: response.status, code });
+    }
+    if (response.body === null) throw new LnurlTransportError("Session stream has no readable body");
+    return response;
+  };
+  const onFrame = (frame) => {
+    streamDeliveredFrame = true;
+    if (frame.event === "session_created") {
+      if (info) return;
+      let created;
+      try {
+        created = JSON.parse(frame.data);
+      } catch (err) {
+        rejectOpened(new LnurlTransportError("Invalid session_created frame", { cause: err }));
+        return;
+      }
+      const isNonEmptyString = (v) => typeof v === "string" && v.length > 0;
+      if (!isNonEmptyString(created.sessionId) || !isNonEmptyString(created.lnurl) || !isNonEmptyString(created.token)) {
+        rejectOpened(new LnurlTransportError("session_created frame is missing sessionId, lnurl or token"));
+        return;
+      }
+      info = created;
+      resolveOpened(makeSession(created));
+      return;
+    }
+    const current = info;
+    if (!current) return;
+    if (frame.event === "invoice_request") {
+      let req;
+      try {
+        req = JSON.parse(frame.data);
+      } catch (err) {
+        handlers.onError?.(new LnurlTransportError("Invalid invoice_request frame", { cause: err }));
+        return;
+      }
+      const respond = {
+        answerInvoice: (pr) => postJson(`${root}/lnurl/session/${current.sessionId}/invoice`, current.token, { pr }, fetchImpl),
+        rejectInvoice: (reason) => postJson(`${root}/lnurl/session/${current.sessionId}/invoice`, current.token, { error: reason }, fetchImpl)
+      };
+      try {
+        const result = handlers.onInvoiceRequest(
+          req.comment === void 0 ? { amountMsat: req.amountMsat } : { amountMsat: req.amountMsat, comment: req.comment },
+          respond
+        );
+        if (result instanceof Promise) result.catch((err) => handlers.onError?.(err));
+      } catch (err) {
+        handlers.onError?.(err);
+      }
+      return;
+    }
+    if (frame.event === "invoice_settled") {
+      try {
+        handlers.onSettled?.(JSON.parse(frame.data));
+      } catch (err) {
+        handlers.onError?.(new LnurlTransportError("Invalid invoice_settled frame", { cause: err }));
+      }
+      return;
+    }
+    if (frame.event === "error") {
+      let message = frame.data;
+      try {
+        const data = JSON.parse(frame.data);
+        if (typeof data.error === "string") message = data.error;
+      } catch {
+      }
+      handlers.onError?.(new Error(message));
+    }
+  };
+  const sleep2 = (ms) => new Promise((resolve2) => {
+    timer = setTimeout(() => {
+      timer = void 0;
+      resolve2();
+    }, ms);
+  });
+  const run = async () => {
+    let attempts = 0;
+    for (; ; ) {
+      streamDeliveredFrame = false;
+      let response;
+      try {
+        response = await postSession();
+      } catch (err) {
+        if (!info) {
+          rejectOpened(err);
+          return;
+        }
+        if (err instanceof LnurlError && err.httpStatus === 409) {
+          handlers.onError?.(err);
+          return;
+        }
+        if (closed || signal?.aborted || !resumable || attempts >= maxAttempts) {
+          handlers.onError?.(err);
+          return;
+        }
+        attempts += 1;
+        handlers.onReconnect?.(attempts);
+        await sleep2(backoffMs(attempts));
+        continue;
+      }
+      const body = response.body;
+      activeBody = body;
+      try {
+        await readSseStream(body, onFrame, signal);
+      } catch (err) {
+        if (closed || signal?.aborted) return;
+        if (!info) {
+          rejectOpened(err);
+          return;
+        }
+        handlers.onError?.(err);
+      } finally {
+        if (activeBody === body) activeBody = null;
+      }
+      if (!info) {
+        rejectOpened(new LnurlTransportError("Session stream ended before session_created"));
+        return;
+      }
+      if (streamDeliveredFrame) attempts = 0;
+      if (closed || signal?.aborted || !resumable || attempts >= maxAttempts) return;
+      attempts += 1;
+      handlers.onReconnect?.(attempts);
+      await sleep2(backoffMs(attempts));
+    }
+  };
+  void run();
+  return opened;
+}
+
+// packages/client/src/token.ts
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
+import { hex as hex3 } from "@scure/base";
+var MESSAGE_PREFIX = "lnurl-session:";
+function sessionTokenMessage(domain) {
+  const normalised = domain.trim().toLowerCase();
+  if (!normalised) throw new Error("a session token must be bound to a domain");
+  return sha2563(new TextEncoder().encode(MESSAGE_PREFIX + normalised));
+}
+function tokenFromSignature(signature) {
+  return hex3.encode(sha2563(signature));
+}
+function deriveSessionToken(privateKeyHex, domain) {
+  const signature = secp256k1.sign(sessionTokenMessage(domain), hex3.decode(privateKeyHex), { prehash: false });
+  return tokenFromSignature(signature);
+}
+async function deriveSessionTokenWithSigner(signMessage, domain) {
+  const message = sessionTokenMessage(domain);
+  const first = await signMessage(message, "ecdsa");
+  const second = await signMessage(message, "ecdsa");
+  if (first.length !== second.length || !first.every((b, i) => b === second[i])) {
+    throw new Error(
+      "signer is not deterministic: signing the same message twice differed, so the derived token would change on every call and orphan the address. Use RFC6979 ECDSA, not randomised schnorr."
+    );
+  }
+  return tokenFromSignature(first);
+}
+function deriveSessionId(tokenHex) {
+  return hex3.encode(sha2563(hex3.decode(tokenHex))).slice(0, 32);
+}
+
+// packages/client/src/addresses.ts
+function rootOf(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+var asRegistered = (a) => ({
+  ...a,
+  handle: a.handle ?? a.username,
+  nameless: a.nameless ?? false,
+  sessionLnurl: a.sessionLnurl ?? null
+});
+var asListed = (a) => ({
+  ...a,
+  handle: a.handle ?? a.username,
+  nameless: a.nameless ?? false,
+  sessionLnurl: a.sessionLnurl ?? null
+});
+function registerAddress(baseUrl, req, fetchImpl) {
+  const headers = { "content-type": "application/json" };
+  if (req.apiKey !== void 0) headers["X-API-Key"] = req.apiKey;
+  const body = { token: req.token };
+  if (req.username !== void 0) body["username"] = req.username;
+  if (req.claimCode !== void 0) body["claimCode"] = req.claimCode;
+  if (req.domain !== void 0) body["domain"] = req.domain;
+  if (req.nameless !== void 0) body["nameless"] = req.nameless;
+  return apiFetch(`${rootOf(baseUrl)}/lnurl/address`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  }, fetchImpl).then(asRegistered);
+}
+function listAddresses(baseUrl, token, fetchImpl) {
+  return apiFetch(`${rootOf(baseUrl)}/lnurl/address`, {
+    headers: { Authorization: `Bearer ${token}` }
+  }, fetchImpl).then((entries) => entries.map(asListed));
+}
+function upgradeAddress(baseUrl, req, fetchImpl) {
+  const body = {};
+  if (req.username !== void 0) body["username"] = req.username;
+  if (req.claimCode !== void 0) body["claimCode"] = req.claimCode;
+  const query = req.domain !== void 0 ? `?domain=${encodeURIComponent(req.domain)}` : "";
+  return apiFetch(`${rootOf(baseUrl)}/lnurl/address/${encodeURIComponent(req.handle)}${query}`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json", Authorization: `Bearer ${req.token}` },
+    body: JSON.stringify(body)
+  }, fetchImpl).then(asRegistered);
+}
+function domainCapabilities(baseUrl, opts, fetchImpl) {
+  const query = opts?.domain !== void 0 ? `?domain=${encodeURIComponent(opts.domain)}` : "";
+  return apiFetch(`${rootOf(baseUrl)}/lnurl/domain${query}`, void 0, fetchImpl);
+}
+function toActivity(row) {
+  if (row.paymentOption === "lightning") {
+    const activity2 = {
+      kind: "bolt11",
+      paymentHash: row.paymentHash,
+      pr: row.pr,
+      preimage: row.preimage,
+      swapId: row.swapId,
+      payoutReference: row.payoutReference ?? null,
+      settled: row.settled,
+      amountMsat: row.amountMsat,
+      createdAt: row.createdAt,
+      settledAt: row.settledAt
+    };
+    return activity2;
+  }
+  const activity = {
+    kind: "destination",
+    verifyId: row.paymentHash,
+    paymentOption: row.paymentOption,
+    paymentDestination: row.paymentDestination,
+    covenantScript: row.covenantScript,
+    paymentReference: row.paymentReference,
+    payoutReference: row.payoutReference ?? null,
+    settled: row.settled,
+    amountMsat: row.amountMsat,
+    createdAt: row.createdAt,
+    settledAt: row.settledAt
+  };
+  return activity;
+}
+async function listPayments(baseUrl, token, handle, opts, fetchImpl) {
+  const params = new URLSearchParams();
+  if (opts?.domain !== void 0) params.set("domain", opts.domain);
+  if (opts?.since !== void 0) params.set("since", String(opts.since));
+  if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+  const query = params.size > 0 ? `?${params.toString()}` : "";
+  const page = await apiFetch(
+    `${rootOf(baseUrl)}/lnurl/address/${encodeURIComponent(handle)}/payments${query}`,
+    {
+      headers: { Authorization: `Bearer ${token}` }
+    },
+    fetchImpl
+  );
+  return {
+    source: { ...page.source, handle: page.source.handle ?? handle },
+    payments: page.payments.map(toActivity),
+    nextSince: page.nextSince
+  };
+}
+async function revokeAddress(baseUrl, token, handle, opts, fetchImpl) {
+  const query = opts?.domain !== void 0 ? `?domain=${encodeURIComponent(opts.domain)}` : "";
+  await apiFetch(`${rootOf(baseUrl)}/lnurl/address/${encodeURIComponent(handle)}${query}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${token}` }
+  }, fetchImpl);
+}
+var COMPRESSED_KEY = /^0[23][0-9a-f]{64}$/i;
+async function registerArkadeIdentity(baseUrl, req, fetchImpl) {
+  if (!COMPRESSED_KEY.test(req.claimPublicKey)) {
+    throw new LnurlError("claimPublicKey must be a compressed 33-byte public key (02/03 prefix plus 64 hex chars)");
+  }
+  const body = { arkadeAddress: req.arkadeAddress, claimPublicKey: req.claimPublicKey };
+  if (req.boardingAddress !== void 0) body["boardingAddress"] = req.boardingAddress;
+  if (req.domain !== void 0) body["domain"] = req.domain;
+  await apiFetch(`${rootOf(baseUrl)}/lnurl/address/${encodeURIComponent(req.handle)}/arkade`, {
+    method: "POST",
+    headers: { "content-type": "application/json", Authorization: `Bearer ${req.token}` },
+    body: JSON.stringify(body)
+  }, fetchImpl);
+}
+
+// packages/client/src/sync.ts
+var DEFAULT_SYNC_PAGE_LIMIT = 50;
+var SYNC_MAX_ATTEMPTS = 3;
+var SYNC_RETRY_DELAY_MS = 250;
+var NEVER_SETTLES = /* @__PURE__ */ new Set(["onchain"]);
+var wait = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var isRetryable = (error) => {
+  if (error instanceof LnurlError) return error.retryable;
+  return error?.retryable === true;
+};
+var toStored = (baseUrl, domain, lightningAddress, handle, entry) => {
+  const identifier = entry.kind === "bolt11" ? entry.paymentHash : entry.verifyId;
+  return {
+    key: `${baseUrl}|${identifier}`,
+    baseUrl,
+    domain,
+    lightningAddress,
+    handle,
+    identifier,
+    kind: entry.kind,
+    settled: entry.settled,
+    amountMsat: entry.amountMsat,
+    createdAt: entry.createdAt,
+    settledAt: entry.settledAt,
+    swapId: entry.kind === "bolt11" ? entry.swapId : null,
+    paymentReference: entry.kind === "destination" ? entry.paymentReference : null,
+    // Present on both shapes: every rail eventually credits the owner somewhere.
+    payoutReference: entry.payoutReference ?? null,
+    preimage: entry.kind === "bolt11" ? entry.preimage : null,
+    paymentOption: entry.kind === "destination" ? entry.paymentOption : null,
+    covenantScript: entry.kind === "destination" ? entry.covenantScript : null
+  };
+};
+var mayStillSettle = (row) => !row.settled && (row.paymentOption === null || !NEVER_SETTLES.has(row.paymentOption));
+var resumeFrom = (tail, fallback) => {
+  let oldest = fallback;
+  for (const row of tail) if (mayStillSettle(row) && row.createdAt < oldest) oldest = row.createdAt;
+  return oldest;
+};
+var listWithBackoff = (client, token, handle, domain, since, limit) => {
+  const attempt = async (tries) => {
+    try {
+      return await client.listPayments(token, handle, { domain, since, limit });
+    } catch (error) {
+      if (!isRetryable(error) || tries >= SYNC_MAX_ATTEMPTS) throw error;
+      await wait(tries * SYNC_RETRY_DELAY_MS);
+      return attempt(tries + 1);
+    }
+  };
+  return attempt(1);
+};
+var syncTarget = async (target, client, store, limit, onStored) => {
+  const watermarkKey = `${target.handle}@${target.domain}`;
+  let since = await store.readWatermark(target.baseUrl, watermarkKey);
+  const tail = [];
+  for (; ; ) {
+    const page = await listWithBackoff(client, target.token, target.handle, target.domain, since, limit);
+    const records = page.payments.map(
+      (entry) => toStored(target.baseUrl, page.source.domain, page.source.lightningAddress, page.source.handle, entry)
+    );
+    await store.upsert(records);
+    onStored(records.length);
+    for (const record of records) tail.push(record);
+    if (tail.length > limit) tail.splice(0, tail.length - limit);
+    const previous = since;
+    since = page.nextSince;
+    await store.writeWatermark(target.baseUrl, watermarkKey, resumeFrom(tail, since));
+    if (page.payments.length < limit) return;
+    if (previous !== void 0 && since <= previous) {
+      throw new LnurlError(
+        `payment sync stalled for ${watermarkKey} at ${target.baseUrl}: ${limit} payments share timestamp ${since}, so the cursor cannot advance past them`
+      );
+    }
+  }
+};
+function syncPayments(targets, opts) {
+  const run = async () => {
+    const limit = opts.limit ?? DEFAULT_SYNC_PAGE_LIMIT;
+    let synced = 0;
+    const failures = [];
+    for (const target of targets) {
+      try {
+        await syncTarget(target, opts.client(target.baseUrl), opts.store, limit, (count) => {
+          synced += count;
+        });
+      } catch (error) {
+        failures.push({ baseUrl: target.baseUrl, error });
+      }
+    }
+    return { synced, failures };
+  };
+  return run();
+}
+
+// packages/client/src/stores.ts
+var RECORDS = "arkade-lnurl.payments";
+var WATERMARKS = "arkade-lnurl.watermarks";
+var area = () => {
+  if (typeof localStorage === "undefined") {
+    throw new LnurlError("browserPaymentStore needs localStorage; supply your own PaymentSyncStore");
+  }
+  return localStorage;
+};
+var read = (key, fallback) => {
+  try {
+    const raw = area().getItem(key);
+    return raw ? JSON.parse(raw) : fallback;
+  } catch {
+    return fallback;
+  }
+};
+function browserPaymentStore(prefix = "") {
+  const records = `${prefix}${RECORDS}`;
+  const marks = `${prefix}${WATERMARKS}`;
+  return {
+    async upsert(incoming) {
+      const byKey = new Map(read(records, []).map((r) => [r.key, r]));
+      for (const record of incoming) byKey.set(record.key, record);
+      area().setItem(records, JSON.stringify([...byKey.values()]));
+    },
+    async readWatermark(baseUrl, lightningAddress) {
+      return read(marks, {})[`${baseUrl}|${lightningAddress}`];
+    },
+    async writeWatermark(baseUrl, lightningAddress, since) {
+      const all = read(marks, {});
+      all[`${baseUrl}|${lightningAddress}`] = since;
+      area().setItem(marks, JSON.stringify(all));
+    }
+  };
+}
+function storedPayments(address, prefix = "") {
+  const mine = typeof address === "string" ? (r) => r.lightningAddress === address : (r) => r.domain === address.domain && (r.handle === address.handle || r.handle === void 0 && r.lightningAddress === `${address.handle}@${address.domain}`);
+  return read(`${prefix}${RECORDS}`, []).filter(mine).sort((a, b) => b.createdAt - a.createdAt);
+}
+function forgetStoredPayments(prefix = "") {
+  area().removeItem(`${prefix}${RECORDS}`);
+  area().removeItem(`${prefix}${WATERMARKS}`);
+}
+
+// packages/client/src/index.ts
+function createLnurlClient(opts) {
+  const baseUrl = opts?.baseUrl;
+  const fetchImpl = opts?.fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
+  const needBase = (method) => {
+    if (!baseUrl) throw new LnurlError(`baseUrl is required for ${method}`);
+    return baseUrl;
+  };
+  return {
+    resolve: (input) => resolve(input, fetchImpl),
+    requestInvoice: (payRequest, reqOpts) => requestInvoice(payRequest, reqOpts, fetchImpl),
+    pollVerify: (verifyUrl, pollOpts) => pollVerify(verifyUrl, pollOpts, fetchImpl),
+    batchVerify: (verifyBatchUrl, verifyUrls, opts2) => batchVerify(verifyBatchUrl, verifyUrls, opts2, opts2?.fetchImpl),
+    openSession: async (sessionOpts, handlers) => openSession(needBase("openSession"), sessionOpts, handlers, fetchImpl),
+    openVerifyBatchStream: (streamOpts, handlers) => openVerifyBatchStream(streamOpts, handlers, streamOpts?.fetchImpl),
+    registerAddress: async (req) => registerAddress(needBase("registerAddress"), req, fetchImpl),
+    upgradeAddress: async (req) => upgradeAddress(needBase("upgradeAddress"), req, fetchImpl),
+    domainCapabilities: async (capOpts) => domainCapabilities(needBase("domainCapabilities"), capOpts, fetchImpl),
+    listAddresses: async (token) => listAddresses(needBase("listAddresses"), token, fetchImpl),
+    revokeAddress: async (token, handle, revokeOpts) => revokeAddress(needBase("revokeAddress"), token, handle, revokeOpts, fetchImpl),
+    registerArkadeIdentity: async (req) => registerArkadeIdentity(needBase("registerArkadeIdentity"), req, fetchImpl),
+    listPayments: async (token, handle, listOpts) => listPayments(needBase("listPayments"), token, handle, listOpts, fetchImpl)
+  };
+}
+
+export {
+  LnurlError,
+  LnurlTransportError,
+  LnurlTimeoutError,
+  deriveSessionToken,
+  deriveSessionTokenWithSigner,
+  deriveSessionId,
+  isLnAddress,
+  isLnUrl,
+  isValidLnUrl,
+  toPayRequestUrl,
+  isTokenAddress,
+  tokenOptions,
+  resolve,
+  requestInvoice,
+  verifyStatusIsFor,
+  pollVerify,
+  batchVerify,
+  openVerifyBatchStream,
+  openSession,
+  registerAddress,
+  listAddresses,
+  upgradeAddress,
+  domainCapabilities,
+  listPayments,
+  revokeAddress,
+  registerArkadeIdentity,
+  syncPayments,
+  browserPaymentStore,
+  storedPayments,
+  forgetStoredPayments,
+  createLnurlClient
+};