@lnurlcash/kit 0.14.0-rc.0

package/dist/index.js

@@ -0,0 +1,1231 @@
+import { bech32, bech32m } from '@scure/base';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { utf8ToBytes, bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
+import { schnorr, secp256k1 } from '@noble/curves/secp256k1.js';
+
+// errors.ts
+var AmbiguousMintError = class extends Error {
+};
+var AmbiguousMutationError = class extends AmbiguousMintError {
+  newSecrets;
+  constructor(message, newSecrets) {
+    super(message);
+    this.newSecrets = newSecrets;
+  }
+};
+var ServiceError = class extends Error {
+  reason;
+  constructor(reason) {
+    super(reason || "The service rejected the request without saying why.");
+    this.reason = reason;
+    this.name = "ServiceError";
+  }
+};
+var PendingNoteError = class extends Error {
+  constructor() {
+    super(
+      "This note has another operation in progress - try again in a moment."
+    );
+    this.name = "PendingNoteError";
+  }
+};
+var NoteSpentError = class extends Error {
+  constructor(reason) {
+    super(`This note has already been spent (service says: "${reason}").`);
+    this.name = "NoteSpentError";
+  }
+};
+var NoteUnknownError = class extends Error {
+  constructor(reason) {
+    super(
+      `The service doesn't recognize this note (service says: "${reason}").`
+    );
+    this.name = "NoteUnknownError";
+  }
+};
+var classifyNoteError = (err) => {
+  if (!(err instanceof ServiceError)) return err;
+  const reason = err.reason;
+  if (/spent/i.test(reason)) return new NoteSpentError(reason);
+  if (/unknown|not found/i.test(reason)) return new NoteUnknownError(reason);
+  return err;
+};
+var sameInvoice = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+var isPreimage = (value) => /^[0-9a-fA-F]{64}$/.test(value.trim());
+var isBolt11Invoice = (value) => /^ln(bc|tb|bcrt|tbs|sb)[0-9]*[munp]?1[a-z0-9]+$/.test(
+  value.trim().toLowerCase()
+);
+var BOLT11_AMOUNT_MSAT_PER_UNIT = {
+  "": 1e11,
+  m: 1e8,
+  u: 1e5,
+  n: 100,
+  p: 0.1
+};
+var encodeBolt11AmountSuffix = (amountMsat) => {
+  if (!Number.isInteger(amountMsat) || amountMsat < 0) {
+    throw new Error("amount_msat must be a non-negative integer.");
+  }
+  for (const multiplier of ["", "m", "u", "n", "p"]) {
+    const digits = amountMsat / BOLT11_AMOUNT_MSAT_PER_UNIT[multiplier];
+    if (Number.isInteger(digits)) return `${digits}${multiplier}`;
+  }
+  throw new Error("amount_msat could not be encoded.");
+};
+var decodeBolt11AmountSuffix = (suffix) => {
+  const match = suffix.match(/^(\d+)([munp])?$/);
+  if (!match) return null;
+  const [, digits, multiplier] = match;
+  const msat = Number(digits) * BOLT11_AMOUNT_MSAT_PER_UNIT[multiplier ?? ""];
+  return Number.isSafeInteger(msat) ? msat : null;
+};
+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;
+};
+var BOLT11_TAG_PAYMENT_HASH = 1;
+var decodeBolt11PaymentHash = (pr) => {
+  const trimmed = pr.trim().toLowerCase();
+  try {
+    const decoded = bech32.decode(trimmed, 2048);
+    const words = decoded.words;
+    const fieldsEnd = words.length - 104;
+    let pos = 7;
+    while (pos + 3 <= fieldsEnd) {
+      const tag = words[pos];
+      const len = words[pos + 1] * 32 + words[pos + 2];
+      const start = pos + 3;
+      const end = start + len;
+      if (end > fieldsEnd) break;
+      if (tag === BOLT11_TAG_PAYMENT_HASH && len === 52) {
+        return bytesToHex(
+          bech32.fromWords(words.slice(start, end)).slice(0, 32)
+        );
+      }
+      pos = end;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var verifyMeltPreimage = (pr, preimage) => {
+  if (!isPreimage(preimage)) return false;
+  const expected = decodeBolt11PaymentHash(pr);
+  if (!expected) return false;
+  return bytesToHex(sha256(hexToBytes(preimage))) === expected;
+};
+var encodeFixed = (hrp, bytes, length) => {
+  if (bytes.length !== length) {
+    throw new Error(`${hrp}1... payload must be exactly ${length} bytes`);
+  }
+  return bech32m.encode(hrp, bech32m.toWords(bytes), false);
+};
+var decodeFixed = (hrp, value, length) => {
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed.startsWith(`${hrp}1`)) return null;
+  try {
+    const decoded = bech32m.decode(trimmed, false);
+    if (decoded.prefix !== hrp) return null;
+    const bytes = bech32m.fromWords(decoded.words);
+    return bytes.length === length ? bytes : null;
+  } catch {
+    return null;
+  }
+};
+var encodeCp1 = (pubkeyXOnly) => encodeFixed("cp", pubkeyXOnly, 32);
+var decodeCp1 = (value) => decodeFixed("cp", value, 32);
+var isCp1 = (value) => decodeCp1(value) !== null;
+var encodeCk1 = (signature) => encodeFixed("ck", signature, 65);
+var decodeCk1 = (value) => decodeFixed("ck", value, 65);
+var isCk1 = (value) => decodeCk1(value) !== null;
+var encodeCs1 = (signature) => encodeFixed("cs", signature, 65);
+var decodeCs1 = (value) => decodeFixed("cs", value, 65);
+var isCs1 = (value) => decodeCs1(value) !== null;
+var encodeCs1WithAmount = (amountMsat, signature) => encodeFixed(`cs${encodeBolt11AmountSuffix(amountMsat)}`, signature, 65);
+var decodeCs1WithAmount = (value) => {
+  const trimmed = value.trim().toLowerCase();
+  const sep = trimmed.lastIndexOf("1");
+  if (sep < 2 || !trimmed.slice(0, sep).startsWith("cs")) return null;
+  const amountMsat = decodeBolt11AmountSuffix(trimmed.slice(2, sep));
+  if (amountMsat === null) return null;
+  const signature = decodeFixed(trimmed.slice(0, sep), trimmed, 65);
+  return signature ? { amountMsat, signature } : null;
+};
+var isCs1WithAmount = (value) => decodeCs1WithAmount(value) !== null;
+var decodeAnyCs1 = (value) => decodeCs1WithAmount(value)?.signature ?? decodeCs1(value);
+var isAnyCs1 = (value) => isCs1WithAmount(value) || isCs1(value);
+var encodeCx1 = (pubkeyXOnly, chainCode) => encodeFixed("cx", new Uint8Array([...pubkeyXOnly, ...chainCode]), 64);
+var decodeCx1 = (value) => {
+  const bytes = decodeFixed("cx", value, 64);
+  if (!bytes) return null;
+  return { pubkeyXOnly: bytes.slice(0, 32), chainCode: bytes.slice(32) };
+};
+var isCx1 = (value) => decodeCx1(value) !== null;
+var NOTE_DERIVE_TAG = "LNURLcash/derive";
+var ser32BE = (index) => {
+  const bytes = new Uint8Array(4);
+  new DataView(bytes.buffer).setUint32(0, index, false);
+  return bytes;
+};
+var bytesToNumberBE = (bytes) => BigInt(`0x${bytesToHex(bytes)}`);
+var numberToBytesBE = (n, length) => hexToBytes(n.toString(16).padStart(length * 2, "0"));
+var CURVE_ORDER = schnorr.Point.CURVE().n;
+var tweakScalar = (branchPubkeyXOnly, chainCode, index) => {
+  const t = schnorr.utils.taggedHash(
+    NOTE_DERIVE_TAG,
+    branchPubkeyXOnly,
+    chainCode,
+    ser32BE(index)
+  );
+  return bytesToNumberBE(t) % CURVE_ORDER;
+};
+var deriveNotePubkey = (branchPubkeyXOnly, chainCode, index) => {
+  const t = tweakScalar(branchPubkeyXOnly, chainCode, index);
+  const branchPoint = schnorr.utils.lift_x(bytesToNumberBE(branchPubkeyXOnly));
+  const notePoint = branchPoint.add(schnorr.Point.BASE.multiply(t));
+  return schnorr.utils.pointToBytes(notePoint);
+};
+var deriveNoteSecretKey = (branchPrivateKey, chainCode, index) => {
+  const branchPubkeyXOnly = schnorr.getPublicKey(branchPrivateKey);
+  const t = tweakScalar(branchPubkeyXOnly, chainCode, index);
+  const rawScalar = bytesToNumberBE(branchPrivateKey);
+  const branchFullPoint = schnorr.Point.BASE.multiply(rawScalar);
+  const evenYScalar = branchFullPoint.y % 2n === 0n ? rawScalar : (CURVE_ORDER - rawScalar) % CURVE_ORDER;
+  const noteScalar = (evenYScalar + t) % CURVE_ORDER;
+  return numberToBytesBE(noteScalar, 32);
+};
+
+// 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 defaultSchemeFor = (hostish) => isInsecureHost(hostish.split("/")[0].split(":")[0]) ? "http" : "https";
+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;
+  return url.replace(/^[a-z]+:\/\//i, `${defaultSchemeFor(match[1])}://`);
+};
+var toLud17w = (url) => url.replace(/^https?:\/\//, "lnurlw://");
+var isLightningAddress = (value) => {
+  const trimmed = value.trim();
+  const at = trimmed.indexOf("@");
+  if (at <= 0 || at === trimmed.length - 1) return false;
+  if (trimmed.indexOf("@", at + 1) !== -1) return false;
+  const domain = trimmed.slice(at + 1);
+  if (/\s/.test(trimmed)) return false;
+  if (/^[^\s@]+\.[^\s@]+$/.test(domain)) return true;
+  return isInsecureHost(domain.split(":")[0]);
+};
+var lnAddressToUrl = (address) => {
+  const [name, domain] = address.trim().split("@");
+  return `${defaultSchemeFor(domain)}://${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 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 (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().replace(/^lightning:/i, "");
+  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 (/^https?:\/\//i.test(trimmed)) {
+    return isAllowedServiceUrl(trimmed) ? trimmed : null;
+  }
+  return null;
+};
+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 has no secret in the browser. If it is marked "on device", reconnect the vault before refreshing or spending it.'
+    );
+  }
+  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 isValidK1 = (value) => isPreimage(value) || isCk1(value);
+var resolveNoteInput = (value) => {
+  const url = resolveLnurlInput(value);
+  const k1 = url ? noteK1(url) : null;
+  if (!url || !k1 || !isValidK1(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);
+  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 withoutSignature = (url) => {
+  const newUrl = new URL(url);
+  newUrl.searchParams.delete("sig");
+  return newUrl.toString();
+};
+var serverOf = (url) => {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+};
+var serviceOriginOf = (value) => {
+  const expanded = fromLud17(value.trim());
+  try {
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(expanded) && !/^https?:\/\//i.test(expanded)) {
+      return "";
+    }
+    const candidate = /^https?:\/\//i.test(expanded) ? expanded : `${defaultSchemeFor(expanded)}://${expanded}`;
+    return isAllowedServiceUrl(candidate) ? new URL(candidate).origin : "";
+  } catch {
+    return "";
+  }
+};
+var noteEndpointOf = (url) => {
+  try {
+    const parsed = new URL(fromLud17(url.trim()));
+    const path = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
+    return `${parsed.host}${path}`;
+  } catch {
+    return serverOf(url);
+  }
+};
+var MINT_PUBKEY_PATTERN = /^0[23][0-9a-f]{64}$/i;
+var NOTE_SIGNATURE_PATTERN = /^[0-9a-f]{130}$/i;
+var parseMintKey = (body) => {
+  if (typeof body?.mintPubkey !== "string" || !MINT_PUBKEY_PATTERN.test(body.mintPubkey)) {
+    throw new Error(
+      "SERVICE did not publish a valid persistent signing key (mintPubkey)."
+    );
+  }
+  return { mintPubkey: body.mintPubkey.toLowerCase() };
+};
+var hashK1 = (k1) => bytesToHex(sha256(hexToBytes(k1)));
+var LIGHTNING_SIGNED_MESSAGE_PREFIX = utf8ToBytes("Lightning Signed Message:");
+var noteSignatureDigestForHash = (h, amountMsat) => {
+  if (!/^[0-9a-fA-F]{64}$/.test(h.trim())) {
+    throw new Error("A note hash must be 32 bytes of hex.");
+  }
+  const message = utf8ToBytes(
+    `LNURLcash:${amountMsat}:${h.trim().toLowerCase()}`
+  );
+  return sha256(
+    sha256(new Uint8Array([...LIGHTNING_SIGNED_MESSAGE_PREFIX, ...message]))
+  );
+};
+var noteSignatureDigest = (k1, amountMsat) => noteSignatureDigestForHash(hashK1(k1), amountMsat);
+var normalizeSignatureHex = (signature) => {
+  if (NOTE_SIGNATURE_PATTERN.test(signature)) return signature.toLowerCase();
+  const decoded = decodeAnyCs1(signature);
+  return decoded ? bytesToHex(decoded) : null;
+};
+var verifyNoteSignatureDigest = (digest, signature, mintPubkeyHex) => {
+  const signatureHex = normalizeSignatureHex(signature);
+  if (!signatureHex) return false;
+  let wireSig;
+  try {
+    wireSig = hexToBytes(signatureHex);
+  } catch {
+    return false;
+  }
+  if (wireSig.length !== 65) return false;
+  const target = mintPubkeyHex.toLowerCase();
+  const trailing = new Uint8Array([wireSig[64], ...wireSig.subarray(0, 64)]);
+  const leading = wireSig;
+  for (const candidate of [trailing, leading]) {
+    try {
+      const recovered = secp256k1.recoverPublicKey(candidate, digest, {
+        prehash: false
+      });
+      if (bytesToHex(recovered) === target) return true;
+    } catch {
+    }
+  }
+  return false;
+};
+var verifyNoteSignature = (k1, amountMsat, signatureHex, mintPubkeyHex) => {
+  if (isCk1(k1)) {
+    const signatureBytes = decodeCk1(k1);
+    const pubkey = signatureBytes ? recoverNoteOwnershipPubkey(signatureBytes) : null;
+    return pubkey ? verifyNoteSignatureHash(
+      bytesToHex(pubkey),
+      amountMsat,
+      signatureHex,
+      mintPubkeyHex
+    ) : false;
+  }
+  try {
+    return verifyNoteSignatureDigest(
+      noteSignatureDigest(k1, amountMsat),
+      signatureHex,
+      mintPubkeyHex
+    );
+  } catch {
+    return false;
+  }
+};
+var verifyNoteSignatureHash = (h, amountMsat, signatureHex, mintPubkeyHex) => {
+  try {
+    return verifyNoteSignatureDigest(
+      noteSignatureDigestForHash(h, amountMsat),
+      signatureHex,
+      mintPubkeyHex
+    );
+  } catch {
+    return false;
+  }
+};
+var NOTE_OWNERSHIP_MESSAGE = utf8ToBytes("LNURLcash");
+var noteOwnershipDigest = () => sha256(
+  sha256(
+    new Uint8Array([
+      ...LIGHTNING_SIGNED_MESSAGE_PREFIX,
+      ...NOTE_OWNERSHIP_MESSAGE
+    ])
+  )
+);
+var signNoteOwnership = (secretKey) => {
+  const libSig = secp256k1.sign(noteOwnershipDigest(), secretKey, {
+    format: "recovered",
+    prehash: false
+  });
+  return new Uint8Array([...libSig.subarray(1), libSig[0]]);
+};
+var recoverNoteOwnershipPubkey = (signature) => {
+  if (signature.length !== 65) return null;
+  try {
+    const recidLeading = new Uint8Array([
+      signature[64],
+      ...signature.subarray(0, 64)
+    ]);
+    const recovered = secp256k1.recoverPublicKey(
+      recidLeading,
+      noteOwnershipDigest(),
+      { prehash: false }
+    );
+    return recovered.subarray(1);
+  } catch {
+    return null;
+  }
+};
+var addressProofDigest = (action, username) => {
+  const message = utf8ToBytes(`LNURLcash:${action}:${username}`);
+  return sha256(
+    sha256(new Uint8Array([...LIGHTNING_SIGNED_MESSAGE_PREFIX, ...message]))
+  );
+};
+var signAddressProof = (branchIndexZeroSecretKey, action, username) => {
+  const libSig = secp256k1.sign(
+    addressProofDigest(action, username),
+    branchIndexZeroSecretKey,
+    { format: "recovered", prehash: false }
+  );
+  return new Uint8Array([...libSig.subarray(1), libSig[0]]);
+};
+var cp1FromCk1 = (ck1) => {
+  const signature = decodeCk1(ck1);
+  const pubkey = signature ? recoverNoteOwnershipPubkey(signature) : null;
+  return pubkey ? encodeCp1(pubkey) : null;
+};
+var requireMutationSignature = (body, field) => {
+  const signature = body?.[field];
+  if (typeof signature === "string") {
+    if (NOTE_SIGNATURE_PATTERN.test(signature)) {
+      return signature.toLowerCase();
+    }
+    if (isAnyCs1(signature)) return signature.trim();
+  }
+  throw new AmbiguousMintError(
+    `SERVICE confirmed the mutation without a valid ${field} signature.`
+  );
+};
+
+// fees.ts
+var MIN_COMMENT_LENGTH_FOR_SECRET = 64;
+var canUseMintComment = (info) => typeof info.commentAllowed === "number" && info.commentAllowed >= MIN_COMMENT_LENGTH_FOR_SECRET;
+var requireMintComment = (info) => {
+  if (!canUseMintComment(info)) {
+    throw new Error(
+      "This mint cannot create current LUD-25 notes because it does not advertise commentAllowed: 64."
+    );
+  }
+};
+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.isFinite(baseFeeMsat) || !Number.isFinite(feePpm)) continue;
+    if (feePpm >= 1e6) continue;
+    if (baseFeeMsat === 0 && feePpm === 0) return null;
+    return { baseFeeMsat, feePpm };
+  }
+  return null;
+};
+var applyMintFee = (grossMsat, fee) => {
+  const whole = Math.floor(grossMsat / 1e6);
+  const rest = grossMsat % 1e6;
+  const proportional = whole * fee.feePpm + Math.floor(rest * fee.feePpm / 1e6);
+  return Math.max(0, grossMsat - fee.baseFeeMsat - proportional);
+};
+var withinMintFeeBand = (grossMsat, netMsat, fee) => {
+  const exactNet = applyMintFee(grossMsat, fee);
+  const exactFee = grossMsat - exactNet;
+  const roundedNet = Math.max(0, grossMsat - Math.ceil(exactFee / 1e3) * 1e3);
+  return netMsat >= roundedNet && netMsat <= exactNet;
+};
+var grossUpForMintFee = (netMsat, fee) => {
+  if (netMsat <= 0) return 0;
+  let lo = netMsat;
+  let hi = netMsat + fee.baseFeeMsat;
+  let guard = 0;
+  while (applyMintFee(hi, fee) < netMsat && guard++ < 64) hi *= 2;
+  while (lo < hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (applyMintFee(mid, fee) < netMsat) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+};
+
+// net.ts
+var networkGuard = () => {
+};
+var configureNetworkGuard = (guard) => {
+  networkGuard = guard;
+};
+var transport = (url, signal, method) => fetch(url, { signal, method });
+var configureTransport = (next) => {
+  transport = next;
+};
+var lnurlFetch = async (url, method = "GET") => {
+  networkGuard();
+  if (!isAllowedServiceUrl(url.toString())) {
+    throw new Error(
+      "The service provided a URL this wallet will not fetch (not an allowed https/http address)."
+    );
+  }
+  let res;
+  try {
+    res = await transport(url.toString(), AbortSignal.timeout(3e4), method);
+  } catch (err) {
+    if (err.name === "TimeoutError") {
+      throw new AmbiguousMintError(
+        "The service took too long to respond - try again later."
+      );
+    }
+    throw new AmbiguousMintError(
+      "Failed to reach the service - it may be offline or not allow cross-origin requests."
+    );
+  }
+  const body = await res.json().catch(() => {
+    throw new AmbiguousMintError("Service returned an invalid response.");
+  });
+  if (body?.status === "ERROR") {
+    throw new ServiceError(typeof body.reason === "string" ? body.reason : "");
+  }
+  return body;
+};
+var defaultSecretProvider = () => bytesToHex(crypto.getRandomValues(new Uint8Array(32)));
+var secretProvider = defaultSecretProvider;
+var configureSecretProvider = (provider) => {
+  secretProvider = provider;
+};
+var generateSecret = (domain) => secretProvider(domain);
+var pubkeySecretProvider = () => null;
+var configurePubkeySecretProvider = (provider) => {
+  pubkeySecretProvider = provider;
+};
+var generatePubkeySecret = (domain) => pubkeySecretProvider(domain);
+
+// request.ts
+var parseOptionalSig = (value) => {
+  if (typeof value !== "string") return void 0;
+  if (NOTE_SIGNATURE_PATTERN.test(value)) return value.toLowerCase();
+  return isAnyCs1(value) ? value.trim() : void 0;
+};
+var parseNoteLookupBody = (body) => {
+  if (body?.tag !== "withdrawRequest" || typeof body.callback !== "string" || typeof body.maxWithdrawable !== "number" || !Number.isFinite(body.maxWithdrawable) || body.maxWithdrawable < 0 || body.minWithdrawable !== void 0 && (typeof body.minWithdrawable !== "number" || !Number.isFinite(body.minWithdrawable) || body.minWithdrawable < 0 || body.minWithdrawable > body.maxWithdrawable)) {
+    throw new Error("Not a withdrawRequest (unexpected response).");
+  }
+  const { sig: _rawSig, ...rest } = body;
+  const sig = parseOptionalSig(body.sig);
+  return {
+    ...rest,
+    ...parseMintKey(body),
+    ...sig !== void 0 ? { sig } : {}
+  };
+};
+var requestNoteInfoByField = async (url, field, value) => {
+  const lookupUrl = new URL(url);
+  lookupUrl.searchParams.delete("k1");
+  lookupUrl.searchParams.delete("amount");
+  lookupUrl.searchParams.delete("sig");
+  lookupUrl.searchParams.set(field, value);
+  const body = await lnurlFetch(lookupUrl);
+  if (body.k1 !== void 0) {
+    throw new Error("SERVICE returned k1 in a hash-only lookup response.");
+  }
+  return parseNoteLookupBody(body);
+};
+var requestNoteInfoByHash = async (url, h) => {
+  if (!/^[0-9a-f]{64}$/i.test(h)) {
+    throw new Error("A note hash must be 32 bytes of hex.");
+  }
+  return requestNoteInfoByField(url, "h", h.toLowerCase());
+};
+var requestNoteInfoByPubkey = async (url, cp1Value) => {
+  if (!isCp1(cp1Value)) {
+    throw new Error("A note pubkey must be a valid cp1 value.");
+  }
+  return requestNoteInfoByField(url, "p", cp1Value);
+};
+var fetchNoteInfoByHash = async (url, h) => {
+  try {
+    return await requestNoteInfoByHash(url, h);
+  } catch (err) {
+    throw classifyNoteError(err);
+  }
+};
+var fetchNoteInfoByPubkey = async (url, cp1Value) => {
+  try {
+    return await requestNoteInfoByPubkey(url, cp1Value);
+  } catch (err) {
+    throw classifyNoteError(err);
+  }
+};
+var fetchNoteInfo = async (url) => {
+  const queried = requireNoteK1(url);
+  const rawUrl = new URL(url);
+  rawUrl.searchParams.delete("sig");
+  if (isCk1(queried)) {
+    const signatureBytes = decodeCk1(queried);
+    const pubkey = signatureBytes ? recoverNoteOwnershipPubkey(signatureBytes) : null;
+    if (!pubkey) {
+      throw new Error("This note's ck1 secret is malformed.");
+    }
+    const info = await fetchNoteInfoByPubkey(
+      rawUrl.toString(),
+      encodeCp1(pubkey)
+    );
+    return { ...info, k1: queried };
+  }
+  try {
+    const info = await requestNoteInfoByHash(rawUrl.toString(), hashK1(queried));
+    return { ...info, k1: queried };
+  } catch (err) {
+    const missingK1 = err instanceof ServiceError && /(?:missing|required|specify).{0,40}\bk1\b|\bk1\b.{0,40}(?:missing|required)/i.test(
+      err.reason
+    );
+    if (!missingK1) throw classifyNoteError(err);
+  }
+  let body;
+  try {
+    body = await lnurlFetch(rawUrl);
+  } catch (fallbackError) {
+    throw classifyNoteError(fallbackError);
+  }
+  if (typeof body.k1 !== "string" || body.k1.toLowerCase() !== queried) {
+    throw new Error(
+      "Service echoed back a different k1 than queried - the note may have been redeemed elsewhere, or the service isn't spec-compliant."
+    );
+  }
+  return {
+    ...parseNoteLookupBody(body),
+    k1: queried
+  };
+};
+var probeBurnedNote = async (url) => {
+  try {
+    await fetchNoteInfo(url);
+    return "live";
+  } catch (err) {
+    if (err instanceof NoteSpentError || err instanceof NoteUnknownError) {
+      return "gone";
+    }
+    return "unknown";
+  }
+};
+var fetchMintAddress = async (url) => {
+  const body = await lnurlFetch(url);
+  if (body?.tag !== "withdrawRequest" || typeof body.callback !== "string" || typeof body.payLink !== "string" || typeof body.maxWithdrawable !== "number") {
+    throw new Error("Not a mint address response (unexpected shape).");
+  }
+  const { mintPubkey, nodeCapacity, outstandingNotesMsat, ...rest } = body;
+  const signingKey = parseMintKey({ mintPubkey });
+  const nodePubkey = typeof body.nodeUri === "string" && MINT_PUBKEY_PATTERN.test(body.nodeUri.split("@")[0] ?? "") ? body.nodeUri.split("@")[0].toLowerCase() : void 0;
+  return {
+    ...rest,
+    ...signingKey,
+    nodePubkey,
+    nodeCapacityMsat: typeof nodeCapacity === "number" ? nodeCapacity : void 0,
+    outstandingNotesMsat: typeof outstandingNotesMsat === "number" ? outstandingNotesMsat : void 0
+  };
+};
+var callbackRequest = async (callback, params) => {
+  const k1s = params.filter(([key]) => key === "k1").map(([, value]) => value);
+  if (k1s.length === 0 || k1s.some((k1) => k1.trim() === "")) {
+    throw new Error(
+      'This note has no secret in the browser. If it is marked "on device", reconnect the vault before refreshing or spending it.'
+    );
+  }
+  let cbUrl;
+  try {
+    cbUrl = new URL(callback);
+  } catch {
+    throw new Error("The service provided an invalid callback URL.");
+  }
+  for (const [key, value] of params) cbUrl.searchParams.append(key, value);
+  let body;
+  try {
+    body = await lnurlFetch(cbUrl);
+  } catch (err) {
+    if (err instanceof ServiceError && err.reason === "pending") {
+      throw new PendingNoteError();
+    }
+    if (err instanceof AmbiguousMintError) throw err;
+    throw classifyNoteError(err);
+  }
+  if (body?.status !== "OK") {
+    throw new AmbiguousMintError("Operation was not confirmed by the service.");
+  }
+  return body;
+};
+var meltNote = async (callback, k1, pr) => {
+  const body = await callbackRequest(callback, [
+    ["k1", k1],
+    ["pr", pr.trim()]
+  ]);
+  return {
+    verify: body.verify,
+    pr: typeof body.pr === "string" ? body.pr : void 0
+  };
+};
+var OUTPUT_FIELD_NAMES = {
+  "1": { legacy: "h", current: "p1" },
+  "2": { legacy: "h2", current: "p2" }
+};
+var outputFieldName = (value, suffix) => isCp1(value) ? OUTPUT_FIELD_NAMES[suffix].current : OUTPUT_FIELD_NAMES[suffix].legacy;
+var rotateNoteWithHash = async (callback, k1, h) => {
+  const body = await callbackRequest(callback, [
+    ["k1", k1],
+    [outputFieldName(h, "1"), h]
+  ]);
+  return { signature: requireMutationSignature(body, "sig") };
+};
+var splitNoteWithHash = async (callback, k1s, amountMsat, h, h2) => {
+  const body = await callbackRequest(callback, [
+    ...k1s.map((k1) => ["k1", k1]),
+    ["amount", String(amountMsat)],
+    [outputFieldName(h, "1"), h],
+    [outputFieldName(h2, "2"), h2]
+  ]);
+  return {
+    signature: requireMutationSignature(body, "sig"),
+    changeSignature: requireMutationSignature(body, "sig2")
+  };
+};
+var mergeNotesWithHash = async (callback, k1s, h) => {
+  const body = await callbackRequest(callback, [
+    ...k1s.map((k1) => ["k1", k1]),
+    [outputFieldName(h, "1"), h]
+  ]);
+  return { signature: requireMutationSignature(body, "sig") };
+};
+var generateOutputSecret = (domain, preferPubkey) => {
+  if (preferPubkey) {
+    const pubkeySecret = generatePubkeySecret(domain);
+    if (pubkeySecret) return pubkeySecret;
+  }
+  return generateSecret(domain);
+};
+var disclosedValue = (secret) => {
+  if (isCk1(secret)) {
+    const cp1 = cp1FromCk1(secret);
+    if (!cp1) throw new Error("Generated an invalid pubkey secret.");
+    return cp1;
+  }
+  return hashK1(secret);
+};
+var rotateNote = async (callback, k1) => {
+  const newK1 = generateOutputSecret(serverOf(callback), isCk1(k1));
+  try {
+    const result = await rotateNoteWithHash(callback, k1, disclosedValue(newK1));
+    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) => {
+  const domain = serverOf(callback);
+  const preferPubkey = k1s.every(isCk1);
+  const newK1 = generateOutputSecret(domain, preferPubkey);
+  const changeK1 = generateOutputSecret(domain, preferPubkey);
+  try {
+    const result = await splitNoteWithHash(
+      callback,
+      k1s,
+      amountMsat,
+      disclosedValue(newK1),
+      disclosedValue(changeK1)
+    );
+    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) => {
+  const newK1 = generateOutputSecret(serverOf(callback), k1s.every(isCk1));
+  try {
+    const result = await mergeNotesWithHash(
+      callback,
+      k1s,
+      disclosedValue(newK1)
+    );
+    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) => {
+  const info = await fetchNoteInfo(
+    withNewK1(baseUrl, k1, expectedAmountMsat, signature)
+  );
+  return {
+    k1,
+    amountMsat: info.maxWithdrawable,
+    signature,
+    callback: info.callback
+  };
+};
+
+// internalTransfer.ts
+var parseInternalTransferHint = (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/xpub") continue;
+    if (typeof entry[1] !== "string") continue;
+    const sep = entry[1].lastIndexOf(":");
+    if (sep < 0) continue;
+    const cx1 = decodeCx1(entry[1].slice(0, sep));
+    const startIndex = Number(entry[1].slice(sep + 1));
+    if (!cx1 || !Number.isInteger(startIndex) || startIndex < 0) continue;
+    return { cx1, startIndex };
+  }
+  return null;
+};
+var isIndexInUse = (err) => err instanceof ServiceError && /already in use/i.test(err.reason);
+var MAX_INDEX_ATTEMPTS = 25;
+var payInternalTransfer = async (callback, k1s, amountMsat, totalInputMsat, hint) => {
+  if (amountMsat > totalInputMsat) {
+    throw new Error("Cannot pay more than the selected notes are worth.");
+  }
+  const domain = serverOf(callback);
+  const preferPubkey = k1s.every(isCk1);
+  let index = hint.startIndex;
+  for (let attempt = 0; attempt < MAX_INDEX_ATTEMPTS; attempt++) {
+    const recipientOutput = encodeCp1(
+      deriveNotePubkey(hint.cx1.pubkeyXOnly, hint.cx1.chainCode, index)
+    );
+    if (amountMsat === totalInputMsat) {
+      try {
+        const { signature } = await mergeNotesWithHash(
+          callback,
+          k1s,
+          recipientOutput
+        );
+        return { kind: "merge", index, signature };
+      } catch (err) {
+        if (isIndexInUse(err)) {
+          index++;
+          continue;
+        }
+        throw err;
+      }
+    }
+    const changeK1 = generateOutputSecret(domain, preferPubkey);
+    try {
+      const result = await splitNoteWithHash(
+        callback,
+        k1s,
+        amountMsat,
+        recipientOutput,
+        disclosedValue(changeK1)
+      );
+      return {
+        kind: "split",
+        index,
+        signature: result.signature,
+        change: changeK1,
+        changeSignature: result.changeSignature
+      };
+    } catch (err) {
+      if (isIndexInUse(err)) {
+        index++;
+        continue;
+      }
+      if (err instanceof AmbiguousMintError) {
+        throw new AmbiguousMutationError(err.message, [changeK1]);
+      }
+      throw err;
+    }
+  }
+  throw new Error(
+    `${domain} kept reporting every index tried as already in use - could not complete the internal transfer.`
+  );
+};
+var fetchPayRequest = async (url) => {
+  const body = await lnurlFetch(url);
+  if (body?.tag !== "payRequest" || typeof body.callback !== "string") {
+    throw new Error("Not a payRequest (unexpected response).");
+  }
+  const mintFee = typeof body.metadata === "string" ? parseMintFee(body.metadata) : null;
+  const internalTransfer = typeof body.metadata === "string" ? parseInternalTransferHint(body.metadata) : null;
+  return {
+    ...body,
+    mintFee: mintFee ?? void 0,
+    internalTransfer: internalTransfer ?? void 0,
+    mintToHash: body.mintToHash === true,
+    commentAllowed: typeof body.commentAllowed === "number" ? body.commentAllowed : void 0
+  };
+};
+var normalizeNoteId = (value) => {
+  const trimmed = value.trim().toLowerCase();
+  if (/^[0-9a-f]{64}$/.test(trimmed)) return trimmed;
+  const decoded = decodeCp1(trimmed);
+  return decoded ? bytesToHex(decoded) : null;
+};
+var normalizeSignature = (value) => {
+  if (/^[0-9a-f]{130}$/i.test(value)) return value.toLowerCase();
+  const decoded = decodeAnyCs1(value);
+  return decoded ? bytesToHex(decoded) : null;
+};
+var parseBoundMintCommitment = (value) => {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value;
+  if (typeof raw.h !== "string") return void 0;
+  const h = normalizeNoteId(raw.h);
+  if (h === null || typeof raw.amount !== "number" || !Number.isSafeInteger(raw.amount) || raw.amount <= 0 || raw.sig !== void 0 && typeof raw.sig !== "string") {
+    return void 0;
+  }
+  let signature;
+  if (typeof raw.sig === "string") {
+    const normalized = normalizeSignature(raw.sig);
+    if (normalized === null) return void 0;
+    signature = normalized;
+  }
+  return {
+    h,
+    amountMsat: raw.amount,
+    ...signature !== void 0 ? { signature } : {}
+  };
+};
+var requestInvoice = async (payCallback, amountMsat, outputHash) => {
+  const cbUrl = new URL(payCallback);
+  cbUrl.searchParams.set("amount", String(amountMsat));
+  if (outputHash !== void 0) {
+    const value = outputHash.trim().toLowerCase();
+    if (isCp1(value)) {
+      cbUrl.searchParams.set("comment", value);
+    } else if (isPreimage(value)) {
+      cbUrl.searchParams.set("comment", value);
+      cbUrl.searchParams.set("h", value);
+    } else {
+      throw new Error(
+        "An output hash must be 32 bytes of hex, or a cp1 pubkey - no invoice was requested."
+      );
+    }
+  }
+  const body = await lnurlFetch(cbUrl);
+  if (typeof body?.pr !== "string") {
+    throw new Error("Service did not return an invoice.");
+  }
+  const invoiceMsat = decodeBolt11AmountMsat(body.pr);
+  if (invoiceMsat !== null && invoiceMsat !== amountMsat) {
+    throw new Error(
+      `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,
+    mintToHash: body.mintToHash === true,
+    mint: parseBoundMintCommitment(body.mint)
+  };
+};
+var fetchInvoiceVerification = async (verifyUrl) => {
+  const body = await lnurlFetch(verifyUrl);
+  if (typeof body?.settled !== "boolean" || typeof body?.pr !== "string") {
+    throw new Error("Service returned an unexpected verify response.");
+  }
+  return {
+    settled: body.settled,
+    preimage: typeof body.preimage === "string" ? body.preimage : null,
+    pr: body.pr,
+    mint: parseBoundMintCommitment(body.mint)
+  };
+};
+var requireBoundMintQuote = (invoice, expectedH, grossMsat, fee) => {
+  const h = normalizeNoteId(expectedH);
+  if (h === null) throw new Error("The expected mint output is malformed.");
+  const commitment = invoice.mint;
+  if (!invoice.mintToHash || !invoice.verify || !commitment) {
+    throw new Error(
+      "The mint did not offer an authenticated device-bound receipt for this quote."
+    );
+  }
+  if (commitment.h !== h) {
+    throw new Error("The mint committed the quote to a different output.");
+  }
+  const amountAccepted = fee ? withinMintFeeBand(grossMsat, commitment.amountMsat, fee) : commitment.amountMsat === grossMsat;
+  if (!amountAccepted) {
+    throw new Error(
+      "The mint committed the quote to an unexpected note amount."
+    );
+  }
+  if (commitment.signature !== void 0) {
+    throw new Error("The mint signed an output before its invoice settled.");
+  }
+  return commitment;
+};
+var validateBoundMintReceipt = (invoice, verification, expectedH, expectedAmountMsat, mintPubkey) => {
+  if (!verification.settled) throw new Error("The invoice has not settled.");
+  if (!sameInvoice(invoice.pr, verification.pr)) {
+    throw new Error("The settlement receipt names a different invoice.");
+  }
+  const expectedNormalized = normalizeNoteId(expectedH);
+  const receipt = verification.mint;
+  if (!receipt || expectedNormalized === null || receipt.h !== expectedNormalized || receipt.amountMsat !== expectedAmountMsat) {
+    throw new Error("The settlement receipt does not match the mint quote.");
+  }
+  if (!receipt.signature || !verifyNoteSignatureHash(
+    receipt.h,
+    receipt.amountMsat,
+    receipt.signature,
+    mintPubkey
+  )) {
+    throw new Error("The settled mint receipt has an invalid signature.");
+  }
+  return { ...receipt, signature: receipt.signature };
+};
+var addressProofUrl = (server, username, indexZeroSecretKey, action) => {
+  const url = new URL(`/p/${encodeURIComponent(username)}`, server);
+  url.searchParams.set(
+    "sig",
+    bytesToHex(signAddressProof(indexZeroSecretKey, action, username))
+  );
+  return url;
+};
+var registerUsername = async (server, username, cx1, indexZeroSecretKey) => {
+  const url = addressProofUrl(server, username, indexZeroSecretKey, "register");
+  url.searchParams.set("cx1", cx1);
+  const body = await lnurlFetch(url, "POST");
+  if (body?.status !== "OK") {
+    throw new Error("SERVICE did not confirm the registration.");
+  }
+};
+var unregisterUsername = async (server, username, indexZeroSecretKey) => {
+  const url = addressProofUrl(
+    server,
+    username,
+    indexZeroSecretKey,
+    "unregister"
+  );
+  const body = await lnurlFetch(url, "DELETE");
+  if (body?.status !== "OK") {
+    throw new Error("SERVICE did not confirm the unregistration.");
+  }
+};
+var DEFAULT_GAP_LIMIT = 20;
+var DEFAULT_RATE_LIMIT_BACKOFF_MS = 2e3;
+var isRateLimited = (err) => err instanceof ServiceError && /rate.?limit/i.test(err.reason);
+var scanForAddressNotes = async (withdrawUrl, branch, opts = {}) => {
+  const gapLimit = opts.gapLimit ?? DEFAULT_GAP_LIMIT;
+  const backoffMs = opts.rateLimitBackoffMs ?? DEFAULT_RATE_LIMIT_BACKOFF_MS;
+  const found = [];
+  let consecutiveUnknown = 0;
+  let index = opts.startIndex ?? 0;
+  while (consecutiveUnknown < gapLimit) {
+    const pubkey = deriveNotePubkey(branch.pubkeyXOnly, branch.chainCode, index);
+    const cp1 = encodeCp1(pubkey);
+    try {
+      const info = await fetchNoteInfoByPubkey(withdrawUrl, cp1);
+      const result = { index, cp1, info };
+      found.push(result);
+      opts.onFound?.(result);
+      consecutiveUnknown = 0;
+      index++;
+    } catch (err) {
+      if (isRateLimited(err)) {
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+        continue;
+      }
+      if (err instanceof NoteUnknownError) {
+        consecutiveUnknown++;
+        index++;
+        continue;
+      }
+      if (err instanceof NoteSpentError) {
+        consecutiveUnknown = 0;
+        index++;
+        continue;
+      }
+      throw classifyNoteError(err);
+    }
+  }
+  return found;
+};
+
+export { AmbiguousMintError, AmbiguousMutationError, MINT_PUBKEY_PATTERN, MIN_COMMENT_LENGTH_FOR_SECRET, NOTE_SIGNATURE_PATTERN, NoteSpentError, NoteUnknownError, PendingNoteError, ServiceError, applyMintFee, buildNoteUrl, canUseMintComment, classifyNoteError, configureNetworkGuard, configurePubkeySecretProvider, configureSecretProvider, configureTransport, cp1FromCk1, decodeAnyCs1, decodeBolt11AmountMsat, decodeBolt11AmountSuffix, decodeBolt11PaymentHash, decodeCk1, decodeCp1, decodeCs1, decodeCs1WithAmount, decodeCx1, defaultSchemeFor, deriveNotePubkey, deriveNoteSecretKey, disclosedValue, encodeBolt11AmountSuffix, encodeCk1, encodeCp1, encodeCs1, encodeCs1WithAmount, encodeCx1, fetchInvoiceVerification, fetchMintAddress, fetchNoteInfo, fetchNoteInfoByHash, fetchNoteInfoByPubkey, fetchPayRequest, fromBech32Lnurl, fromLud17, generateOutputSecret, grossUpForMintFee, hashK1, isAllowedServiceUrl, isAnyCs1, isBech32Lnurl, isBolt11Invoice, isCk1, isCp1, isCs1, isCs1WithAmount, isCx1, isLightningAddress, isPreimage, isValidK1, isValidNoteInput, lightningAddressUsername, lnurlFetch, meltNote, mergeNotes, mergeNotesWithHash, mintAddressUrl, noteDeclaredAmount, noteEndpointOf, noteK1, noteSignature, parseInternalTransferHint, parseMintFee, parseMintKey, payInternalTransfer, probeBurnedNote, recoverNoteOwnershipPubkey, registerUsername, requestInvoice, requireBoundMintQuote, requireMintComment, requireMutationSignature, requireNoteK1, resolveLnurlInput, resolveMintInput, resolveNoteInput, rotateNote, rotateNoteWithHash, sameInvoice, scanForAddressNotes, serverOf, serviceOriginOf, settleNote, signAddressProof, signNoteOwnership, splitNote, splitNoteWithHash, toBech32Lnurl, toLud17w, unregisterUsername, validateBoundMintReceipt, verifyMeltPreimage, verifyNoteSignature, verifyNoteSignatureHash, withNewK1, withinMintFeeBand, withoutK1, withoutSignature };