@arkade-os/lnurl-client 0.6.0 → 0.7.0

package/dist/{chunk-YKBY6NCA.js → chunk-4ELYU6DY.js}

@@ -1,55 +1,8 @@
-// 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;
-  }
-};
+import {
+  LnurlError,
+  LnurlTimeoutError,
+  LnurlTransportError
+} from "./chunk-H7W5RHP2.js";
 
 // packages/client/src/http.ts
 async function callFetch(url, init, fetchImpl) {
@@ -204,6 +157,87 @@ function tokenOptions(payRequest) {
   });
 }
 
+// packages/client/src/units.ts
+function formatUnitAmount(amount, decimals) {
+  const digits = String(amount).padStart(decimals + 1, "0");
+  return decimals ? `${digits.slice(0, -decimals)}.${digits.slice(-decimals)}` : digits;
+}
+function parseUnitAmount(text, decimals) {
+  const match = /^(\d*)(?:\.(\d*))?$/.exec(text.trim());
+  if (!match || match[1] === "" && !match[2]) return void 0;
+  const fraction = match[2] ?? "";
+  if (fraction.length > decimals) return void 0;
+  const amount = Number(`${match[1]}${fraction.padEnd(decimals, "0")}`);
+  return Number.isSafeInteger(amount) && amount > 0 ? amount : void 0;
+}
+
+// packages/client/src/token-quotes.ts
+var decimal = (value) => value.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
+function tokenPayment(token, answer) {
+  if (answer.paymentOption !== token.id) throw new LnurlError(`The callback answered for ${answer.paymentOption}, not ${token.id}`);
+  const destination = answer.paymentDestination;
+  if (!destination || !isTokenAddress(token.asset.namespace, destination)) {
+    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}`);
+  }
+  if (!Number.isInteger(token.unit.decimals) || token.unit.decimals < 0 || token.unit.decimals > 36) {
+    throw new LnurlError("The token unit has invalid decimals");
+  }
+  const baseUnits = payment.amount;
+  return {
+    destination,
+    baseUnits,
+    amount: decimal(formatUnitAmount(BigInt(baseUnits).toString(), token.unit.decimals)),
+    ...answer.paymentDestinationTag !== void 0 ? { paymentDestinationTag: answer.paymentDestinationTag } : {}
+  };
+}
+function paysQuote(uri, { destination, baseUnits, amount, paymentDestinationTag }, asset) {
+  let url;
+  try {
+    url = new URL(uri);
+  } catch {
+    return false;
+  }
+  if (url.hash) return false;
+  const q = url.searchParams;
+  const only = (key) => q.getAll(key).length === 1 ? q.get(key) : void 0;
+  if (asset.namespace === "eip155" && url.protocol === "ethereum:") {
+    const target = /^(0x[0-9a-f]{40})(?:@(\d+))?\/transfer$/i.exec(url.pathname);
+    let transferArgumentsOnly = true;
+    q.forEach((_value, key) => {
+      if (key !== "address" && key !== "uint256") transferArgumentsOnly = false;
+    });
+    return paymentDestinationTag === void 0 && target !== null && transferArgumentsOnly && target[1].toLowerCase() === asset.reference.toLowerCase() && (target[2] ?? "1") === asset.chainReference && only("address")?.toLowerCase() === destination.toLowerCase() && only("uint256") === baseUnits;
+  }
+  if (asset.namespace === "solana" && url.protocol === "solana:") {
+    const requestedAmount = only("amount");
+    return url.pathname === destination && only("spl-token") === asset.reference && q.getAll("memo").length <= 1 && (paymentDestinationTag === void 0 || only("memo") === paymentDestinationTag) && requestedAmount !== void 0 && /^\d+(?:\.\d+)?$/.test(requestedAmount) && decimal(requestedAmount) === amount;
+  }
+  return false;
+}
+function payableTokenUri(token, answer) {
+  const payment = tokenPayment(token, answer);
+  return answer.paymentURI && paysQuote(answer.paymentURI, payment, token.asset) ? answer.paymentURI : payment.destination;
+}
+function normalizeTokenQuote(token, answer, nowMs = Date.now()) {
+  const payment = tokenPayment(token, answer);
+  const rawExpiry = answer.paymentQuote?.expiresAt;
+  const expiresAt = typeof rawExpiry === "string" ? Date.parse(rawExpiry) : NaN;
+  if (!Number.isFinite(nowMs) || !Number.isFinite(expiresAt) || expiresAt <= nowMs) {
+    throw new LnurlError("The token quote has no valid future expiry");
+  }
+  return {
+    optionId: token.id,
+    ...payment,
+    value: answer.paymentURI && paysQuote(answer.paymentURI, payment, token.asset) ? answer.paymentURI : payment.destination,
+    expiresAt
+  };
+}
+
 // packages/client/src/payer.ts
 import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import { hex as hex2 } from "@scure/base";
@@ -253,16 +287,26 @@ function preimageOpens(preimage, 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`);
+function quotableUnit(payRequest, code, amount) {
+  const unit = payRequest.units?.find((u) => u.code.toUpperCase() === code.toUpperCase());
+  if (!unit) throw new LnurlError(`This payRequest does not quote in ${code}`);
+  if (!Number.isSafeInteger(amount) || amount <= 0) throw new LnurlError(`Amount must be a positive whole number of ${unit.code}'s smallest unit`);
+  const bound = (b) => b !== void 0 && /^\d+$/.test(b) ? BigInt(b) : void 0;
+  const lo = bound(unit.minAmount);
+  const hi = bound(unit.maxAmount);
+  if (lo !== void 0 && BigInt(amount) < lo || hi !== void 0 && BigInt(amount) > hi) {
+    throw new LnurlError(`Amount must be between ${unit.minAmount ?? 1} and ${unit.maxAmount ?? "any"} in ${unit.code}'s smallest unit`);
   }
-  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}`);
+  return unit;
+}
+function quotedMsat(raw, unit, amount) {
+  const q = raw;
+  if (q?.requested?.unit !== unit || q.requested.amount !== String(amount)) {
+    throw new LnurlError(`The callback did not quote ${amount} ${unit}`);
   }
+  const msat2 = q.payment?.unit === "msat" && /^\d+$/.test(q.payment.amount) ? Number(q.payment.amount) : NaN;
+  if (!Number.isSafeInteger(msat2) || msat2 <= 0) throw new LnurlError("The callback quoted no millisat amount to pay");
+  return msat2;
 }
 async function resolve(input, fetchImpl) {
   const source = toPayRequestUrl(input);
@@ -271,20 +315,20 @@ async function resolve(input, fetchImpl) {
   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");
+  if (payRequest.source.surface === "session" && opts.paymentOption !== void 0 && !payRequest.paymentOptions) {
+    throw new LnurlError("paymentOption needs a session payRequest that advertises options; this one does not");
   }
-  const amountMsat = opts.amountSat * 1e3;
+  const unit = opts.unit === void 0 ? void 0 : quotableUnit(payRequest, opts.unit, opts.amount);
   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)) {
+  const amountMsat = unit ? void 0 : opts.amountSat * 1e3;
+  if (amountMsat !== void 0 && !Number.isSafeInteger(amountMsat)) {
     throw new LnurlError("Amount must be a whole number of millisats");
   }
-  if (amountMsat < min || amountMsat > max) {
+  if (amountMsat !== void 0 && (amountMsat < min || amountMsat > max)) {
     throw new LnurlError(`Amount must be between ${min} and ${max} millisats`);
   }
   if (opts.comment !== void 0 && opts.comment.length > 0) {
@@ -295,18 +339,19 @@ async function requestInvoice(payRequest, opts, fetchImpl) {
     }
   }
   const params = new URLSearchParams();
-  params.set("amount", String(amountMsat));
+  params.set("amount", String(unit ? opts.amount : 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);
+  if (unit) params.set("unit", unit.code);
   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 expectedMsat = unit ? quotedMsat(body.paymentQuote, unit.code, opts.amount) : amountMsat;
+    if (invoiceMsat !== expectedMsat) {
+      throw new LnurlError(`The callback returned an invoice for ${invoiceMsat ?? "no"} millisats, not the ${unit ? "quoted" : "requested"} ${expectedMsat}`);
     }
     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;
@@ -327,7 +372,11 @@ async function requestInvoice(payRequest, opts, fetchImpl) {
       ...typeof body.verify === "string" ? { verify: body.verify } : {},
       ...typeof body.verifyBatch === "string" ? { verifyBatch: body.verifyBatch } : {}
     };
-    if (token) assertTokenAnswer(token, result);
+    if (token) {
+      const paymentURI = payableTokenUri(token, result);
+      if (result.paymentURI !== void 0) result.paymentURI = paymentURI;
+    }
+    if (unit) quotedMsat(body.paymentQuote, unit.code, opts.amount);
     return result;
   }
   throw new LnurlError("Unexpected callback response");
@@ -898,7 +947,8 @@ function toActivity(row) {
       settled: row.settled,
       amountMsat: row.amountMsat,
       createdAt: row.createdAt,
-      settledAt: row.settledAt
+      settledAt: row.settledAt,
+      ...row.quote ? { quote: row.quote } : {}
     };
     return activity2;
   }
@@ -913,7 +963,8 @@ function toActivity(row) {
     settled: row.settled,
     amountMsat: row.amountMsat,
     createdAt: row.createdAt,
-    settledAt: row.settledAt
+    settledAt: row.settledAt,
+    ...row.quote ? { quote: row.quote } : {}
   };
   return activity;
 }
@@ -945,17 +996,47 @@ async function revokeAddress(baseUrl, token, handle, opts, fetchImpl) {
 }
 var COMPRESSED_KEY = /^0[23][0-9a-f]{64}$/i;
 async function registerArkadeIdentity(baseUrl, req, fetchImpl) {
-  if (!COMPRESSED_KEY.test(req.claimPublicKey)) {
+  if (!req.hd && !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.hd && (req.arkadeAddress !== void 0 || req.claimPublicKey !== void 0 || req.boardingAddress !== void 0)) {
+    throw new LnurlError("HD receive cannot include a static wallet destination");
+  }
+  const body = req.hd ? { hd: req.hd } : { arkadeAddress: req.arkadeAddress, claimPublicKey: req.claimPublicKey };
+  if (!req.hd && 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`, {
+  const result = 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);
+  if (req.hd && result?.receiveMode !== "hd") throw new LnurlError("Server did not confirm HD receive mode");
+}
+async function listHdAllocations(baseUrl, token, handle, opts, fetchImpl) {
+  if (opts?.after !== void 0 && (!Number.isSafeInteger(opts.after) || opts.after < 0)) {
+    throw new LnurlError("Allocation cursor must be a non-negative integer");
+  }
+  if (opts?.limit !== void 0 && (!Number.isSafeInteger(opts.limit) || opts.limit <= 0)) {
+    throw new LnurlError("Allocation limit must be a positive integer");
+  }
+  const params = new URLSearchParams();
+  if (opts?.domain !== void 0) params.set("domain", opts.domain);
+  if (opts?.after !== void 0) params.set("after", String(opts.after));
+  if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+  const query = params.size ? `?${params.toString()}` : "";
+  const page = await apiFetch(`${rootOf(baseUrl)}/lnurl/address/${encodeURIComponent(handle)}/arkade/allocations${query}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  }, fetchImpl);
+  if (!page || !Array.isArray(page.allocations) || !Number.isSafeInteger(page.nextAfter)) {
+    throw new LnurlError("Invalid HD allocation page");
+  }
+  let previous = opts?.after ?? 0;
+  for (const allocation of page.allocations) {
+    if (!allocation || !Number.isSafeInteger(allocation.id) || allocation.id <= previous || !Number.isSafeInteger(allocation.index) || allocation.index < 0 || allocation.index >= 2147483648 || typeof allocation.descriptor !== "string" || typeof allocation.arkadeAddress !== "string" || !COMPRESSED_KEY.test(allocation.claimPublicKey) || !allocation.hd || allocation.hd.version !== 1 || !Number.isSafeInteger(allocation.createdAt)) throw new LnurlError("Invalid HD allocation page");
+    previous = allocation.id;
+  }
+  if (page.nextAfter !== previous) throw new LnurlError("Invalid HD allocation cursor");
+  return page;
 }
 
 // packages/client/src/sync.ts
@@ -988,7 +1069,8 @@ var toStored = (baseUrl, domain, lightningAddress, handle, entry) => {
     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
+    covenantScript: entry.kind === "destination" ? entry.covenantScript : null,
+    ...entry.quote ? { quote: entry.quote } : {}
   };
 };
 var mayStillSettle = (row) => !row.settled && (row.paymentOption === null || !NEVER_SETTLES.has(row.paymentOption));
@@ -1097,6 +1179,177 @@ function forgetStoredPayments(prefix = "") {
   area().removeItem(`${prefix}${WATERMARKS}`);
 }
 
+// packages/client/src/confirmations.ts
+var POLL_MS = 2e3;
+var BATCH_TIMEOUT_MS = 1e4;
+var CONFIRMATION_TIMEOUT_MS = 18e4;
+function createPendingConfirmations(client = createLnurlClient()) {
+  const entries = /* @__PURE__ */ new Set();
+  const batches = /* @__PURE__ */ new Set();
+  let timer;
+  let ticking = false;
+  let generation = 0;
+  function maybeStop() {
+    if (timer && entries.size === 0) {
+      clearInterval(timer);
+      timer = void 0;
+    }
+  }
+  function finish(entry, notify) {
+    if (!entries.delete(entry)) return;
+    entry.soloPolling?.abort();
+    maybeStop();
+    try {
+      notify();
+    } catch {
+    }
+  }
+  const fail = (entry, err) => finish(entry, () => entry.onError(err));
+  const expire = (entry) => {
+    if (Date.now() < entry.deadline) return false;
+    fail(entry, new Error("receiver did not confirm settlement in time"));
+    return true;
+  };
+  function settle(entry, status) {
+    if (expire(entry)) return;
+    if (entry.expect && !verifyStatusIsFor(status, entry.expect)) {
+      fail(entry, new Error("verify answered about a different payment"));
+    } else if (status.settled) {
+      finish(entry, () => entry.onSettled(status));
+    }
+  }
+  async function tick(current) {
+    const now = Date.now();
+    for (const entry of [...entries]) expire(entry);
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (entry.soloPolling) continue;
+      if (entry.verifyBatch === void 0) {
+        entry.soloPolling = new AbortController();
+        void Promise.resolve().then(() => client.pollVerify(entry.verifyUrl, {
+          intervalMs: POLL_MS,
+          timeoutMs: entry.deadline - now,
+          signal: entry.soloPolling.signal,
+          ...entry.expect ? { expect: entry.expect } : {}
+        })).then((status) => settle(entry, status)).catch((err) => fail(entry, err instanceof Error ? err : new Error(String(err))));
+      } else {
+        const group = groups.get(entry.verifyBatch) ?? [];
+        group.push(entry);
+        groups.set(entry.verifyBatch, group);
+      }
+    }
+    for (const [endpoint, group] of groups) {
+      if (current !== generation) return;
+      const active = group.filter((entry) => entries.has(entry) && !expire(entry));
+      if (!active.length) continue;
+      const abort = new AbortController();
+      batches.add(abort);
+      const cancelled = new Promise((_, reject) => {
+        abort.signal.addEventListener("abort", () => reject(new Error("batch verify aborted")), { once: true });
+      });
+      const cutoff = setTimeout(() => abort.abort(), Math.max(
+        0,
+        Math.min(BATCH_TIMEOUT_MS, ...active.map((entry) => entry.deadline - Date.now()))
+      ));
+      try {
+        const body = await Promise.race([
+          client.batchVerify(endpoint, [...new Set(active.map((entry) => entry.verifyUrl))], { signal: abort.signal }),
+          cancelled
+        ]);
+        for (const entry of active) {
+          const answer = body.results[entry.verifyUrl];
+          if (!answer || answer.kind !== "verify") {
+            fail(entry, new Error(answer?.reason ?? "no answer for this verify URL"));
+          } else {
+            settle(entry, answer.status);
+          }
+        }
+      } catch {
+      } finally {
+        clearTimeout(cutoff);
+        batches.delete(abort);
+      }
+    }
+  }
+  function ensure() {
+    if (timer) return;
+    timer = setInterval(() => {
+      if (ticking) return;
+      const current = generation;
+      ticking = true;
+      void tick(current).finally(() => {
+        if (current === generation) ticking = false;
+      });
+    }, POLL_MS);
+  }
+  return {
+    add(confirmation) {
+      if ([...entries].some((entry) => (entry.key ?? entry.verifyUrl) === (confirmation.key ?? confirmation.verifyUrl))) return;
+      entries.add({
+        ...confirmation,
+        deadline: (confirmation.startedAt ?? Date.now()) + (confirmation.timeoutMs ?? CONFIRMATION_TIMEOUT_MS)
+      });
+      ensure();
+    },
+    forget() {
+      const forgotten = [...entries];
+      entries.clear();
+      generation++;
+      ticking = false;
+      maybeStop();
+      for (const entry of forgotten) entry.soloPolling?.abort();
+      for (const abort of batches) abort.abort();
+      batches.clear();
+    }
+  };
+}
+
+// packages/client/src/repository.ts
+function createLnurlPaymentRepository(payments, watermarks) {
+  const inFlight = /* @__PURE__ */ new Set();
+  let closed = false;
+  const write = async (work) => {
+    if (closed) return;
+    const pending = Promise.resolve().then(work);
+    inFlight.add(pending);
+    try {
+      await pending;
+    } finally {
+      inFlight.delete(pending);
+    }
+  };
+  return {
+    all: () => payments.read(),
+    upsert: (records) => write(() => payments.write(records)),
+    readWatermark: (baseUrl, address) => watermarks.read(baseUrl, address),
+    writeWatermark: (baseUrl, address, since) => write(() => watermarks.write(baseUrl, address, since)),
+    clear: async () => {
+      await watermarks.clear();
+      await payments.clear();
+    },
+    closeWrites: () => {
+      closed = true;
+    },
+    reopenWrites: () => {
+      closed = false;
+    },
+    writesClosed: () => closed,
+    writesSettled: async () => {
+      await Promise.allSettled([...inFlight]);
+    }
+  };
+}
+async function clearLnurlPaymentsForReset(repository) {
+  repository.closeWrites();
+  try {
+    await repository.writesSettled();
+    await repository.clear();
+  } catch (error) {
+    repository.reopenWrites();
+    throw error;
+  }
+}
+
 // packages/client/src/index.ts
 function createLnurlClient(opts) {
   const baseUrl = opts?.baseUrl;
@@ -1109,7 +1362,7 @@ function createLnurlClient(opts) {
     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),
+    batchVerify: (verifyBatchUrl, verifyUrls, opts2) => batchVerify(verifyBatchUrl, verifyUrls, opts2, opts2?.fetchImpl ?? 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),
@@ -1118,14 +1371,12 @@ function createLnurlClient(opts) {
     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),
+    listHdAllocations: async (token, handle, listOpts) => listHdAllocations(needBase("listHdAllocations"), token, handle, listOpts, fetchImpl),
     listPayments: async (token, handle, listOpts) => listPayments(needBase("listPayments"), token, handle, listOpts, fetchImpl)
   };
 }
 
 export {
-  LnurlError,
-  LnurlTransportError,
-  LnurlTimeoutError,
   deriveSessionToken,
   deriveSessionTokenWithSigner,
   deriveSessionId,
@@ -1135,6 +1386,10 @@ export {
   toPayRequestUrl,
   isTokenAddress,
   tokenOptions,
+  formatUnitAmount,
+  parseUnitAmount,
+  payableTokenUri,
+  normalizeTokenQuote,
   resolve,
   requestInvoice,
   verifyStatusIsFor,
@@ -1149,9 +1404,14 @@ export {
   listPayments,
   revokeAddress,
   registerArkadeIdentity,
+  listHdAllocations,
   syncPayments,
   browserPaymentStore,
   storedPayments,
   forgetStoredPayments,
+  CONFIRMATION_TIMEOUT_MS,
+  createPendingConfirmations,
+  createLnurlPaymentRepository,
+  clearLnurlPaymentsForReset,
   createLnurlClient
 };

package/dist/chunk-H7W5RHP2.js

@@ -0,0 +1,58 @@
+// 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;
+  }
+};
+
+export {
+  LnurlError,
+  LnurlTransportError,
+  LnurlTimeoutError
+};

package/dist/hd.d.ts

@@ -0,0 +1,16 @@
+import * as _arkade_os_sdk from '@arkade-os/sdk';
+import { IContractManager } from '@arkade-os/sdk';
+import { b as HdReceiveConfig, c as HdReceiveAllocation } from './addresses-CPAzIbJ_.js';
+export { H as HdReceiveAllocationPage } from './addresses-CPAzIbJ_.js';
+
+interface HdReceiveBranch {
+    hd: HdReceiveConfig;
+    signingDescriptor(index: number): string;
+}
+declare function createHdReceiveBranch(params: Omit<HdReceiveConfig, "version" | "descriptor"> & {
+    accountDescriptor: string;
+    branchPath: string;
+}): HdReceiveBranch;
+declare function restoreHdReceiveAllocation(manager: Pick<IContractManager, "createContract">, allocation: HdReceiveAllocation, branch: HdReceiveBranch): Promise<_arkade_os_sdk.Contract>;
+
+export { HdReceiveAllocation, type HdReceiveBranch, HdReceiveConfig, createHdReceiveBranch, restoreHdReceiveAllocation };