@arkade-os/lnurl-client 0.6.0 → 0.7.0

package/dist/arkade.js

@@ -1,14 +1,18 @@
 import {
-  LnurlError,
   createLnurlClient,
+  createPendingConfirmations,
   deriveSessionId,
   deriveSessionTokenWithSigner,
+  formatUnitAmount,
   syncPayments
-} from "./chunk-YKBY6NCA.js";
+} from "./chunk-4ELYU6DY.js";
+import {
+  LnurlError
+} from "./chunk-H7W5RHP2.js";
 
 // packages/client/src/arkade.ts
-import { ArkAddress } from "@arkade-os/sdk";
-import { hex } from "@scure/base";
+import { ArkAddress as ArkAddress2 } from "@arkade-os/sdk";
+import { hex as hex2 } from "@scure/base";
 
 // packages/client/src/rail.ts
 import { isLnurl } from "@arkade-os/sdk";
@@ -54,6 +58,11 @@ function makeRail(type, id, inner, deps, resolveOnce) {
       } catch {
         return false;
       }
+      if (req.unitAmount) {
+        if (!unitOf(pr, req.unitAmount.unit)) return false;
+        if (pr.paymentOptions === void 0) return type === "lightning";
+        return pr.paymentOptions.some((o) => o.type === type && o.available !== false);
+      }
       if (pr.paymentOptions === void 0) {
         if (type !== "lightning") return false;
         if (req.amount === void 0) return true;
@@ -68,24 +77,41 @@ function makeRail(type, id, inner, deps, resolveOnce) {
     },
     async quote(req, ctx) {
       const pr = await resolveOnce(req.raw);
-      if (req.amount === void 0) throw new LnurlError(`${id} needs an explicit amount`);
+      const inUnit = req.unitAmount;
+      if (req.amount === void 0 && !inUnit) throw new LnurlError(`${id} needs an explicit amount`);
       const option = pr.paymentOptions?.find((o) => o.type === type && o.available !== false)?.id;
-      const result = await deps.client.requestInvoice(pr, {
-        amountSat: req.amount,
+      const extra = {
         ...option !== void 0 ? { paymentOption: option } : {},
         ...deps.comment !== void 0 ? { comment: deps.comment } : {}
-      });
-      const delegated = result.kind === "bolt11" ? { raw: result.pr } : { raw: destinationOf(result.paymentDestination, id), amount: req.amount };
+      };
+      const result = await deps.client.requestInvoice(
+        pr,
+        inUnit ? { ...extra, unit: inUnit.unit, amount: inUnit.amount } : { ...extra, amountSat: req.amount }
+      );
+      const quotedSat = inUnit ? Number(result.paymentQuote?.payment.amount) / 1e3 : req.amount;
+      if (!Number.isSafeInteger(quotedSat)) throw new LnurlError(`${id}: the quote names no whole number of sats`);
+      const delegated = result.kind === "bolt11" ? { raw: result.pr } : { raw: destinationOf(result.paymentDestination, id), amount: quotedSat };
       if (!inner.match(delegated, ctx)) {
         throw new LnurlError(`${id}: ${inner.id} cannot pay the destination the callback returned`);
       }
       const quote = await inner.quote(delegated, ctx);
       const expect = result.kind === "bolt11" ? { pr: result.pr } : { paymentOption: result.paymentOption, paymentDestination: result.paymentDestination };
-      const lnurl = { target: req.raw, via: inner.id, verify: result.verify, verifyBatch: result.verifyBatch, expect };
+      const unit = inUnit ? unitOf(pr, inUnit.unit) : void 0;
+      const lnurl = {
+        target: req.raw,
+        via: inner.id,
+        verify: result.verify,
+        verifyBatch: result.verifyBatch,
+        expect,
+        ...inUnit && unit ? { quote: { amount: String(inUnit.amount), unit: unit.code, decimals: unit.decimals } } : {}
+      };
       return { ...quote, railId: id, meta: { ...quote.meta, lnurl } };
     }
   };
 }
+function unitOf(pr, code) {
+  return pr.units?.find((u) => u.code.toUpperCase() === code.toUpperCase());
+}
 function destinationOf(destination, id) {
   if (!destination) throw new LnurlError(`${id}: the callback returned no payment destination`);
   return destination;
@@ -139,7 +165,11 @@ function arkadeLnurl(opts) {
   const { wallet, baseUrl } = opts;
   const domain = opts.domain ?? new URL(baseUrl).hostname;
   const identity = wallet ? wallet.identity : opts.identity;
-  const addresses = async () => wallet ? { arkadeAddress: await wallet.getAddress(), boardingAddress: await wallet.getBoardingAddress() } : { arkadeAddress: opts.arkadeAddress, ...opts.boardingAddress ? { boardingAddress: opts.boardingAddress } : {} };
+  const addresses = async () => {
+    if (wallet) return { arkadeAddress: await wallet.getAddress(), boardingAddress: await wallet.getBoardingAddress() };
+    if (!opts.arkadeAddress) throw new LnurlError("Static receive requires an Arkade address");
+    return { arkadeAddress: opts.arkadeAddress, ...opts.boardingAddress ? { boardingAddress: opts.boardingAddress } : {} };
+  };
   const client = opts.client ?? createLnurlClient({ baseUrl });
   const payer = createLnurlClient();
   let tokenOnce;
@@ -180,6 +210,7 @@ function arkadeLnurl(opts) {
         return entry.pr;
       },
       payments: (listOpts) => client.listPayments(held, handle, { domain, ...listOpts }),
+      allocations: (listOpts) => client.listHdAllocations(held, handle, { domain, ...listOpts }),
       sync: async () => syncPayments(
         [{ baseUrl, token: held, handle, domain }],
         { client: (target) => createLnurlClient({ baseUrl: target }), store: needStore() }
@@ -216,7 +247,7 @@ function arkadeLnurl(opts) {
         );
       }
       await client.registerArkadeIdentity(
-        await arkadeIdentityRequest({
+        opts.hd ? { token: held, handle: registered.handle, domain, hd: opts.hd } : await arkadeIdentityRequest({
           identity,
           token: held,
           handle: registered.handle,
@@ -227,11 +258,15 @@ function arkadeLnurl(opts) {
       return receiverFrom(held, registered.handle, registered.lightningAddress, flagged);
     },
     router,
-    options: (target, amountSat, prefs) => router().options({ raw: target.trim(), amount: amountSat }, { priority: DEFAULT_RAIL_PRIORITY, ...prefs })
+    options: (target, amount, prefs) => router().options(
+      typeof amount === "number" ? { raw: target.trim(), amount } : { raw: target.trim(), unitAmount: amount },
+      { priority: DEFAULT_RAIL_PRIORITY, ...prefs }
+    )
   };
 }
 
 // packages/client/src/activity.ts
+var quotedLabel = (q) => `${formatUnitAmount(q.amount, q.decimals)} ${q.unit}`;
 var LNURL_RESOLVER_ID = "lnurl:payments";
 var SENT_RESOLVER_ID = "lnurl:sends";
 var LNURL_GROUP_PREFIX = "lnurl:";
@@ -264,6 +299,7 @@ function sentActivityResolver(sends) {
           target: sent.target,
           rail: sent.railId,
           delivered: `${sent.amountSat} sats`,
+          ...sent.quote ? { requested: quotedLabel(sent.quote) } : {},
           ...sent.feeSat > 0 ? { fee: `${sent.feeSat} sats` } : {},
           ...sent.swapId ? { swap: sent.swapId } : {},
           ...sent.preimage ? { preimage: sent.preimage } : {},
@@ -293,17 +329,176 @@ function lnurlActivityResolver(payments) {
           rail: railOf(payment),
           lightningAddress: payment.lightningAddress,
           identifier: payment.identifier,
-          verified: payment.settled
+          verified: payment.settled,
+          ...payment.quote ? { requested: quotedLabel(payment.quote) } : {}
         }
       }];
     }
   };
 }
 
+// packages/client/src/sends.ts
+function createLnurlSendTracker(store, options) {
+  const confirmations = options.confirmations ?? createPendingConfirmations();
+  const subscriptions = /* @__PURE__ */ new Set();
+  let generation = 0;
+  const persist = (update) => {
+    try {
+      const rows = update(store.read());
+      if (rows) store.write(rows);
+    } catch (error) {
+      options.onError(error);
+    }
+  };
+  const save = (sent) => persist((rows) => mergeSentPayment(rows, sent));
+  const mark = (txid, confirmed) => persist((rows) => {
+    const sent = rows.find((row) => row.txid === txid);
+    return sent ? mergeSentPayment(rows, { ...sent, receiverConfirmed: confirmed }) : void 0;
+  });
+  const watch = (txid, verify, verifyBatch, startedAt, expect) => {
+    const current = generation;
+    confirmations.add({
+      key: txid,
+      verifyUrl: verify,
+      verifyBatch,
+      startedAt,
+      expect,
+      onSettled: () => {
+        if (current === generation) mark(txid, true);
+      },
+      onError: () => {
+        if (current === generation) mark(txid, false);
+      }
+    });
+  };
+  return {
+    all: () => store.read(),
+    record(handle, quote, target) {
+      const createdAt = Date.now();
+      const current = generation;
+      const meta = lnurlQuoteMeta(quote);
+      let stopped = false;
+      let unsubscribe;
+      const stop = () => {
+        stopped = true;
+        unsubscribe?.();
+        subscriptions.delete(stop);
+      };
+      subscriptions.add(stop);
+      unsubscribe = handle.subscribe(({ status, result }) => {
+        if (stopped || current !== generation) return;
+        try {
+          if (result?.txid) save({
+            txid: result.txid,
+            target: meta?.target ?? target,
+            railId: quote.railId,
+            amountSat: quote.amount,
+            feeSat: quote.fee,
+            createdAt,
+            ...result.swapId ? { swapId: result.swapId } : {},
+            ...result.preimage ? { preimage: result.preimage } : {},
+            ...meta?.verify ? { verify: meta.verify } : {},
+            ...meta?.verifyBatch ? { verifyBatch: meta.verifyBatch } : {},
+            ...meta?.expect ? { expect: meta.expect } : {},
+            ...meta?.quote ? { quote: meta.quote } : {}
+          });
+        } finally {
+          if (status === "settled" || status === "failed") stop();
+        }
+      });
+      if (stopped) unsubscribe();
+      return stop;
+    },
+    watch,
+    resume() {
+      for (const sent of store.read()) {
+        if (sent.verify && sent.receiverConfirmed === void 0)
+          watch(sent.txid, sent.verify, sent.verifyBatch, sent.createdAt, sent.expect);
+      }
+    },
+    mark,
+    forget() {
+      generation++;
+      confirmations.forget();
+      for (const stop of subscriptions) stop();
+    }
+  };
+}
+
+// packages/client/src/receive-rails.ts
+import { ArkAddress } from "@arkade-os/sdk";
+import { hex } from "@scure/base";
+function lnurlRailLimits(payRequest) {
+  const options = payRequest.paymentOptions ?? [{ id: "lightning", type: "lightning" }];
+  return options.filter((option) => option.id !== "" && option.available !== false && option.asset === void 0).map((option) => ({
+    type: option.type,
+    min: Math.ceil((option.minSendable ?? payRequest.minSendable) / 1e3),
+    max: Math.floor((option.maxSendable ?? payRequest.maxSendable) / 1e3)
+  }));
+}
+function sameOperator(a, b) {
+  try {
+    const [x, y] = [ArkAddress.decode(a), ArkAddress.decode(b)];
+    return x.hrp === y.hrp && hex.encode(x.serverPubKey) === hex.encode(y.serverPubKey);
+  } catch {
+    return false;
+  }
+}
+async function resolveLnurlRails(receiver, amountSat, rails, own, client = createLnurlClient()) {
+  const payRequest = await receiver.payRequest();
+  return Promise.allSettled(rails.map(async (rail) => {
+    const option = payRequest.paymentOptions?.find((candidate) => candidate.id !== "" && candidate.type === rail && candidate.available !== false && candidate.asset === void 0);
+    const legacyLightning = payRequest.paymentOptions === void 0 && rail === "lightning";
+    if (!option && !legacyLightning) throw new LnurlError(`the LNURL offers no ${rail} rail`);
+    const min = option?.minSendable ?? payRequest.minSendable;
+    const max = option?.maxSendable ?? payRequest.maxSendable;
+    const amountMsat = amountSat * 1e3;
+    if (!Number.isSafeInteger(amountMsat) || amountMsat < min || amountMsat > max) {
+      throw new LnurlError(`Amount must be between ${min} and ${max} whole millisats`);
+    }
+    const result = await client.requestInvoice(payRequest, { amountSat, paymentOption: option?.id });
+    if (option && result.paymentOption !== void 0 && result.paymentOption !== option.id) {
+      throw new LnurlError(`The callback answered for ${result.paymentOption}, not ${option.id}`);
+    }
+    const target = result.kind === "bolt11" ? result.pr : result.paymentDestination;
+    if (!target || result.kind === "bolt11" !== (rail === "lightning")) {
+      throw new LnurlError(`the LNURL answered the ${rail} rail with nothing payable on it`);
+    }
+    if (rail === "onchain" && target !== own.onchain) {
+      throw new LnurlError("the LNURL gave an on-chain address that is not this wallet's");
+    }
+    if (rail === "arkade" && !sameOperator(target, own.arkade)) {
+      throw new LnurlError("the LNURL gave an Arkade address on another operator");
+    }
+    return target;
+  }));
+}
+
+// packages/client/src/receiver-bootstrap.ts
+async function bootstrapReceiver(facade, opts = {}) {
+  const receiver = await facade.owned();
+  if (receiver?.lightningAddress) return { kind: "ready", receiver, claimed: false };
+  if (receiver) {
+    try {
+      return { kind: "ready", receiver, claimed: false, capabilities: await facade.capabilities() };
+    } catch (capabilitiesError) {
+      return { kind: "ready", receiver, claimed: false, capabilitiesError };
+    }
+  }
+  const capabilities = await facade.capabilities();
+  if (opts.autoClaimNameless && capabilities.allocationModes.includes("session") && !capabilities.requireApiKey) {
+    return { kind: "ready", receiver: await facade.claim({ nameless: true }), claimed: true, capabilities };
+  }
+  return { kind: "onboarding", capabilities };
+}
+async function claimOrAdopt(facade, opts) {
+  return await facade.owned() ?? facade.claim(opts);
+}
+
 // packages/client/src/arkade.ts
 function isArkadeAddress(address) {
   try {
-    ArkAddress.decode(address);
+    ArkAddress2.decode(address);
     return true;
   } catch {
     return false;
@@ -317,7 +512,7 @@ async function claimPublicKeyOf(identity) {
   if (key.length !== 33) {
     throw new LnurlError(`expected a 33-byte compressed public key, got ${key.length} bytes`);
   }
-  return hex.encode(key);
+  return hex2.encode(key);
 }
 async function arkadeIdentityRequest(params) {
   if (!isArkadeAddress(params.arkadeAddress)) {
@@ -344,14 +539,20 @@ export {
   arkadeIdentityRequest,
   arkadeLnurl,
   arkadePaymentRouter,
+  bootstrapReceiver,
+  claimOrAdopt,
   claimPublicKeyOf,
+  createLnurlSendTracker,
   deriveSessionTokenForIdentity,
   encodeLnurl,
   isArkadeAddress,
   lnurlActivityResolver,
   lnurlQuoteMeta,
+  lnurlRailLimits,
   lnurlRails,
   mergeSentPayment,
+  quotedLabel,
   railOf,
+  resolveLnurlRails,
   sentActivityResolver
 };

package/dist/browser.d.ts

@@ -0,0 +1,6 @@
+import { LnurlPaymentStore } from './index.js';
+import './addresses-CPAzIbJ_.js';
+
+declare function createIndexedDbLnurlPaymentStore(dbName?: string, storeName?: string): LnurlPaymentStore;
+
+export { createIndexedDbLnurlPaymentStore };

package/dist/browser.js

@@ -0,0 +1,60 @@
+// packages/client/src/browser.ts
+function createIndexedDbLnurlPaymentStore(dbName = "arkade-lnurl-payments", storeName = "payments") {
+  const open = () => new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, 1);
+    request.onupgradeneeded = () => {
+      if (!request.result.objectStoreNames.contains(storeName)) {
+        request.result.createObjectStore(storeName, { keyPath: "key" });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+  const run = (mode, work) => open().then((db) => new Promise((resolve, reject) => {
+    const fail = (error) => {
+      db.close();
+      reject(error ?? new DOMException("Transaction aborted", "AbortError"));
+    };
+    let started;
+    try {
+      const tx = db.transaction(storeName, mode);
+      started = tx;
+      tx.onabort = () => fail(tx.error);
+      const result = work(tx.objectStore(storeName));
+      tx.oncomplete = () => {
+        db.close();
+        try {
+          resolve(result());
+        } catch (error) {
+          reject(error);
+        }
+      };
+    } catch (error) {
+      if (started) {
+        started.onabort = () => fail(error);
+        try {
+          started.abort();
+        } catch {
+          fail(error);
+        }
+      } else fail(error);
+    }
+  }));
+  return {
+    read: () => run("readonly", (store) => {
+      const request = store.getAll();
+      return () => request.result;
+    }),
+    write: (records) => run("readwrite", (store) => {
+      for (const record of records) store.put(record);
+      return () => void 0;
+    }),
+    clear: () => run("readwrite", (store) => {
+      store.clear();
+      return () => void 0;
+    })
+  };
+}
+export {
+  createIndexedDbLnurlPaymentStore
+};