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

package/dist/arkade.js

@@ -0,0 +1,558 @@
+import {
+  createLnurlClient,
+  createPendingConfirmations,
+  deriveSessionId,
+  deriveSessionTokenWithSigner,
+  formatUnitAmount,
+  syncPayments
+} from "./chunk-4ELYU6DY.js";
+import {
+  LnurlError
+} from "./chunk-H7W5RHP2.js";
+
+// packages/client/src/arkade.ts
+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";
+var LNURL_ARKADE_RAIL = "lnurl-arkade";
+var LNURL_LIGHTNING_RAIL = "lnurl-lightning";
+var PAY_REQUEST_TTL_MS = 3e4;
+function lnurlQuoteMeta(quote) {
+  const meta = quote.meta?.lnurl;
+  return typeof meta?.target === "string" && typeof meta.via === "string" ? meta : void 0;
+}
+function lnurlRails(deps) {
+  const ttlMs = deps.ttlMs ?? PAY_REQUEST_TTL_MS;
+  const cache = /* @__PURE__ */ new Map();
+  const resolveOnce = (raw) => {
+    const key = raw.trim();
+    const hit = cache.get(key);
+    if (hit && Date.now() - hit.at < ttlMs) return hit.pr;
+    const pr = deps.client.resolve(key).catch((err) => {
+      cache.delete(key);
+      throw err;
+    });
+    cache.set(key, { at: Date.now(), pr });
+    return pr;
+  };
+  const rails = [makeRail("arkade", LNURL_ARKADE_RAIL, deps.arkade, deps, resolveOnce)];
+  if (deps.lightning) {
+    rails.push(makeRail("lightning", LNURL_LIGHTNING_RAIL, deps.lightning, deps, resolveOnce));
+  }
+  return rails;
+}
+function makeRail(type, id, inner, deps, resolveOnce) {
+  return {
+    id,
+    // The SDK's own predicate, which is deliberately looser than this package's
+    // isValidLnUrl: classification is format-only and synchronous, so the rail
+    // claims the shape here and lets resolve() in available() reject a bad
+    // checksum. Using it is also what finally gives `isLnurl` a consumer.
+    match: (req) => isLnurl(req.raw.trim()),
+    async available(req) {
+      let pr;
+      try {
+        pr = await resolveOnce(req.raw);
+      } 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;
+        const msat2 = req.amount * 1e3;
+        return msat2 >= pr.minSendable && msat2 <= pr.maxSendable;
+      }
+      const option = pr.paymentOptions.find((o) => o.type === type && o.available !== false);
+      if (!option) return false;
+      if (req.amount === void 0) return true;
+      const msat = req.amount * 1e3;
+      return msat >= (option.minSendable ?? pr.minSendable) && msat <= (option.maxSendable ?? pr.maxSendable);
+    },
+    async quote(req, ctx) {
+      const pr = await resolveOnce(req.raw);
+      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 extra = {
+        ...option !== void 0 ? { paymentOption: option } : {},
+        ...deps.comment !== void 0 ? { comment: deps.comment } : {}
+      };
+      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 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;
+}
+
+// packages/client/src/wallet.ts
+import { bech32 } from "@scure/base";
+
+// packages/client/src/sdk-adapter.ts
+import { arkRail, BIP21, createDefaultPaymentRouter } from "@arkade-os/sdk";
+function arkadePaymentRouter(opts) {
+  const router = opts.router ?? createDefaultPaymentRouter(opts.wallet);
+  if (opts.lightning) router.use(invoicePricedLeg(opts.lightning));
+  for (const rail of lnurlRails({
+    client: opts.client ?? createLnurlClient(),
+    arkade: arkRail(),
+    ...opts.lightning ? { lightning: opts.lightning } : {},
+    ...opts.comment !== void 0 ? { comment: opts.comment } : {}
+  })) {
+    router.use(rail);
+  }
+  return router;
+}
+function invoicePricedLeg(rail) {
+  const leg = (req) => {
+    if (req.amount === void 0 || req.amount !== BIP21.amountSats(req.raw)) return req;
+    const { amount: _restated, ...rest } = req;
+    return rest;
+  };
+  return {
+    id: rail.id,
+    match: (req, ctx) => rail.match(req, ctx),
+    available: (req, ctx) => rail.available?.(leg(req), ctx) ?? true,
+    quote: (req, ctx) => rail.quote(leg(req), ctx)
+  };
+}
+
+// packages/client/src/wallet.ts
+function encodeLnurl(url) {
+  return bech32.encode("lnurl", bech32.toWords(new TextEncoder().encode(url)), 1023).toUpperCase();
+}
+var DEFAULT_RAIL_PRIORITY = [
+  "lnurl-arkade",
+  "ark",
+  "ark-asset",
+  "lnurl-lightning",
+  "solver-lightning",
+  "onchain"
+];
+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 () => {
+    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;
+  const token = () => tokenOnce ??= deriveSessionTokenForIdentity(identity, domain);
+  let routerOnce;
+  const router = () => {
+    if (!wallet) throw new LnurlError("paying needs a wallet; arkadeLnurl was given an identity only");
+    return routerOnce ??= arkadePaymentRouter({
+      wallet,
+      client: payer,
+      ...opts.router ? { router: opts.router } : {},
+      ...opts.lightningRail ? { lightning: opts.lightningRail } : {}
+    });
+  };
+  let writes = 0;
+  const wrote = () => {
+    writes++;
+  };
+  const needStore = () => {
+    if (!opts.store) throw new LnurlError("sync needs a store; pass one to arkadeLnurl");
+    return opts.store;
+  };
+  const receiverFrom = (held, handle, lightningAddress, flagged) => {
+    const lnurl = flagged ? encodeLnurl(`${baseUrl}/lnurl/${deriveSessionId(held)}`) : encodeLnurl(`${baseUrl}/.well-known/lnurlp/${handle}`);
+    let memo;
+    return {
+      handle,
+      lightningAddress: lightningAddress ?? void 0,
+      lnurl,
+      // `resolve` ignores `baseUrl` and sends no token, so one client is enough.
+      payRequest() {
+        if (memo && memo.writes === writes && Date.now() - memo.at < PAY_REQUEST_TTL_MS) return memo.pr;
+        const entry = { at: Date.now(), writes, pr: client.resolve(lnurl) };
+        memo = entry;
+        entry.pr.catch(() => {
+          if (memo === entry) memo = void 0;
+        });
+        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() }
+      ),
+      async upgrade(upgradeOpts) {
+        const registered = await client.upgradeAddress({ token: held, handle, domain, ...upgradeOpts }).finally(wrote);
+        return receiverFrom(held, registered.handle, registered.lightningAddress, flagged);
+      }
+    };
+  };
+  return {
+    token,
+    capabilities: () => client.domainCapabilities({ domain }),
+    async owned() {
+      const held = await token();
+      const mine = (await client.listAddresses(held)).filter((a) => a.domain.toLowerCase() === domain.toLowerCase());
+      const active = mine.filter((a) => a.status === "active");
+      const chosen = active.find((a) => a.sessionLnurl !== null) ?? active[0] ?? mine[0];
+      return chosen ? receiverFrom(held, chosen.handle, chosen.lightningAddress, chosen.sessionLnurl !== null) : void 0;
+    },
+    async claim(claimOpts) {
+      const held = await token();
+      const registered = await client.registerAddress({
+        token: held,
+        domain,
+        ...claimOpts?.nameless ? { nameless: true } : {},
+        ...claimOpts?.username !== void 0 ? { username: claimOpts.username } : {},
+        ...claimOpts?.claimCode !== void 0 ? { claimCode: claimOpts.claimCode } : {}
+      }).finally(wrote);
+      const flagged = registered.sessionLnurl != null;
+      if (claimOpts?.nameless && !flagged) {
+        throw new LnurlError(
+          `server ignored nameless and registered "${registered.handle}"; it predates nameless receivers \u2014 revoke that address if unwanted`
+        );
+      }
+      await client.registerArkadeIdentity(
+        opts.hd ? { token: held, handle: registered.handle, domain, hd: opts.hd } : await arkadeIdentityRequest({
+          identity,
+          token: held,
+          handle: registered.handle,
+          domain,
+          ...await addresses()
+        })
+      ).finally(wrote);
+      return receiverFrom(held, registered.handle, registered.lightningAddress, flagged);
+    },
+    router,
+    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:";
+var SENT_GROUP_PREFIX = "sent:";
+var railOf = (p) => p.kind === "bolt11" ? "lightning" : p.paymentOption ?? "destination";
+function absorbedPaymentKey(activityId) {
+  return activityId.startsWith(LNURL_GROUP_PREFIX) ? activityId.slice(LNURL_GROUP_PREFIX.length) : void 0;
+}
+function mergeSentPayment(existing, incoming) {
+  const byTxid = new Map(existing.map((s) => [s.txid, s]));
+  byTxid.set(incoming.txid, { ...byTxid.get(incoming.txid), ...incoming });
+  return [...byTxid.values()];
+}
+function sentActivityResolver(sends) {
+  let byTxid = /* @__PURE__ */ new Map();
+  return {
+    id: SENT_RESOLVER_ID,
+    prepare: async () => {
+      byTxid = new Map(sends().filter((s) => s.txid).map((s) => [s.txid, s]));
+    },
+    resolve: (tx) => {
+      const sent = byTxid.get(tx.key.arkTxid);
+      if (!sent) return void 0;
+      return [{
+        groupId: `${SENT_GROUP_PREFIX}${sent.txid}`,
+        // The counterparty, not the rail: that is the question a sent row answers.
+        label: `\u2192 ${sent.target}`,
+        kind: "lnurl-send",
+        metadata: {
+          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 } : {},
+          ...sent.receiverConfirmed === void 0 ? {} : { receiver: sent.receiverConfirmed ? "confirmed settled" : "has not confirmed" }
+        }
+      }];
+    }
+  };
+}
+function lnurlActivityResolver(payments) {
+  let byTxid = /* @__PURE__ */ new Map();
+  return {
+    id: LNURL_RESOLVER_ID,
+    prepare: async () => {
+      byTxid = new Map(
+        payments().filter((p) => Boolean(p.payoutReference)).map((p) => [p.payoutReference, p])
+      );
+    },
+    resolve: (tx) => {
+      const payment = byTxid.get(tx.key.arkTxid);
+      if (!payment) return void 0;
+      return [{
+        groupId: `${LNURL_GROUP_PREFIX}${payment.key}`,
+        label: `${railOf(payment)} \xB7 ${payment.lightningAddress ?? "LNURL"}`,
+        kind: "lnurl",
+        metadata: {
+          rail: railOf(payment),
+          lightningAddress: payment.lightningAddress,
+          identifier: payment.identifier,
+          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 {
+    ArkAddress2.decode(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deriveSessionTokenForIdentity(identity, domain) {
+  return deriveSessionTokenWithSigner((message) => identity.signMessage(message, "ecdsa"), domain);
+}
+async function claimPublicKeyOf(identity) {
+  const key = await identity.compressedPublicKey();
+  if (key.length !== 33) {
+    throw new LnurlError(`expected a 33-byte compressed public key, got ${key.length} bytes`);
+  }
+  return hex2.encode(key);
+}
+async function arkadeIdentityRequest(params) {
+  if (!isArkadeAddress(params.arkadeAddress)) {
+    throw new LnurlError(`not a valid Arkade address: ${params.arkadeAddress}`);
+  }
+  return {
+    token: params.token,
+    handle: params.handle,
+    arkadeAddress: params.arkadeAddress,
+    claimPublicKey: await claimPublicKeyOf(params.identity),
+    ...params.boardingAddress !== void 0 ? { boardingAddress: params.boardingAddress } : {},
+    ...params.domain !== void 0 ? { domain: params.domain } : {}
+  };
+}
+export {
+  DEFAULT_RAIL_PRIORITY,
+  LNURL_ARKADE_RAIL,
+  LNURL_GROUP_PREFIX,
+  LNURL_LIGHTNING_RAIL,
+  LNURL_RESOLVER_ID,
+  SENT_GROUP_PREFIX,
+  SENT_RESOLVER_ID,
+  absorbedPaymentKey,
+  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
+};