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

package/dist/arkade.js

@@ -0,0 +1,357 @@
+import {
+  LnurlError,
+  createLnurlClient,
+  deriveSessionId,
+  deriveSessionTokenWithSigner,
+  syncPayments
+} from "./chunk-YKBY6NCA.js";
+
+// packages/client/src/arkade.ts
+import { ArkAddress } from "@arkade-os/sdk";
+import { hex } 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 (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);
+      if (req.amount === void 0) 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,
+        ...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 };
+      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 };
+      return { ...quote, railId: id, meta: { ...quote.meta, lnurl } };
+    }
+  };
+}
+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 () => wallet ? { arkadeAddress: await wallet.getAddress(), boardingAddress: await wallet.getBoardingAddress() } : { 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 }),
+      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(
+        await arkadeIdentityRequest({
+          identity,
+          token: held,
+          handle: registered.handle,
+          domain,
+          ...await addresses()
+        })
+      ).finally(wrote);
+      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 })
+  };
+}
+
+// packages/client/src/activity.ts
+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.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
+        }
+      }];
+    }
+  };
+}
+
+// packages/client/src/arkade.ts
+function isArkadeAddress(address) {
+  try {
+    ArkAddress.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 hex.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,
+  claimPublicKeyOf,
+  deriveSessionTokenForIdentity,
+  encodeLnurl,
+  isArkadeAddress,
+  lnurlActivityResolver,
+  lnurlQuoteMeta,
+  lnurlRails,
+  mergeSentPayment,
+  railOf,
+  sentActivityResolver
+};