lnurlcash-kit 0.1.0-next.0

package/dist/index.js

@@ -0,0 +1,708 @@
+import { bech32 } from '@scure/base';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { utf8ToBytes, bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+
+// src/urls.ts
+var isBech32Lnurl = (data) => data.trim().toUpperCase().startsWith("LNURL1");
+var toBech32Lnurl = (url) => {
+  const bytes = new TextEncoder().encode(url);
+  return bech32.encode("lnurl", bech32.toWords(bytes), 2048).toUpperCase();
+};
+var fromBech32Lnurl = (data) => {
+  const safe = data.trim().toUpperCase();
+  if (!safe.startsWith("LNURL1")) return null;
+  try {
+    const decoded = bech32.decode(
+      `LNURL1${safe.slice(6)}`,
+      2048
+    );
+    return new TextDecoder().decode(bech32.fromWords(decoded.words));
+  } catch {
+    return null;
+  }
+};
+var INSECURE_HOSTS = ["127.0.0.1", "0.0.0.0", "localhost"];
+var isInsecureHost = (host) => INSECURE_HOSTS.includes(host) || host.endsWith(".onion");
+var isAllowedServiceUrl = (value) => {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  if (url.protocol === "https:") return true;
+  if (url.protocol === "http:") return isInsecureHost(url.hostname);
+  return false;
+};
+var fromLud17 = (url) => {
+  const match = url.match(/^(?:lnurlw|lnurlp|lnurlc|keyauth):\/\/([^/]+)/i);
+  if (!match) return url;
+  const host = match[1].split(":")[0];
+  const scheme = isInsecureHost(host) ? "http" : "https";
+  return url.replace(/^[a-z]+:\/\//i, `${scheme}://`);
+};
+var toLud17w = (url) => url.replace(/^https?:\/\//, "lnurlw://");
+var isLightningAddress = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
+var lnAddressToUrl = (address) => {
+  const [name, domain] = address.trim().split("@");
+  const scheme = isInsecureHost(domain.split(":")[0]) ? "http" : "https";
+  return `${scheme}://${domain}/.well-known/lnurlp/${name}`;
+};
+var isBareMintDomain = (value) => {
+  const trimmed = value.trim();
+  if (isLightningAddress(trimmed)) return false;
+  if (/^@?[^\s@/]+\.[^\s@/]+$/.test(trimmed)) return true;
+  return isInsecureHost(trimmed.replace(/^@/, "").split(":")[0]);
+};
+var bareMintDomainToUrl = (value) => lnAddressToUrl(`mint@${value.trim().replace(/^@/, "")}`);
+var isLoopbackLightningAddress = (value) => {
+  const parts = value.trim().split("@");
+  if (parts.length !== 2) return false;
+  const [name, domain] = parts;
+  if (!name || !domain) return false;
+  return isInsecureHost(domain.split(":")[0]);
+};
+var resolveMintInput = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (isBech32Lnurl(trimmed)) {
+    const url = fromBech32Lnurl(trimmed);
+    return url && isAllowedServiceUrl(url) ? url : null;
+  }
+  if (isLightningAddress(trimmed)) return lnAddressToUrl(trimmed);
+  if (isLoopbackLightningAddress(trimmed)) return lnAddressToUrl(trimmed);
+  if (isBareMintDomain(trimmed)) return bareMintDomainToUrl(trimmed);
+  return null;
+};
+var LNURLP_PATH_RE = /^(.*\/\.well-known\/)lnurlp\/([^/]+)$/;
+var mintAddressUrl = (payUrl) => {
+  let parsed;
+  try {
+    parsed = new URL(payUrl);
+  } catch {
+    return null;
+  }
+  const match = parsed.pathname.match(LNURLP_PATH_RE);
+  if (!match) return null;
+  return `${parsed.origin}${match[1]}lnurlw/${match[2]}`;
+};
+var lightningAddressUsername = (payUrl) => {
+  try {
+    return new URL(payUrl).pathname.match(LNURLP_PATH_RE)?.[2] ?? null;
+  } catch {
+    return null;
+  }
+};
+var resolveLnurlInput = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (isBech32Lnurl(trimmed)) {
+    const url = fromBech32Lnurl(trimmed);
+    return url && isAllowedServiceUrl(url) ? url : null;
+  }
+  if (/^(lnurlw|lnurlp|lnurlc|keyauth):\/\//i.test(trimmed)) {
+    const url = fromLud17(trimmed);
+    return isAllowedServiceUrl(url) ? url : null;
+  }
+  if (isLightningAddress(trimmed)) return lnAddressToUrl(trimmed);
+  if (isLoopbackLightningAddress(trimmed)) return lnAddressToUrl(trimmed);
+  if (/^https?:\/\//i.test(trimmed)) {
+    return isAllowedServiceUrl(trimmed) ? trimmed : null;
+  }
+  return null;
+};
+var serverOf = (url) => {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+};
+var hashK1 = (k1) => bytesToHex(sha256(hexToBytes(k1)));
+var defaultRandomSecret = () => bytesToHex(crypto.getRandomValues(new Uint8Array(32)));
+var isPreimage = (value) => /^[0-9a-fA-F]{64}$/.test(value.trim());
+
+// src/note.ts
+var noteK1 = (url) => {
+  try {
+    return new URL(url).searchParams.get("k1")?.toLowerCase() ?? null;
+  } catch {
+    return null;
+  }
+};
+var requireNoteK1 = (url) => {
+  const k1 = noteK1(url);
+  if (!k1) {
+    throw new Error(
+      "This note carries no secret in its URL - it may be held on a device."
+    );
+  }
+  return k1;
+};
+var noteDeclaredAmount = (url) => {
+  try {
+    const raw = new URL(url).searchParams.get("amount");
+    if (raw === null) return null;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : null;
+  } catch {
+    return null;
+  }
+};
+var noteSignature = (url) => {
+  try {
+    return new URL(url).searchParams.get("sig");
+  } catch {
+    return null;
+  }
+};
+var resolveNoteInput = (value) => {
+  const url = resolveLnurlInput(value);
+  const k1 = url ? noteK1(url) : null;
+  if (!url || !k1 || !isPreimage(k1)) return null;
+  return url;
+};
+var isValidNoteInput = (value) => resolveNoteInput(value) !== null;
+var buildNoteUrl = (withdrawLink, k1, amountMsat) => {
+  const url = new URL(fromLud17(withdrawLink.trim()));
+  url.searchParams.set("k1", k1.trim().toLowerCase());
+  if (amountMsat !== void 0) {
+    url.searchParams.set("amount", String(amountMsat));
+  }
+  return url.toString();
+};
+var withNewK1 = (url, k1, amountMsat, signature) => {
+  const newUrl = new URL(url);
+  newUrl.searchParams.set("k1", k1.toLowerCase());
+  newUrl.searchParams.set("amount", String(amountMsat));
+  if (signature) newUrl.searchParams.set("sig", signature);
+  else newUrl.searchParams.delete("sig");
+  return newUrl.toString();
+};
+var withoutK1 = (url, amountMsat, signature) => {
+  const newUrl = new URL(url);
+  newUrl.searchParams.delete("k1");
+  newUrl.searchParams.set("amount", String(amountMsat));
+  if (signature) newUrl.searchParams.set("sig", signature);
+  else newUrl.searchParams.delete("sig");
+  return newUrl.toString();
+};
+var LIGHTNING_SIGNED_MESSAGE_PREFIX = utf8ToBytes("Lightning Signed Message:");
+var noteSignatureMessage = (k1, amountMsat) => `LNURLcash:${amountMsat}:${hashK1(k1)}`;
+var noteSignatureDigest = (k1, amountMsat) => sha256(
+  sha256(
+    new Uint8Array([
+      ...LIGHTNING_SIGNED_MESSAGE_PREFIX,
+      ...utf8ToBytes(noteSignatureMessage(k1, amountMsat))
+    ])
+  )
+);
+var verifyNoteSignature = (k1, amountMsat, signatureHex, mintPubkeyHex) => {
+  let wireSig;
+  try {
+    wireSig = hexToBytes(signatureHex);
+  } catch {
+    return false;
+  }
+  if (wireSig.length !== 65) return false;
+  let digest;
+  try {
+    digest = noteSignatureDigest(k1, amountMsat);
+  } catch {
+    return false;
+  }
+  const target = mintPubkeyHex.trim().toLowerCase();
+  const recoveryIdFirst = new Uint8Array([
+    wireSig[64],
+    ...wireSig.subarray(0, 64)
+  ]);
+  for (const candidate of [recoveryIdFirst, wireSig]) {
+    try {
+      const recovered = secp256k1.recoverPublicKey(candidate, digest, {
+        prehash: false
+      });
+      if (bytesToHex(recovered) === target) return true;
+    } catch {
+    }
+  }
+  return false;
+};
+
+// src/fees.ts
+var parseMintFee = (metadata) => {
+  let entries;
+  try {
+    entries = JSON.parse(metadata);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(entries)) return null;
+  for (const entry of entries) {
+    if (!Array.isArray(entry) || entry[0] !== "text/plain") continue;
+    const match = typeof entry[1] === "string" && entry[1].match(/^Mint fees:\s*(\d+)\s*,\s*(\d+)\s*$/);
+    if (!match) continue;
+    const baseFeeMsat = Number(match[1]);
+    const feePpm = Number(match[2]);
+    if (!Number.isSafeInteger(baseFeeMsat) || !Number.isSafeInteger(feePpm)) continue;
+    if (feePpm >= 1e6) continue;
+    if (baseFeeMsat === 0 && feePpm === 0) return null;
+    return { baseFeeMsat, feePpm };
+  }
+  return null;
+};
+var proportionalFee = (grossMsat, feePpm) => Math.floor(grossMsat / 1e6) * feePpm + Math.floor(grossMsat % 1e6 * feePpm / 1e6);
+var applyMintFee = (grossMsat, fee) => Math.max(0, grossMsat - fee.baseFeeMsat - proportionalFee(grossMsat, fee.feePpm));
+var grossUpForMintFee = (netMsat, fee) => {
+  if (netMsat <= 0) return 0;
+  let hi = netMsat + fee.baseFeeMsat;
+  while (applyMintFee(hi, fee) < netMsat) hi *= 2;
+  let lo = 0;
+  while (lo < hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (applyMintFee(mid, fee) >= netMsat) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+};
+var formatFeePercent = (ppm) => (ppm / 1e4).toFixed(4).replace(/\.?0+$/, "");
+var describeMintFee = (fee) => [
+  fee.baseFeeMsat > 0 ? `${Math.round(fee.baseFeeMsat / 1e3)} sat flat` : null,
+  fee.feePpm > 0 ? `${formatFeePercent(fee.feePpm)}% of the amount paid` : null
+].filter(Boolean).join(" + ");
+
+// src/bolt11.ts
+var isBolt11Invoice = (value) => /^ln(bc|tb|bcrt|tbs|sb)[0-9]*[munp]?1[a-z0-9]+$/.test(
+  value.trim().toLowerCase()
+);
+var sameInvoice = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+var BOLT11_AMOUNT_MSAT_PER_UNIT = {
+  "": 1e11,
+  m: 1e8,
+  u: 1e5,
+  n: 100,
+  p: 0.1
+};
+var decodeBolt11AmountMsat = (pr) => {
+  const trimmed = pr.trim().toLowerCase();
+  const sep = trimmed.lastIndexOf("1");
+  if (sep < 2) return null;
+  const hrp = trimmed.slice(0, sep);
+  const match = hrp.match(/^ln(?:bc|tb|bcrt|tbs|sb)(\d+)?([munp])?$/);
+  if (!match) return null;
+  const [, digits, multiplier] = match;
+  if (!digits) return null;
+  const msat = Number(digits) * BOLT11_AMOUNT_MSAT_PER_UNIT[multiplier || ""];
+  return Number.isInteger(msat) ? msat : null;
+};
+
+// src/errors.ts
+var LnurlcashError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var RequestRefusedError = class extends LnurlcashError {
+};
+var ProtocolError = class extends LnurlcashError {
+};
+var ServiceRejectedError = class extends LnurlcashError {
+  reason;
+  constructor(reason) {
+    super(reason || "The service rejected the request.");
+    this.reason = reason;
+  }
+};
+var PendingNoteError = class extends ServiceRejectedError {
+  constructor(reason = "pending") {
+    super(reason);
+    this.message = "This note has another operation in progress - try again in a moment.";
+  }
+};
+var NoteSpentError = class extends ServiceRejectedError {
+  constructor(reason) {
+    super(reason);
+    this.message = `This note has already been spent (service says: "${reason}").`;
+  }
+};
+var NoteUnknownError = class extends ServiceRejectedError {
+  constructor(reason) {
+    super(reason);
+    this.message = `The service doesn't recognise this note (service says: "${reason}").`;
+  }
+};
+var AmbiguousMintError = class extends LnurlcashError {
+};
+var AmbiguousMutationError = class extends AmbiguousMintError {
+  newSecrets;
+  constructor(message, newSecrets) {
+    super(message);
+    this.newSecrets = newSecrets;
+  }
+};
+var classifyNoteError = (reason) => {
+  if (/spent/i.test(reason)) return new NoteSpentError(reason);
+  if (/unknown|not found/i.test(reason)) return new NoteUnknownError(reason);
+  return new ServiceRejectedError(reason);
+};
+
+// src/transport.ts
+var resolveOptions = (options = {}) => ({
+  // Wrapped, never referenced bare: in a browser window.fetch is a method
+  // that demands its receiver, and calling a detached copy throws
+  // 'Illegal invocation'. Node and DOM test environments never enforce
+  // that, so only a REAL browser catches the bare form - the worst
+  // possible place to find out.
+  fetch: options.fetch ?? ((...args) => globalThis.fetch(...args)),
+  timeoutMs: options.timeoutMs ?? 3e4,
+  offline: options.offline ?? false,
+  randomSecret: options.randomSecret ?? defaultRandomSecret
+});
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var MAX_REDIRECTS = 5;
+var MAX_BODY_BYTES = 1048576;
+var fetchFollowingRedirects = async (startUrl, options) => {
+  let current = startUrl;
+  for (let redirects = 0; ; redirects++) {
+    let res;
+    try {
+      res = await options.fetch(current, {
+        signal: AbortSignal.timeout(options.timeoutMs),
+        redirect: "manual"
+      });
+    } catch (err) {
+      if (err.name === "TimeoutError") {
+        throw new AmbiguousMintError(
+          "The service took too long to respond - its answer, if any, was lost."
+        );
+      }
+      throw new AmbiguousMintError(
+        "Failed to reach the service - it may be offline, or may not allow cross-origin requests."
+      );
+    }
+    const location = res.headers.get("location");
+    if (!REDIRECT_STATUSES.has(res.status) || !location) return res;
+    if (redirects >= MAX_REDIRECTS) {
+      throw new AmbiguousMintError("The service redirected too many times.");
+    }
+    let next;
+    try {
+      next = new URL(location, current).toString();
+    } catch {
+      next = null;
+    }
+    if (!next || !isAllowedServiceUrl(next)) {
+      throw new AmbiguousMintError(
+        "The service tried to redirect somewhere this library will not fetch - the original request may already have been processed."
+      );
+    }
+    current = next;
+  }
+};
+var readBodyText = async (res) => {
+  const declared = Number(res.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
+    throw new AmbiguousMintError("The service returned an oversized response.");
+  }
+  if (!res.body) return "";
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > MAX_BODY_BYTES) {
+      await reader.cancel().catch(() => {
+      });
+      throw new AmbiguousMintError("The service returned an oversized response.");
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+};
+var lnurlFetch = async (url, options) => {
+  if (options.offline) {
+    throw new RequestRefusedError(
+      "Offline mode is on - no request was made."
+    );
+  }
+  if (!isAllowedServiceUrl(url.toString())) {
+    throw new RequestRefusedError(
+      "Refusing to fetch that URL - only https, or http to a loopback or .onion host, is allowed."
+    );
+  }
+  const res = await fetchFollowingRedirects(url.toString(), options);
+  const text = await readBodyText(res);
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    throw new AmbiguousMintError("The service returned an unreadable response.");
+  }
+  if (body?.status === "ERROR") {
+    throw new ServiceRejectedError(
+      typeof body.reason === "string" ? body.reason : ""
+    );
+  }
+  return body;
+};
+
+// src/client.ts
+var fetchNoteInfo = async (url, options = {}) => {
+  const opts = resolveOptions(options);
+  const reqUrl = new URL(url);
+  reqUrl.searchParams.delete("sig");
+  let body;
+  try {
+    body = await lnurlFetch(reqUrl, opts);
+  } catch (err) {
+    if (err instanceof ServiceRejectedError) throw classifyNoteError(err.reason);
+    throw err;
+  }
+  if (body?.tag !== "withdrawRequest" || typeof body.callback !== "string" || typeof body.k1 !== "string" || typeof body.maxWithdrawable !== "number" || !Number.isSafeInteger(body.maxWithdrawable) || body.maxWithdrawable < 0 || body.minWithdrawable !== void 0 && (typeof body.minWithdrawable !== "number" || !Number.isSafeInteger(body.minWithdrawable) || body.minWithdrawable < 0 || body.minWithdrawable > body.maxWithdrawable)) {
+    throw new ProtocolError("Not a withdrawRequest (unexpected response).");
+  }
+  const queried = noteK1(url);
+  if (queried && body.k1.toLowerCase() !== queried) {
+    throw new ProtocolError(
+      "The service echoed back a different k1 than was queried - the note may have been redeemed elsewhere, or the service isn't spec-compliant."
+    );
+  }
+  return body;
+};
+var probeBurnedNote = async (url, options = {}) => {
+  try {
+    await fetchNoteInfo(url, options);
+    return "live";
+  } catch (err) {
+    if (err instanceof NoteSpentError || err instanceof NoteUnknownError) {
+      return "gone";
+    }
+    return "unknown";
+  }
+};
+var fetchMintAddress = async (url, options = {}) => {
+  const body = await lnurlFetch(url, resolveOptions(options));
+  if (body?.tag !== "withdrawRequest" || typeof body.callback !== "string" || typeof body.payLink !== "string" || typeof body.maxWithdrawable !== "number") {
+    throw new ProtocolError("Not a mint address response (unexpected shape).");
+  }
+  const { mintPubkey, ...rest } = body;
+  return { ...rest, nodePubkey: mintPubkey };
+};
+var callbackRequest = async (callback, params, options) => {
+  const opts = resolveOptions(options);
+  let cbUrl;
+  try {
+    cbUrl = new URL(callback);
+  } catch {
+    throw new RequestRefusedError("The service provided an invalid callback URL.");
+  }
+  if (!params.some(([key]) => key === "k1")) {
+    throw new RequestRefusedError(
+      "At least one k1 is required - there is no note to operate on."
+    );
+  }
+  for (const [key, value] of params) cbUrl.searchParams.append(key, value);
+  let body;
+  try {
+    body = await lnurlFetch(cbUrl, opts);
+  } catch (err) {
+    if (err instanceof ServiceRejectedError) {
+      if (err.reason === "pending") throw new PendingNoteError(err.reason);
+      throw classifyNoteError(err.reason);
+    }
+    throw err;
+  }
+  if (body?.status !== "OK") {
+    throw new AmbiguousMintError(
+      "The service did not confirm the operation - it may still have been applied."
+    );
+  }
+  return body;
+};
+var meltNote = async (callback, k1, pr, options = {}) => {
+  const body = await callbackRequest(
+    callback,
+    [
+      ["k1", k1],
+      ["pr", pr.trim()]
+    ],
+    options
+  );
+  return {
+    verify: body.verify,
+    pr: typeof body.pr === "string" ? body.pr : void 0
+  };
+};
+var rotateNoteWithHash = async (callback, k1, h, options = {}) => {
+  const body = await callbackRequest(
+    callback,
+    [
+      ["k1", k1],
+      ["h", h]
+    ],
+    options
+  );
+  return { signature: body.sig };
+};
+var splitNoteWithHash = async (callback, k1s, amountMsat, h, h2, options = {}) => {
+  const body = await callbackRequest(
+    callback,
+    [
+      ...k1s.map((k1) => ["k1", k1]),
+      ["amount", String(amountMsat)],
+      ["h", h],
+      ["h2", h2]
+    ],
+    options
+  );
+  return { signature: body.sig, changeSignature: body.sig2 };
+};
+var mergeNotesWithHash = async (callback, k1s, h, options = {}) => {
+  const body = await callbackRequest(
+    callback,
+    [...k1s.map((k1) => ["k1", k1]), ["h", h]],
+    options
+  );
+  return { signature: body.sig };
+};
+var rotateNote = async (callback, k1, options = {}) => {
+  const opts = resolveOptions(options);
+  const newK1 = opts.randomSecret();
+  try {
+    const result = await rotateNoteWithHash(callback, k1, hashK1(newK1), options);
+    return { k1: newK1, signature: result.signature };
+  } catch (err) {
+    if (err instanceof AmbiguousMintError) {
+      throw new AmbiguousMutationError(err.message, [newK1]);
+    }
+    throw err;
+  }
+};
+var splitNote = async (callback, k1s, amountMsat, options = {}) => {
+  const opts = resolveOptions(options);
+  const newK1 = opts.randomSecret();
+  const changeK1 = opts.randomSecret();
+  try {
+    const result = await splitNoteWithHash(
+      callback,
+      k1s,
+      amountMsat,
+      hashK1(newK1),
+      hashK1(changeK1),
+      options
+    );
+    return {
+      k1: newK1,
+      signature: result.signature,
+      change: changeK1,
+      changeSignature: result.changeSignature
+    };
+  } catch (err) {
+    if (err instanceof AmbiguousMintError) {
+      throw new AmbiguousMutationError(err.message, [newK1, changeK1]);
+    }
+    throw err;
+  }
+};
+var mergeNotes = async (callback, k1s, options = {}) => {
+  const opts = resolveOptions(options);
+  const newK1 = opts.randomSecret();
+  try {
+    const result = await mergeNotesWithHash(callback, k1s, hashK1(newK1), options);
+    return { k1: newK1, signature: result.signature };
+  } catch (err) {
+    if (err instanceof AmbiguousMintError) {
+      throw new AmbiguousMutationError(err.message, [newK1]);
+    }
+    throw err;
+  }
+};
+var settleNote = async (baseUrl, k1, expectedAmountMsat, signature, options = {}) => {
+  const info = await fetchNoteInfo(
+    withNewK1(baseUrl, k1, expectedAmountMsat, signature),
+    options
+  );
+  try {
+    const rotated = await rotateNote(info.callback, k1, options);
+    return {
+      k1: rotated.k1,
+      amountMsat: info.maxWithdrawable,
+      signature: rotated.signature,
+      callback: info.callback
+    };
+  } catch {
+    return {
+      k1,
+      amountMsat: info.maxWithdrawable,
+      signature,
+      callback: info.callback
+    };
+  }
+};
+var fetchPayRequest = async (url, options = {}) => {
+  const body = await lnurlFetch(url, resolveOptions(options));
+  if (body?.tag !== "payRequest" || typeof body.callback !== "string") {
+    throw new ProtocolError("Not a payRequest (unexpected response).");
+  }
+  const mintFee = typeof body.metadata === "string" ? parseMintFee(body.metadata) : null;
+  return { ...body, mintFee: mintFee ?? void 0 };
+};
+var requestInvoice = async (payCallback, amountMsat, options = {}) => {
+  const cbUrl = new URL(payCallback);
+  cbUrl.searchParams.set("amount", String(amountMsat));
+  const body = await lnurlFetch(cbUrl, resolveOptions(options));
+  if (typeof body?.pr !== "string") {
+    throw new ProtocolError("The service did not return an invoice.");
+  }
+  const invoiceMsat = decodeBolt11AmountMsat(body.pr);
+  if (invoiceMsat !== null && invoiceMsat !== amountMsat) {
+    throw new ProtocolError(
+      `The service returned an invoice for ${invoiceMsat} msat, not the ${amountMsat} requested.`
+    );
+  }
+  return {
+    pr: body.pr,
+    verify: typeof body.verify === "string" ? body.verify : void 0,
+    disposable: body.disposable !== false
+  };
+};
+var fetchInvoiceVerification = async (verifyUrl, options = {}) => {
+  const body = await lnurlFetch(verifyUrl, resolveOptions(options));
+  if (typeof body?.settled !== "boolean" || typeof body?.pr !== "string") {
+    throw new ProtocolError("The service returned an unexpected verify response.");
+  }
+  return {
+    settled: body.settled,
+    preimage: typeof body.preimage === "string" ? body.preimage : null,
+    pr: body.pr
+  };
+};
+
+// src/index.ts
+var createClient = (options = {}) => ({
+  fetchNoteInfo: (url) => fetchNoteInfo(url, options),
+  probeBurnedNote: (url) => probeBurnedNote(url, options),
+  fetchMintAddress: (url) => fetchMintAddress(url, options),
+  meltNote: (callback, k1, pr) => meltNote(callback, k1, pr, options),
+  rotateNote: (callback, k1) => rotateNote(callback, k1, options),
+  rotateNoteWithHash: (callback, k1, h) => rotateNoteWithHash(callback, k1, h, options),
+  splitNote: (callback, k1s, amountMsat) => splitNote(callback, k1s, amountMsat, options),
+  splitNoteWithHash: (callback, k1s, amountMsat, h, h2) => splitNoteWithHash(callback, k1s, amountMsat, h, h2, options),
+  mergeNotes: (callback, k1s) => mergeNotes(callback, k1s, options),
+  mergeNotesWithHash: (callback, k1s, h) => mergeNotesWithHash(callback, k1s, h, options),
+  settleNote: (baseUrl, k1, expectedAmountMsat, signature) => settleNote(baseUrl, k1, expectedAmountMsat, signature, options),
+  fetchPayRequest: (url) => fetchPayRequest(url, options),
+  requestInvoice: (payCallback, amountMsat) => requestInvoice(payCallback, amountMsat, options),
+  fetchInvoiceVerification: (verifyUrl) => fetchInvoiceVerification(verifyUrl, options)
+});
+
+export { AmbiguousMintError, AmbiguousMutationError, LnurlcashError, NoteSpentError, NoteUnknownError, PendingNoteError, ProtocolError, RequestRefusedError, ServiceRejectedError, applyMintFee, buildNoteUrl, classifyNoteError, createClient, decodeBolt11AmountMsat, defaultRandomSecret, describeMintFee, fetchInvoiceVerification, fetchMintAddress, fetchNoteInfo, fetchPayRequest, formatFeePercent, fromBech32Lnurl, fromLud17, grossUpForMintFee, hashK1, isAllowedServiceUrl, isBech32Lnurl, isBolt11Invoice, isLightningAddress, isPreimage, isValidNoteInput, lightningAddressUsername, meltNote, mergeNotes, mergeNotesWithHash, mintAddressUrl, noteDeclaredAmount, noteK1, noteSignature, noteSignatureDigest, noteSignatureMessage, parseMintFee, probeBurnedNote, requestInvoice, requireNoteK1, resolveLnurlInput, resolveMintInput, resolveNoteInput, rotateNote, rotateNoteWithHash, sameInvoice, serverOf, settleNote, splitNote, splitNoteWithHash, toBech32Lnurl, toLud17w, verifyNoteSignature, withNewK1, withoutK1 };