@openreceive/node 0.2.1

package/dist/index.js

@@ -0,0 +1,2510 @@
+import {
+  OPENRECEIVE_SWAP_PAY_IN_ASSETS,
+  TransientSwapCache,
+  createLscSwapProvidersFromEnvironment,
+  createNwcEndpointLogger,
+  emitLog,
+  fixedFloatCompatibleSwapProvider,
+  fixedFloatProvider,
+  formatLscUri,
+  isSwapPayInAsset,
+  listSwapAssetInfo,
+  sanitizeEvent,
+  summarizeSwapProviderApiRequest,
+  summarizeSwapProviderApiResponse
+} from "./chunk-6HALOJYF.js";
+
+// src/index.ts
+import { OpenReceiveError as OpenReceiveError4 } from "@openreceive/core";
+
+// src/alby-nwc.ts
+import {
+  compact,
+  formatSpendCapabilityRefusedMessage,
+  formatSpendCapabilityWarningMessage,
+  OpenReceiveError as OpenReceiveError2,
+  parseNwcUri
+} from "@openreceive/core";
+
+// src/nwc/errors.ts
+import {
+  isErrorCode,
+  isRetryableErrorCode,
+  OpenReceiveError
+} from "@openreceive/core";
+var WalletPreflightError = class extends Error {
+  code;
+  summary;
+  constructor(code, message, summary) {
+    super(message);
+    this.name = "WalletPreflightError";
+    this.code = code;
+    this.summary = summary;
+  }
+};
+var ReceiveCheckoutValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReceiveCheckoutValidationError";
+  }
+};
+var NWC_ERROR_CODE_ALIASES = {
+  ABORT_ERROR: "TIMEOUT",
+  BAD_REQUEST: "INVALID_REQUEST",
+  CONNECTION_ERROR: "WALLET_UNAVAILABLE",
+  EXPIRED: "INVOICE_EXPIRED",
+  FETCH_ERROR: "WALLET_UNAVAILABLE",
+  FORBIDDEN: "RESTRICTED",
+  INVOICE_NOT_FOUND: "NOT_FOUND",
+  INVALID_PARAMETER: "INVALID_REQUEST",
+  INVALID_PARAMETERS: "INVALID_REQUEST",
+  INVALID_PARAMS: "INVALID_REQUEST",
+  METHOD_NOT_FOUND: "UNSUPPORTED_METHOD",
+  NETWORK_ERROR: "WALLET_UNAVAILABLE",
+  NIP47_NETWORK_ERROR: "WALLET_UNAVAILABLE",
+  NOSTR_NETWORK_ERROR: "WALLET_UNAVAILABLE",
+  NOT_AUTHORIZED: "UNAUTHORIZED",
+  NOT_SUPPORTED: "UNSUPPORTED_METHOD",
+  NOTFOUND: "NOT_FOUND",
+  PERMISSION_DENIED: "RESTRICTED",
+  RELAY_CONNECTION_ERROR: "WALLET_UNAVAILABLE",
+  REQUEST_TIMEOUT: "TIMEOUT",
+  SERVICE_UNAVAILABLE: "WALLET_UNAVAILABLE",
+  TIMED_OUT: "TIMEOUT",
+  TIMEOUT_ERROR: "TIMEOUT",
+  UNKNOWN_METHOD: "UNSUPPORTED_METHOD",
+  UNSUPPORTED: "UNSUPPORTED_METHOD",
+  UNSUPPORTED_ENCRYPTION_MODE: "UNSUPPORTED_ENCRYPTION",
+  WALLET_OFFLINE: "WALLET_UNAVAILABLE",
+  WALLET_UNREACHABLE: "WALLET_UNAVAILABLE"
+};
+var OPENRECEIVE_ERROR_MESSAGES = {
+  NOT_IMPLEMENTED: "NWC wallet service does not implement this method.",
+  RESTRICTED: "NWC wallet service restricted this request.",
+  UNAUTHORIZED: "NWC wallet service rejected authorization.",
+  FORBIDDEN: "The host application did not authorize this request.",
+  RATE_LIMITED: "NWC wallet service rate limited this request.",
+  QUOTA_EXCEEDED: "NWC wallet service quota was exceeded.",
+  INTERNAL: "NWC wallet service returned an internal error.",
+  UNSUPPORTED_ENCRYPTION: "NWC wallet service does not support the required encryption mode.",
+  OTHER: "NWC wallet service returned an unknown error.",
+  NOT_FOUND: "NWC wallet service could not find the requested resource.",
+  TIMEOUT: "NWC wallet service request timed out.",
+  INVALID_REQUEST: "OpenReceive sent an invalid NWC wallet request.",
+  WALLET_UNAVAILABLE: "NWC wallet service is unavailable.",
+  INVOICE_EXPIRED: "NWC wallet reported that the invoice is expired.",
+  UNSUPPORTED_METHOD: "NWC wallet service does not support the requested method.",
+  CONFLICT: "NWC wallet service reported a conflicting request."
+};
+function normalizeNwcWalletError(error) {
+  if (error instanceof OpenReceiveError) return error;
+  const records = collectErrorRecords(error);
+  const code = knownErrorCode(error) ?? errorCodeFromRecords(records) ?? (typeof error === "string" ? normalizeNwcErrorCode(error) : void 0) ?? "OTHER";
+  const message = errorMessageFromRecords(records, error, code);
+  const retryable = firstBooleanField(records, ["retryable"]) ?? isRetryableErrorCode(code);
+  const requestId = firstStringField(records, ["request_id", "requestId"]);
+  const details = firstRecordField(records, ["details"]);
+  const body = {
+    code,
+    message,
+    retryable,
+    ...requestId === void 0 ? {} : { request_id: requestId },
+    ...details === void 0 ? {} : { details }
+  };
+  return new OpenReceiveError(body, { cause: error });
+}
+function knownErrorCode(error) {
+  if (error instanceof ReceiveCheckoutValidationError) {
+    return "INVALID_REQUEST";
+  }
+  if (error instanceof WalletPreflightError) {
+    if (error.code === "missing_required_method") return "UNSUPPORTED_METHOD";
+    if (error.code === "spend_capability_advertised") return "RESTRICTED";
+    if (error.code === "unsupported_encryption") return "UNSUPPORTED_ENCRYPTION";
+    return "WALLET_UNAVAILABLE";
+  }
+  return void 0;
+}
+function errorCodeFromRecords(records) {
+  for (const record of records) {
+    const directCode = normalizeNwcErrorCode(record.code) ?? normalizeNwcErrorCode(record.error_code) ?? normalizeNwcErrorCode(record.errorCode) ?? normalizeNwcErrorCode(record.type);
+    if (directCode !== void 0 && directCode !== "OTHER") return directCode;
+    const nameCode = normalizeNwcErrorCode(record.name);
+    if (nameCode !== void 0 && nameCode !== "OTHER") return nameCode;
+    if (directCode !== void 0) return directCode;
+  }
+  return void 0;
+}
+function normalizeNwcErrorCode(value) {
+  if (typeof value !== "string" || value.trim().length === 0) return void 0;
+  const normalized = normalizeNwcErrorCodeText(value);
+  return NWC_ERROR_CODE_ALIASES[normalized] ?? (isErrorCode(normalized) ? normalized : void 0);
+}
+function normalizeNwcErrorCodeText(value) {
+  return value.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+function errorMessageFromRecords(records, error, code) {
+  const message = firstStringField(records, ["message", "description", "reason"]);
+  if (message !== void 0 && normalizeNwcErrorCode(message) !== code) {
+    return message;
+  }
+  if (typeof error === "string" && normalizeNwcErrorCode(error) === void 0) {
+    const trimmed = error.trim();
+    if (trimmed.length > 0) return trimmed;
+  }
+  return OPENRECEIVE_ERROR_MESSAGES[code];
+}
+function collectErrorRecords(value) {
+  const records = [];
+  collectErrorRecordsInto(value, records, /* @__PURE__ */ new Set());
+  return records;
+}
+function collectErrorRecordsInto(value, records, seen) {
+  if (typeof value !== "object" || value === null || seen.has(value)) return;
+  seen.add(value);
+  const record = value;
+  records.push(record);
+  for (const key of ["error", "result", "cause", "data"]) {
+    collectErrorRecordsInto(record[key], records, seen);
+  }
+}
+function firstStringField(records, fields) {
+  for (const record of records) {
+    for (const field of fields) {
+      const value = record[field];
+      if (typeof value === "string" && value.trim().length > 0) {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
+function firstBooleanField(records, fields) {
+  for (const record of records) {
+    for (const field of fields) {
+      const value = record[field];
+      if (typeof value === "boolean") return value;
+    }
+  }
+  return void 0;
+}
+function firstRecordField(records, fields) {
+  for (const record of records) {
+    for (const field of fields) {
+      const value = record[field];
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/nwc/normalize.ts
+import {
+  OPENRECEIVE_MAX_AMOUNT_MSATS,
+  OPENRECEIVE_MIN_AMOUNT_MSATS,
+  OPENRECEIVE_NWC_METADATA_MAX_BYTES,
+  nonEmptyString,
+  recordOrEmpty
+} from "@openreceive/core";
+
+// src/hex.ts
+var HEX_64 = /^[0-9a-fA-F]{64}$/;
+
+// src/nwc/normalize.ts
+var REQUIRED_RECEIVE_METHODS = ["make_invoice", "list_transactions"];
+var SPEND_METHODS = [
+  "pay_invoice",
+  "multi_pay_invoice",
+  "pay_keysend",
+  "multi_pay_keysend"
+];
+function summarizeWalletCapabilities(connection, rawInfo, rawServiceInfo) {
+  const unwrappedInfo = unwrapNwcResult(rawInfo);
+  const info = recordOrEmpty(unwrappedInfo);
+  const serviceInfo = rawServiceInfo === void 0 ? void 0 : recordOrEmpty(unwrapNwcResult(rawServiceInfo));
+  const methods = normalizeStringList(
+    info.methods ?? info.capabilities ?? info.supported_methods ?? info.supportedMethods ?? (typeof unwrappedInfo === "string" ? unwrappedInfo : void 0)
+  ).map(normalizeNwcMethodName);
+  const encryption = chooseEncryptionMode(
+    normalizeStringList(
+      serviceInfo?.encryption ?? serviceInfo?.encryptions ?? info.encryption ?? info.encryptions
+    )
+  );
+  const spendMethods = spendMethodsIn(methods);
+  const missingMethods = REQUIRED_RECEIVE_METHODS.filter((method) => !methods.includes(method));
+  const warnings = spendMethods.map(
+    (method) => `Wallet advertises spend method '${method}'; OpenReceive checkout will not expose it.`
+  );
+  return {
+    walletPubkey: connection.walletPubkey,
+    relays: [...connection.relays],
+    methods,
+    encryption,
+    spendCapabilityAdvertised: spendMethods.length > 0,
+    receiveCheckoutReady: missingMethods.length === 0,
+    warnings
+  };
+}
+function spendMethodsIn(methods) {
+  return methods.filter(
+    (method) => SPEND_METHODS.includes(method)
+  );
+}
+function toNip47MakeInvoiceParams(request) {
+  const params = {
+    amount: toSafeNumber(request.amount_msats, "amount_msats")
+  };
+  if (request.description !== void 0) params.description = request.description;
+  if (request.description_hash !== void 0) {
+    params.description_hash = request.description_hash;
+  }
+  if (request.expiry !== void 0) params.expiry = request.expiry;
+  if (request.metadata !== void 0) params.metadata = request.metadata;
+  return params;
+}
+function toNip47ListTransactionsParams(request) {
+  const params = {};
+  if (request.from !== void 0) params.from = request.from;
+  if (request.until !== void 0) params.until = request.until;
+  if (request.limit !== void 0) params.limit = request.limit;
+  if (request.offset !== void 0) params.offset = request.offset;
+  if (request.unpaid !== void 0) params.unpaid = request.unpaid;
+  if (request.type !== void 0) params.type = request.type;
+  return params;
+}
+function validateMakeInvoiceRequest(request) {
+  if (request.amount_msats < OPENRECEIVE_MIN_AMOUNT_MSATS) {
+    throw new ReceiveCheckoutValidationError("amount_msats must be at least 1000");
+  }
+  if (request.amount_msats > OPENRECEIVE_MAX_AMOUNT_MSATS) {
+    throw new ReceiveCheckoutValidationError("amount_msats exceeds JSON safe integer boundary");
+  }
+  if (request.description !== void 0 && request.description_hash !== void 0) {
+    throw new ReceiveCheckoutValidationError(
+      "At most one of description or description_hash may be present"
+    );
+  }
+  if (request.description_hash !== void 0 && !HEX_64.test(request.description_hash)) {
+    throw new ReceiveCheckoutValidationError("description_hash must be 64 hex characters");
+  }
+  if (request.metadata !== void 0) {
+    const metadataBytes = byteLength(JSON.stringify(request.metadata));
+    if (metadataBytes > OPENRECEIVE_NWC_METADATA_MAX_BYTES) {
+      throw new ReceiveCheckoutValidationError(
+        `metadata must serialize below ${OPENRECEIVE_NWC_METADATA_MAX_BYTES} bytes`
+      );
+    }
+  }
+}
+function validateListTransactionsRequest(request) {
+  validateOptionalNonNegativeInteger(request.from, "from");
+  validateOptionalNonNegativeInteger(request.until, "until");
+  validateOptionalNonNegativeInteger(request.offset, "offset");
+  if (request.limit !== void 0 && (!Number.isSafeInteger(request.limit) || request.limit <= 0)) {
+    throw new ReceiveCheckoutValidationError("limit must be a positive safe integer");
+  }
+  if (request.from !== void 0 && request.until !== void 0 && request.from > request.until) {
+    throw new ReceiveCheckoutValidationError("from must be less than or equal to until");
+  }
+  if (request.type !== void 0 && request.type !== "incoming" && request.type !== "outgoing") {
+    throw new ReceiveCheckoutValidationError("type must be incoming or outgoing");
+  }
+}
+function validateOptionalNonNegativeInteger(value, field) {
+  if (value === void 0) return;
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new ReceiveCheckoutValidationError(`${field} must be a non-negative safe integer`);
+  }
+}
+function normalizeMakeInvoiceResult(rawResult) {
+  const result = recordOrEmpty(unwrapNwcResult(rawResult));
+  const invoice = requiredString(result.invoice, "invoice");
+  const paymentHash = requiredString(result.payment_hash ?? result.paymentHash, "payment_hash");
+  if (!HEX_64.test(paymentHash)) {
+    throw new TypeError("payment_hash must be 64 hex characters");
+  }
+  const amountMsats = toBigInt(result.amount_msats ?? result.amount, "amount_msats");
+  const createdAt = parseOptionalInteger(result.created_at ?? result.createdAt, "created_at");
+  const expiresAt = parseOptionalInteger(result.expires_at ?? result.expiresAt, "expires_at");
+  return {
+    invoice,
+    payment_hash: paymentHash,
+    amount_msats: amountMsats,
+    ...createdAt === void 0 ? {} : { created_at: createdAt },
+    ...expiresAt === void 0 ? {} : { expires_at: expiresAt }
+  };
+}
+function normalizeListTransactionsResult(rawResult) {
+  const unwrapped = unwrapNwcResult(rawResult);
+  const result = recordOrEmpty(unwrapped);
+  let rawTransactions;
+  if (Array.isArray(result.transactions)) {
+    rawTransactions = result.transactions;
+  } else if (Array.isArray(unwrapped)) {
+    rawTransactions = unwrapped;
+  } else if ((unwrapped === void 0 || unwrapped === null || typeof unwrapped === "object") && Object.keys(result).length === 0) {
+    rawTransactions = [];
+  } else {
+    throw new TypeError("list_transactions returned an unrecognized result shape");
+  }
+  const transactions = [];
+  let skippedRows = 0;
+  for (const rawTransaction of rawTransactions) {
+    try {
+      transactions.push(normalizeNwcTransaction(rawTransaction));
+    } catch {
+      skippedRows += 1;
+    }
+  }
+  if (transactions.length === 0 && skippedRows > 0) {
+    throw new TypeError("list_transactions returned no usable rows");
+  }
+  return { transactions, skippedRows };
+}
+function normalizeNwcTransaction(rawTransaction) {
+  const result = recordOrEmpty(rawTransaction);
+  const normalized = {};
+  const type = normalizeTransactionType(result.type);
+  if (type !== void 0) normalized.type = type;
+  const invoice = nonEmptyString(result.invoice);
+  if (invoice !== void 0) normalized.invoice = invoice;
+  const paymentHash = nonEmptyString(result.payment_hash ?? result.paymentHash);
+  if (paymentHash !== void 0) {
+    if (!/^[0-9a-fA-F]{64}$/.test(paymentHash)) {
+      throw new TypeError("payment_hash must be 64 hexadecimal characters");
+    }
+    normalized.payment_hash = paymentHash;
+  }
+  if (result.amount_msats !== void 0 || result.amount !== void 0) {
+    normalized.amount_msats = toBigInt(result.amount_msats ?? result.amount, "amount_msats");
+  }
+  const transactionState = normalizeTransactionState(
+    result.transaction_state ?? result.transactionState ?? result.state
+  ) ?? (result.settled === true || result.paid === true ? "settled" : void 0);
+  if (transactionState !== void 0) {
+    normalized.transaction_state = transactionState;
+  }
+  const createdAt = optionalUnixSeconds(result.created_at ?? result.createdAt, "created_at");
+  if (createdAt !== void 0) normalized.created_at = createdAt;
+  const expiresAt = optionalUnixSeconds(result.expires_at ?? result.expiresAt, "expires_at");
+  if (expiresAt !== void 0) normalized.expires_at = expiresAt;
+  const settledAt = optionalUnixSeconds(result.settled_at ?? result.settledAt, "settled_at");
+  if (settledAt !== void 0) normalized.settled_at = settledAt;
+  const preimage = nonEmptyString(result.preimage);
+  if (preimage !== void 0) normalized.preimage = preimage;
+  const description = nonEmptyString(result.description);
+  if (description !== void 0) normalized.description = description;
+  const descriptionHash = nonEmptyString(result.description_hash ?? result.descriptionHash);
+  if (descriptionHash !== void 0) normalized.description_hash = descriptionHash;
+  if (result.fees_paid !== void 0 || result.feesPaid !== void 0) {
+    normalized.fees_paid_msats = toBigInt(result.fees_paid ?? result.feesPaid, "fees_paid");
+  }
+  return normalized;
+}
+function normalizeNwcNotification(rawNotification) {
+  const record = recordOrEmpty(rawNotification);
+  const type = typeof record.notification_type === "string" ? record.notification_type : typeof record.notificationType === "string" ? record.notificationType : typeof record.type === "string" ? record.type : "unknown";
+  const payload = recordOrEmpty(record.notification);
+  let transaction;
+  if (Object.keys(payload).length > 0) {
+    try {
+      transaction = normalizeNwcTransaction(payload);
+    } catch {
+    }
+  }
+  const rawHash = payload.payment_hash ?? payload.paymentHash ?? record.payment_hash ?? record.paymentHash;
+  const paymentHash = typeof rawHash === "string" && rawHash.length > 0 ? rawHash : transaction?.payment_hash;
+  return {
+    type,
+    ...paymentHash === void 0 ? {} : { payment_hash: paymentHash },
+    ...transaction === void 0 ? {} : { transaction }
+  };
+}
+function chooseEncryptionMode(encryptionModes) {
+  const normalized = encryptionModes.map((mode) => mode.toLowerCase().replace(/[- ]/g, "_"));
+  if (normalized.includes("nip44_v2") || normalized.includes("nip44") || normalized.includes("nip_44")) {
+    return "nip44_v2";
+  }
+  if (normalized.length === 0 || normalized.includes("nip04") || normalized.includes("nip_04")) {
+    return "nip04";
+  }
+  return void 0;
+}
+function normalizeStringList(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    return value.split(/[,\s]+/).map((item) => item.trim()).filter(Boolean);
+  }
+  return [];
+}
+function normalizeNwcMethodName(value) {
+  return value.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+function normalizeTransactionState(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "pending" || normalized === "settled" || normalized === "expired" || normalized === "failed" || normalized === "accepted") {
+    return normalized;
+  }
+  return void 0;
+}
+function normalizeTransactionType(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "incoming" || normalized === "outgoing") return normalized;
+  return void 0;
+}
+function parseOptionalInteger(value, fieldName) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${fieldName} must be a non-negative safe integer`);
+  }
+  return value;
+}
+function optionalUnixSeconds(value, fieldName) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new TypeError(`${fieldName} must be a non-negative number of Unix seconds`);
+  }
+  return Math.floor(value);
+}
+function requiredString(value, fieldName) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${fieldName} must be a non-empty string`);
+  }
+  return value;
+}
+function toBigInt(value, fieldName) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" && Number.isSafeInteger(value)) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^[0-9]+$/.test(value)) {
+    return BigInt(value);
+  }
+  throw new TypeError(`${fieldName} must be an integer`);
+}
+function toSafeNumber(value, fieldName) {
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new ReceiveCheckoutValidationError(`${fieldName} exceeds JSON safe integer boundary`);
+  }
+  return Number(value);
+}
+function byteLength(value) {
+  return new TextEncoder().encode(value).length;
+}
+function unwrapNwcResult(value) {
+  const record = recordOrEmpty(value);
+  return record.result ?? value;
+}
+
+// src/nwc/transport.ts
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+import { recordOrEmpty as recordOrEmpty2 } from "@openreceive/core";
+var require2 = createRequire(import.meta.url);
+async function callRequiredMethod(client, names, request) {
+  for (const name of names) {
+    const method = client[name];
+    if (typeof method === "function") {
+      return await method.call(
+        client,
+        request
+      );
+    }
+  }
+  throw new WalletPreflightError(
+    "wallet_unavailable",
+    `NWC client does not expose ${names.join(" or ")}.`
+  );
+}
+async function createDefaultAlbyNwcClient(connectionString) {
+  ensureNodeWebSocket();
+  const dynamicImport = new Function("specifier", "return import(specifier)");
+  const namespace = recordOrEmpty2(
+    await dynamicImport(pathToFileURL(require2.resolve("@getalby/sdk/nwc")).href)
+  );
+  const Constructor = namespace.NWCClient;
+  if (typeof Constructor !== "function") {
+    throw new WalletPreflightError(
+      "wallet_unavailable",
+      "@getalby/sdk/nwc did not expose NWCClient."
+    );
+  }
+  const NWCClientConstructor = Constructor;
+  return new NWCClientConstructor({
+    nostrWalletConnectUrl: connectionString
+  });
+}
+function ensureNodeWebSocket() {
+  if (globalThis.WebSocket !== void 0) return;
+  throw new WalletPreflightError(
+    "wallet_unavailable",
+    "OpenReceive requires Node 22 or newer with the built-in WebSocket API."
+  );
+}
+async function closeNwcNotificationSubscription(subscription) {
+  if (typeof subscription !== "function") {
+    throw new TypeError("NWC subscribeNotifications must resolve to an unsubscribe function.");
+  }
+  await subscription();
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+
+// src/alby-nwc.ts
+var AlbyNwcReceiveClient = class {
+  /**
+   * Safe, loggable view of the connection (wallet pubkey, relays, lud16, and
+   * the secret-redacted URI). The parsed connection with the client secret is
+   * deliberately private: `console.log(client)` or host error serialization
+   * must never leak the secret.
+   */
+  connection;
+  #connection;
+  #connectionString;
+  #client;
+  #clientPromise;
+  #clientFactory;
+  #preflightSummary;
+  #preflightPromise;
+  #requirePreflight;
+  #logger;
+  #allowSpendCapableWallet;
+  #spendCapabilityWarningDelayMs;
+  #spendCapabilityWarning;
+  #closed = false;
+  constructor(options) {
+    this.#connectionString = options.connectionString;
+    this.#connection = parseNwcUri(options.connectionString);
+    this.connection = {
+      walletPubkey: this.#connection.walletPubkey,
+      relays: [...this.#connection.relays],
+      ...this.#connection.lud16 === void 0 ? {} : { lud16: this.#connection.lud16 },
+      redacted: this.#connection.redacted
+    };
+    this.#client = options.client;
+    this.#clientFactory = options.clientFactory;
+    this.#requirePreflight = options.requirePreflight ?? true;
+    this.#logger = options.logger;
+    this.#allowSpendCapableWallet = options.allowSpendCapableWallet ?? false;
+    this.#spendCapabilityWarningDelayMs = options.spendCapabilityWarningDelayMs ?? 0;
+    this.#spendCapabilityWarning = options.spendCapabilityWarning ?? ((message) => {
+      if (this.#logger === void 0) console.error(message);
+      else this.#log("error", "nwc.spend_capability_warning", message);
+    });
+  }
+  #log(level, event, message, fields = {}) {
+    if (this.#logger === void 0) return;
+    try {
+      this.#logger({
+        level,
+        event,
+        message,
+        wallet_pubkey: this.connection.walletPubkey,
+        ...fields
+      });
+    } catch {
+    }
+  }
+  async preflight() {
+    const client = await this.getClient();
+    const hasGetInfo = typeof client.getInfo === "function" || typeof client.get_info === "function";
+    const hasInfoEvent = typeof client.getWalletServiceInfo === "function";
+    const rawInfo = hasGetInfo || !hasInfoEvent ? await this.#fetchWalletInfo(
+      "get_info",
+      () => callRequiredMethod(client, ["getInfo", "get_info"], {})
+    ) : void 0;
+    const rawServiceInfo = hasInfoEvent ? await this.#fetchWalletInfo(
+      "info_event",
+      () => client.getWalletServiceInfo()
+    ) : void 0;
+    if (rawInfo === void 0) {
+      this.#log(
+        "warn",
+        "nwc.info_event.methods_fallback",
+        "NWC client exposes no get_info; proving receive-only from the service-wide info event (kind 13194) rather than this connection's own method list."
+      );
+    }
+    const summary = summarizeWalletCapabilities(
+      this.#connection,
+      rawInfo ?? rawServiceInfo,
+      rawServiceInfo
+    );
+    this.#log("debug", "nwc.preflight.summarized", "NWC wallet capabilities summarized.", {
+      methods_source: rawInfo === void 0 ? "info_event" : "get_info",
+      methods: summary.methods,
+      encryption: summary.encryption,
+      receive_checkout_ready: summary.receiveCheckoutReady,
+      spend_capability_advertised: summary.spendCapabilityAdvertised
+    });
+    if (!summary.receiveCheckoutReady) {
+      throw new WalletPreflightError(
+        "missing_required_method",
+        "NWC wallet must advertise make_invoice and list_transactions for receive checkout.",
+        summary
+      );
+    }
+    if (summary.encryption !== "nip04" && summary.encryption !== "nip44_v2") {
+      throw new WalletPreflightError(
+        "unsupported_encryption",
+        "NWC wallet must support NIP-04 or NIP-44 v2 encryption.",
+        summary
+      );
+    }
+    if (summary.spendCapabilityAdvertised) {
+      const spendMethods = spendMethodsIn(summary.methods);
+      if (!this.#allowSpendCapableWallet) {
+        this.#log(
+          "error",
+          "nwc.spend_capability_advertised",
+          "NWC connection advertises send-payment methods; refusing to boot without an explicit override.",
+          { methods: spendMethods }
+        );
+        throw new WalletPreflightError(
+          "spend_capability_advertised",
+          formatSpendCapabilityRefusedMessage({ spendMethods }),
+          summary
+        );
+      }
+      const warning = formatSpendCapabilityWarningMessage({
+        spendMethods
+      });
+      this.#log(
+        "error",
+        "nwc.spend_capability_advertised",
+        "NWC connection advertises send-payment methods; continuing because the spend-capable override is set.",
+        { methods: spendMethods }
+      );
+      try {
+        this.#spendCapabilityWarning(warning);
+      } catch {
+      }
+      if (this.#spendCapabilityWarningDelayMs > 0) {
+        await delay(this.#spendCapabilityWarningDelayMs);
+      }
+    }
+    this.#preflightSummary = summary;
+    return summary;
+  }
+  async makeInvoice(request) {
+    await this.ensurePreflight();
+    validateMakeInvoiceRequest(request);
+    this.#log(
+      "debug",
+      "nwc.make_invoice.requested",
+      "Calling NWC wallet make_invoice.",
+      compact({
+        method: "make_invoice",
+        // String form: msats above 2^53 would silently round through Number().
+        amount_msats: request.amount_msats.toString(),
+        expiry: request.expiry,
+        has_description: request.description !== void 0,
+        has_description_hash: request.description_hash !== void 0
+      })
+    );
+    const startedAt = Date.now();
+    let rawResult;
+    try {
+      rawResult = await callRequiredMethod(
+        await this.getClient(),
+        ["makeInvoice", "make_invoice"],
+        toNip47MakeInvoiceParams(request)
+      );
+    } catch (error) {
+      const normalized = normalizeNwcWalletError(error);
+      this.#log("error", "nwc.make_invoice.failed", "NWC wallet make_invoice failed.", {
+        method: "make_invoice",
+        duration_ms: Date.now() - startedAt,
+        error_code: normalized.code,
+        error_message: normalized.message
+      });
+      throw normalized;
+    }
+    let result;
+    try {
+      result = normalizeMakeInvoiceResult(rawResult);
+    } catch (error) {
+      const normalized = normalizeNwcWalletError(error);
+      this.#log("error", "nwc.make_invoice.failed", "NWC wallet make_invoice failed.", {
+        method: "make_invoice",
+        duration_ms: Date.now() - startedAt,
+        error_code: normalized.code,
+        error_message: normalized.message
+      });
+      throw normalized;
+    }
+    this.#log("debug", "nwc.make_invoice.completed", "NWC wallet make_invoice completed.", {
+      method: "make_invoice",
+      duration_ms: Date.now() - startedAt,
+      payment_hash: result.payment_hash,
+      amount_msats: result.amount_msats.toString()
+    });
+    return result;
+  }
+  async listTransactions(request) {
+    await this.ensurePreflight();
+    validateListTransactionsRequest(request);
+    this.#log(
+      "debug",
+      "nwc.list_transactions.requested",
+      "Calling NWC wallet list_transactions.",
+      compact({
+        method: "list_transactions",
+        from: request.from,
+        until: request.until,
+        limit: request.limit,
+        offset: request.offset,
+        unpaid: request.unpaid,
+        type: request.type
+      })
+    );
+    const startedAt = Date.now();
+    let rawResult;
+    try {
+      rawResult = await callRequiredMethod(
+        await this.getClient(),
+        ["listTransactions", "list_transactions"],
+        toNip47ListTransactionsParams(request)
+      );
+    } catch (error) {
+      const normalized = normalizeNwcWalletError(error);
+      this.#log("error", "nwc.list_transactions.failed", "NWC wallet list_transactions failed.", {
+        method: "list_transactions",
+        duration_ms: Date.now() - startedAt,
+        error_code: normalized.code,
+        error_message: normalized.message
+      });
+      throw normalized;
+    }
+    let result;
+    try {
+      result = normalizeListTransactionsResult(rawResult);
+    } catch (error) {
+      const normalized = normalizeNwcWalletError(error);
+      this.#log("error", "nwc.list_transactions.failed", "NWC wallet list_transactions failed.", {
+        method: "list_transactions",
+        duration_ms: Date.now() - startedAt,
+        error_code: normalized.code,
+        error_message: normalized.message
+      });
+      throw normalized;
+    }
+    if (result.skippedRows > 0) {
+      this.#log(
+        "warn",
+        "nwc.list_transactions.rows_skipped",
+        "Skipped wallet transaction rows that could not be normalized.",
+        {
+          method: "list_transactions",
+          skipped_count: result.skippedRows
+        }
+      );
+    }
+    this.#log(
+      "debug",
+      "nwc.list_transactions.completed",
+      "NWC wallet list_transactions completed.",
+      {
+        method: "list_transactions",
+        duration_ms: Date.now() - startedAt,
+        transaction_count: result.transactions.length
+      }
+    );
+    return {
+      transactions: result.transactions,
+      ...result.skippedRows === 0 ? {} : { skippedRows: result.skippedRows }
+    };
+  }
+  /**
+   * Opt-in NWC-02 notification subscription, limited to `payment_received`.
+   * Notifications are authenticated wallet data: the handler receives the
+   * payload normalized like a `list_transactions` row so a payload satisfying
+   * the settlement rule can settle its pending attempt directly, while
+   * anything less only wakes reconciliation. Direct settlement assumes the
+   * client binds notification decryption to the connection's wallet pubkey
+   * (the bundled @getalby/sdk does). Resolves to an unsubscribe function.
+   * Throws an OpenReceiveError with code `UNSUPPORTED_METHOD` when the
+   * underlying wallet client does not support NWC notifications.
+   */
+  async subscribeNotifications(handler) {
+    const client = await this.getClient();
+    const subscribe = client.subscribeNotifications;
+    if (typeof subscribe !== "function") {
+      throw new OpenReceiveError2({
+        code: "UNSUPPORTED_METHOD",
+        message: "NWC wallet client does not support NWC notifications (subscribeNotifications). Keep polling reconciliation.",
+        retryable: false
+      });
+    }
+    this.#log(
+      "debug",
+      "nwc.notifications.subscribe.requested",
+      "Subscribing to NWC-02 payment_received notifications.",
+      { notification_types: ["payment_received"] }
+    );
+    let subscription;
+    try {
+      subscription = await subscribe.call(
+        client,
+        (rawNotification) => {
+          const notification = normalizeNwcNotification(rawNotification);
+          if (notification.type !== "payment_received") return;
+          this.#log(
+            "debug",
+            "nwc.notifications.received",
+            "NWC payment_received notification received.",
+            compact({
+              notification_type: notification.type,
+              payment_hash: notification.payment_hash
+            })
+          );
+          try {
+            handler(notification);
+          } catch {
+          }
+        },
+        ["payment_received"]
+      );
+    } catch (error) {
+      const normalized = normalizeNwcWalletError(error);
+      this.#log(
+        "error",
+        "nwc.notifications.subscribe.failed",
+        "NWC notification subscription failed.",
+        { error_code: normalized.code, error_message: normalized.message }
+      );
+      throw normalized;
+    }
+    this.#log(
+      "info",
+      "nwc.notifications.subscribe.completed",
+      "Subscribed to NWC-02 payment_received notifications; polling reconciliation remains the safety net."
+    );
+    return async () => {
+      await closeNwcNotificationSubscription(subscription);
+      this.#log(
+        "info",
+        "nwc.notifications.unsubscribed",
+        "Unsubscribed from NWC-02 wallet notifications."
+      );
+    };
+  }
+  async #fetchWalletInfo(source, call) {
+    const method = source === "get_info" ? "get_info" : "getWalletServiceInfo";
+    const label = source === "get_info" ? "get_info" : "info event (kind 13194)";
+    this.#log("debug", `nwc.${source}.requested`, `Fetching NWC wallet ${label}.`, { method });
+    const startedAt = Date.now();
+    try {
+      const raw = await call();
+      this.#log("debug", `nwc.${source}.completed`, `NWC wallet ${label} loaded.`, {
+        method,
+        duration_ms: Date.now() - startedAt
+      });
+      return raw;
+    } catch (error) {
+      const normalized = normalizeNwcWalletError(error);
+      this.#log("error", `nwc.${source}.failed`, `NWC wallet ${label} fetch failed.`, {
+        method,
+        duration_ms: Date.now() - startedAt,
+        error_code: normalized.code,
+        error_message: normalized.message
+      });
+      throw normalized;
+    }
+  }
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    const client = this.#client ?? await this.#clientPromise?.catch(() => void 0);
+    this.#client = void 0;
+    this.#clientPromise = void 0;
+    await client?.close?.();
+  }
+  async ensurePreflight() {
+    if (!this.#requirePreflight || this.#preflightSummary !== void 0) return;
+    this.#preflightPromise ??= this.preflight();
+    try {
+      await this.#preflightPromise;
+    } catch (error) {
+      this.#preflightPromise = void 0;
+      throw error;
+    }
+  }
+  async getClient() {
+    if (this.#closed) {
+      throw new Error("OpenReceive NWC receive client is closed; create a new client.");
+    }
+    if (this.#client !== void 0) return this.#client;
+    this.#clientPromise ??= (async () => {
+      const client = this.#clientFactory !== void 0 ? await this.#clientFactory(this.#connection) : await createDefaultAlbyNwcClient(this.#connectionString);
+      this.#client = client;
+      return client;
+    })();
+    try {
+      return await this.#clientPromise;
+    } catch (error) {
+      this.#clientPromise = void 0;
+      throw error;
+    }
+  }
+};
+function createNwcReceiveClient(options) {
+  return new AlbyNwcReceiveClient(options);
+}
+
+// src/service.ts
+import {
+  formatInvalidNwcMessage,
+  formatMissingNwcMessage,
+  NwcUriParseError,
+  OPENRECEIVE_NWC_CODE_HELP_URL,
+  OpenReceiveError as OpenReceiveError3,
+  parseNwcUri as parseNwcUri2,
+  reconcilePaymentAttempts,
+  unixSeconds
+} from "@openreceive/core";
+
+// src/config-error.ts
+var ConfigError = class extends Error {
+  code;
+  hint;
+  cause;
+  constructor(input) {
+    super(input.message);
+    this.name = "ConfigError";
+    this.code = input.code;
+    this.hint = input.hint;
+    this.cause = input.cause;
+  }
+};
+
+// src/service/file-logger.ts
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync } from "fs";
+import { appendFile } from "fs/promises";
+import path from "path";
+import { compact as compact3 } from "@openreceive/core";
+
+// src/console-logger.ts
+import { compact as compact2 } from "@openreceive/core";
+
+// src/log-level.ts
+var LOG_LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var LOG_LEVEL_ALIASES = {
+  debug: "debug",
+  info: "info",
+  warn: "warn",
+  warning: "warn",
+  error: "error"
+};
+function logLevelOrder(level) {
+  return LOG_LEVEL_ORDER[level];
+}
+function parseLogLevel(value) {
+  if (value === void 0 || value === null) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized.length === 0) return void 0;
+  return LOG_LEVEL_ALIASES[normalized];
+}
+function resolveLogLevel(value, fallback = "info") {
+  return parseLogLevel(value) ?? fallback;
+}
+function readLogLevelFromEnvironment(env = process.env) {
+  return resolveLogLevel(env.LOG_LEVEL);
+}
+
+// src/console-logger.ts
+function createConsoleLogger(options = {}) {
+  const prefix = options.prefix ?? "openreceive";
+  const target = options.console ?? console;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return (entry) => {
+    const minLevel = options.minLevel === void 0 ? readLogLevelFromEnvironment() : resolveLogLevel(options.minLevel);
+    if (logLevelOrder(entry.level) < logLevelOrder(minLevel)) return;
+    const { level, event, message, ...fields } = entry;
+    const method = level === "error" ? "error" : level === "warn" ? "warn" : level === "debug" ? "debug" : "info";
+    const sink = target[method] ?? target.log;
+    sink.call(
+      target,
+      formatConsoleLogLine({
+        at: now().toISOString(),
+        level,
+        prefix,
+        event,
+        message
+      }),
+      compact2(fields)
+    );
+  };
+}
+function createAppConsoleLogger(options) {
+  const target = options.console ?? console;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return (event, message, fields = {}, level = "info") => {
+    const minLevel = options.minLevel === void 0 ? readLogLevelFromEnvironment() : resolveLogLevel(options.minLevel);
+    if (logLevelOrder(level) < logLevelOrder(minLevel)) return;
+    const method = level === "error" ? "error" : level === "warn" ? "warn" : level === "debug" ? "debug" : "info";
+    const sink = target[method] ?? target.log;
+    sink.call(
+      target,
+      formatConsoleLogLine({
+        at: now().toISOString(),
+        level,
+        prefix: options.prefix,
+        event,
+        message
+      }),
+      compact2(fields)
+    );
+  };
+}
+function formatConsoleLogLine(input) {
+  return `[${input.at}] ${input.level.toUpperCase()} [${input.prefix}] ${input.event}: ${input.message}`;
+}
+
+// src/service/file-logger.ts
+var OPENRECEIVE_LOGGING_DEFAULTS = {
+  enabled: false,
+  directory: "./logs",
+  filename: "openreceive.log",
+  maxFileSizeMb: 10,
+  maxFiles: 5,
+  level: "info"
+};
+function createFileLogger(config) {
+  const logPath = path.join(config.directory, config.filename);
+  let initialized = false;
+  let currentBytes = 0;
+  let buffered = [];
+  let draining;
+  let scheduled;
+  let exitHooked = false;
+  const ensureReady = () => {
+    if (initialized) return;
+    initialized = true;
+    mkdirSync(config.directory, { recursive: true });
+    currentBytes = existsSync(logPath) ? statSync(logPath).size : 0;
+  };
+  const rotate = () => {
+    if (config.maxFiles <= 1) {
+      if (existsSync(logPath)) unlinkSync(logPath);
+      currentBytes = 0;
+      return;
+    }
+    const oldest = `${logPath}.${config.maxFiles - 1}`;
+    if (existsSync(oldest)) unlinkSync(oldest);
+    for (let index = config.maxFiles - 2; index >= 1; index--) {
+      const from = `${logPath}.${index}`;
+      if (existsSync(from)) renameSync(from, `${logPath}.${index + 1}`);
+    }
+    if (existsSync(logPath)) renameSync(logPath, `${logPath}.1`);
+    currentBytes = 0;
+  };
+  const write = async () => {
+    while (buffered.length > 0) {
+      const lines = buffered;
+      buffered = [];
+      try {
+        ensureReady();
+        let batch = "";
+        for (const line of lines) {
+          const lineBytes = Buffer.byteLength(line);
+          if (currentBytes > 0 && currentBytes + lineBytes > config.maxFileSizeBytes) {
+            if (batch.length > 0) await appendFile(logPath, batch);
+            batch = "";
+            rotate();
+          }
+          batch += line;
+          currentBytes += lineBytes;
+        }
+        if (batch.length > 0) await appendFile(logPath, batch);
+      } catch {
+      }
+    }
+  };
+  const drain = () => {
+    draining ??= write().finally(() => {
+      draining = void 0;
+    });
+    return draining;
+  };
+  const drainSync = () => {
+    if (buffered.length === 0) return;
+    const lines = buffered;
+    buffered = [];
+    try {
+      ensureReady();
+      appendFileSync(logPath, lines.join(""));
+    } catch {
+    }
+  };
+  const schedule = () => {
+    if (!exitHooked) {
+      exitHooked = true;
+      process.once("exit", drainSync);
+    }
+    if (scheduled !== void 0) return;
+    scheduled = setTimeout(() => {
+      scheduled = void 0;
+      void drain();
+    }, 0);
+    scheduled.unref();
+  };
+  const logger = (entry) => {
+    if (logLevelOrder(entry.level) < logLevelOrder(config.minLevel)) return;
+    const { level: entryLevel, event, message, ...rest } = entry;
+    buffered.push(
+      `${JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: entryLevel,
+        event,
+        message,
+        ...rest
+      })}
+`
+    );
+    schedule();
+  };
+  logger.flush = async () => {
+    while (buffered.length > 0 || draining !== void 0) {
+      await drain();
+    }
+  };
+  return logger;
+}
+function createFileLoggerFromConfig(config) {
+  if ((config?.enabled ?? OPENRECEIVE_LOGGING_DEFAULTS.enabled) !== true) return void 0;
+  const defaults = OPENRECEIVE_LOGGING_DEFAULTS;
+  const maxFileSizeMb = config?.maxFileSizeMb ?? defaults.maxFileSizeMb;
+  const maxFiles = config?.maxFiles ?? defaults.maxFiles;
+  return createFileLogger({
+    directory: config?.directory ?? defaults.directory,
+    filename: config?.filename ?? defaults.filename,
+    maxFileSizeBytes: Math.max(1024, Math.round(maxFileSizeMb * 1024 * 1024)),
+    maxFiles: Math.max(1, Math.floor(maxFiles)),
+    minLevel: parseLogLevel(config?.level) ?? readLogLevelFromEnvironment()
+  });
+}
+function composeLoggers(...loggers) {
+  const active = loggers.filter((logger) => logger !== void 0);
+  if (active.length === 0) return void 0;
+  if (active.length === 1) return active[0];
+  return (entry) => {
+    for (const logger of active) {
+      try {
+        logger(entry);
+      } catch {
+      }
+    }
+  };
+}
+function attachLogging(options) {
+  const fileLogger = createFileLoggerFromConfig(options.logging);
+  const consoleEnabled = options.logging?.console ?? options.logger === void 0;
+  const consoleLogger = consoleEnabled ? createConsoleLogger(
+    compact3({
+      prefix: options.logging?.prefix ?? "openreceive",
+      minLevel: options.logging?.level
+    })
+  ) : void 0;
+  const logger = composeLoggers(options.logger, consoleLogger, fileLogger);
+  return logger === void 0 ? options : { ...options, logger };
+}
+
+// src/service/checkouts.ts
+import { OPENRECEIVE_NWC_METADATA_MAX_BYTES as OPENRECEIVE_NWC_METADATA_MAX_BYTES2 } from "@openreceive/core";
+
+// src/service/requests.ts
+import { isBitcoinAmountCurrency, isRecord as isRecord2, nonEmptyString as nonEmptyString2 } from "@openreceive/core";
+
+// src/service/core-utils.ts
+import { isRecord } from "@openreceive/core";
+var ServiceError = class extends Error {
+  status;
+  code;
+  body;
+  constructor(status, body) {
+    super(body.message);
+    this.name = "ServiceError";
+    this.status = status;
+    this.code = body.code;
+    this.body = body;
+  }
+};
+function asRecord(value) {
+  if (value === void 0) return {};
+  if (!isRecord(value)) {
+    throw serviceError(400, "INVALID_REQUEST", "Input must be an object.");
+  }
+  return value;
+}
+function parseOptionalRecord(value, field) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) {
+    throw serviceError(400, "INVALID_REQUEST", `${field} must be a JSON object.`);
+  }
+  return value;
+}
+function serviceError(status, code, message, options = {}) {
+  return new ServiceError(status, {
+    code,
+    message,
+    ...options.retryable === void 0 ? {} : { retryable: options.retryable }
+  });
+}
+
+// src/service/requests.ts
+function createAmountRequest(amount) {
+  if ("sats" in amount) {
+    return { amount: { currency: "SATS", value: normalizeSatsValue(amount.sats) } };
+  }
+  if (isBitcoinAmountCurrency(amount.currency)) {
+    return { amount: { currency: amount.currency, value: amount.value } };
+  }
+  return { fiat: { currency: amount.currency, value: amount.value } };
+}
+var CREATE_CHECKOUT_REQUEST_FIELDS = [
+  "reference",
+  "amount",
+  "memo",
+  "descriptionHash",
+  "metadata",
+  "expirySeconds"
+];
+function normalizeCreateCheckoutRequest(input) {
+  const body = asRecord(input);
+  for (const key of Object.keys(body)) {
+    if (!CREATE_CHECKOUT_REQUEST_FIELDS.includes(key)) {
+      throw serviceError(400, "INVALID_REQUEST", `Unexpected create checkout field: ${key}.`);
+    }
+  }
+  const reference = nonEmptyString2(body.reference);
+  if (reference === void 0) throw serviceError(400, "INVALID_REQUEST", "reference is required.");
+  if (reference.length > 200) {
+    throw serviceError(400, "INVALID_REQUEST", "reference must be 200 characters or fewer.");
+  }
+  const amount = normalizeCreateCheckoutAmount(body.amount);
+  const memo = nonEmptyString2(body.memo);
+  const descriptionHash = nonEmptyString2(body.descriptionHash);
+  getCreateDescriptionFields({ memo, descriptionHash });
+  const metadata = parseOptionalRecord(body.metadata, "metadata");
+  const expirySeconds = body.expirySeconds;
+  if (expirySeconds !== void 0 && (!Number.isSafeInteger(expirySeconds) || expirySeconds <= 0)) {
+    throw serviceError(400, "INVALID_REQUEST", "expirySeconds must be a positive safe integer.");
+  }
+  return {
+    reference,
+    amount,
+    ...memo === void 0 ? {} : { memo },
+    ...descriptionHash === void 0 ? {} : { descriptionHash },
+    ...metadata === void 0 ? {} : { metadata },
+    ...expirySeconds === void 0 ? {} : { expirySeconds }
+  };
+}
+function normalizeCreateCheckoutAmount(value) {
+  if (!isRecord2(value)) {
+    throw serviceError(400, "INVALID_REQUEST", "amount must be { sats } or { currency, value }.");
+  }
+  const keys = Object.keys(value);
+  if ("sats" in value && value.sats !== void 0 && keys.every((key) => key === "sats")) {
+    return { sats: normalizeSatsValue(value.sats) };
+  }
+  if (keys.some((key) => key !== "currency" && key !== "value")) {
+    throw serviceError(400, "INVALID_REQUEST", "amount contains unsupported fields.");
+  }
+  const currency = nonEmptyString2(value.currency);
+  const amountValue = nonEmptyString2(value.value);
+  if (currency === void 0 || amountValue === void 0) {
+    throw serviceError(400, "INVALID_REQUEST", "amount must be { sats } or { currency, value }.");
+  }
+  if (!isBitcoinAmountCurrency(currency) && !/^[A-Z]{3}$/.test(currency)) {
+    throw serviceError(
+      400,
+      "INVALID_REQUEST",
+      "amount.currency must be uppercase ISO 4217, BTC, SAT, or SATS."
+    );
+  }
+  if (!/^[0-9]+(?:\.[0-9]+)?$/.test(amountValue) || /^0+(?:\.0+)?$/.test(amountValue)) {
+    throw serviceError(400, "INVALID_REQUEST", "amount.value must be a positive decimal string.");
+  }
+  return { currency, value: amountValue };
+}
+function normalizeSatsValue(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) return String(value);
+  if (typeof value === "string" && /^[0-9]+$/.test(value) && BigInt(value) > 0n) return value;
+  throw serviceError(400, "INVALID_REQUEST", "sats must be a positive integer.");
+}
+function getCreateDescriptionFields(input) {
+  const memo = nonEmptyString2(input.memo);
+  const descriptionHash = nonEmptyString2(input.descriptionHash);
+  if (memo !== void 0 && memo.length > 500) {
+    throw serviceError(400, "INVALID_REQUEST", "memo must be 500 characters or fewer.");
+  }
+  if (memo !== void 0 && descriptionHash !== void 0) {
+    throw serviceError(400, "INVALID_REQUEST", "Use only one of memo or descriptionHash.");
+  }
+  if (descriptionHash !== void 0 && !HEX_64.test(descriptionHash)) {
+    throw serviceError(400, "INVALID_REQUEST", "descriptionHash must be 64 hex characters.");
+  }
+  return {
+    ...memo === void 0 ? {} : { description: memo },
+    ...descriptionHash === void 0 ? {} : { description_hash: descriptionHash }
+  };
+}
+
+// src/service/pricing.ts
+import {
+  createCachedLivePriceFeed,
+  getBtcFiatRatesWithFallback,
+  isResolvedPriceProvider,
+  OPENRECEIVE_PRICE_FEED_FALLBACK_URL_ENV,
+  OPENRECEIVE_PRICE_FEED_PRIMARY_URL_ENV,
+  nonEmptyString as nonEmptyString3,
+  quoteBitcoinAmountToMsats,
+  quoteFiatToMsatsWithPrice
+} from "@openreceive/core";
+async function listRates(context, input = {}) {
+  const currencies = input.currencies === void 0 ? context.priceCurrencies : payerPriceCurrencies(input.currencies);
+  try {
+    for (const currency of currencies) {
+      assertAllowedFiatCurrency(currency, context.priceCurrencies);
+    }
+    const rates = await fetchRatesOrUnavailable({
+      currencies,
+      priceProviders: context.priceProviders
+    });
+    return rates.rates;
+  } catch (error) {
+    throw mapPriceError(error);
+  }
+}
+async function quoteRates(context, input) {
+  const body = asRecord(input);
+  try {
+    const fiat = parseFiatAmount(body.fiat);
+    assertAllowedFiatCurrency(fiat.currency, context.priceCurrencies);
+    return await quoteFiatAmount({
+      fiat,
+      asOf: context.clock(),
+      priceProviders: context.priceProviders
+    });
+  } catch (error) {
+    throw mapPriceError(error);
+  }
+}
+function payerPriceCurrencies(rawCurrencies) {
+  try {
+    return normalizePriceCurrencies(rawCurrencies, "currencies");
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw serviceError(400, "INVALID_REQUEST", error.message);
+    }
+    throw error;
+  }
+}
+function readPriceCurrencies(configured) {
+  const rawCurrencies = configured ?? ["USD"];
+  return normalizePriceCurrencies(rawCurrencies, "OpenReceive price currencies");
+}
+function normalizePriceCurrencies(rawCurrencies, label) {
+  const currencies = [
+    ...new Set(rawCurrencies.map((currency) => currency.trim().toUpperCase()).filter(Boolean))
+  ];
+  if (currencies.length === 0) {
+    throw new ConfigError({
+      code: "INVALID_PRICE_CURRENCIES",
+      message: `${label} must include at least one currency.`,
+      hint: "Set priceCurrencies to fiat codes like USD and EUR, or omit it to use USD."
+    });
+  }
+  for (const currency of currencies) {
+    if (!/^[A-Z]{3}$/.test(currency)) {
+      throw new ConfigError({
+        code: "INVALID_PRICE_CURRENCIES",
+        message: `Invalid ${label} entry: ${currency}.`,
+        hint: "Use three-letter fiat currency codes such as USD or EUR."
+      });
+    }
+  }
+  return currencies;
+}
+async function resolveCreateAmount(input) {
+  const { body } = input;
+  const hasAmount = body.amount !== void 0;
+  const hasFiat = body.fiat !== void 0;
+  const sourceCount = [hasAmount, hasFiat].filter(Boolean).length;
+  if (sourceCount !== 1) {
+    throw serviceError(
+      400,
+      "INVALID_REQUEST",
+      "Create checkout request requires exactly one of amount or fiat."
+    );
+  }
+  if (hasAmount) {
+    try {
+      const quote = quoteBitcoinAmountToMsats(parseBitcoinAmount(body.amount));
+      return {
+        amountMsats: quote.amountMsats,
+        amountSource: "amount",
+        fiatQuote: null
+      };
+    } catch (error) {
+      if (error instanceof ServiceError) throw error;
+      throw mapPriceError(error);
+    }
+  }
+  try {
+    const fiat = parseFiatAmount(body.fiat);
+    assertAllowedFiatCurrency(fiat.currency, input.priceCurrencies);
+    const quote = await quoteFiatAmount({
+      fiat,
+      asOf: input.now,
+      priceProviders: input.priceProviders
+    });
+    return {
+      amountMsats: quote.amountMsats,
+      amountSource: "fiat",
+      fiatQuote: quote
+    };
+  } catch (error) {
+    if (error instanceof ServiceError) throw error;
+    throw mapPriceError(error);
+  }
+}
+async function quoteFiatAmount(input) {
+  const rates = await fetchRatesOrUnavailable({
+    currencies: [input.fiat.currency],
+    priceProviders: input.priceProviders
+  });
+  const btcFiatPrice = rates.rates.bitcoin[input.fiat.currency.toLowerCase()];
+  if (btcFiatPrice === void 0) {
+    throw ratesUnavailableError(
+      `price provider ${rates.source} did not return ${input.fiat.currency}`
+    );
+  }
+  return quoteFiatToMsatsWithPrice({
+    fiat: input.fiat,
+    btcFiatPrice,
+    source: rates.source,
+    asOf: input.asOf
+  });
+}
+function assertAllowedFiatCurrency(currency, allowedCurrencies) {
+  if (!allowedCurrencies.includes(currency)) {
+    throw serviceError(
+      400,
+      "INVALID_REQUEST",
+      `fiat.currency must be one of the configured priceCurrencies: ${allowedCurrencies.join(", ")}.`
+    );
+  }
+}
+async function fetchRatesOrUnavailable(input) {
+  try {
+    return await getBtcFiatRatesForProviders(input);
+  } catch (error) {
+    if (error instanceof ServiceError) throw error;
+    throw ratesUnavailableError(error instanceof Error ? error.message : void 0);
+  }
+}
+async function getBtcFiatRatesForProviders(input) {
+  if (input.priceProviders.length === 1) {
+    const [provider] = input.priceProviders;
+    if (isResolvedPriceProvider(provider)) {
+      return await provider.getBtcFiatRatesWithSource(input.currencies);
+    }
+    return {
+      source: provider.source,
+      rates: await provider.getBtcFiatRates(input.currencies)
+    };
+  }
+  return getBtcFiatRatesWithFallback({
+    currencies: input.currencies,
+    providers: input.priceProviders
+  });
+}
+function createPriceFeed(options) {
+  const overrides = readPriceFeedUrlOverrides(options.env);
+  return createCachedLivePriceFeed({
+    currencies: options.currencies,
+    fetch: options.fetch,
+    clock: options.clock,
+    cacheSeconds: options.cacheSeconds,
+    primaryUrl: overrides.primaryUrl,
+    fallbackUrl: overrides.fallbackUrl
+  });
+}
+function readPriceFeedUrlOverrides(env) {
+  return {
+    primaryUrl: readPriceFeedUrlEnv(OPENRECEIVE_PRICE_FEED_PRIMARY_URL_ENV, env),
+    fallbackUrl: readPriceFeedUrlEnv(OPENRECEIVE_PRICE_FEED_FALLBACK_URL_ENV, env)
+  };
+}
+function readPriceFeedUrlEnv(name, env = globalThis.process?.env) {
+  const value = env?.[name];
+  if (value === void 0 || value.trim().length === 0) return void 0;
+  return value.trim();
+}
+function ratesUnavailableError(internalDetail) {
+  const error = serviceError(
+    503,
+    "INTERNAL",
+    "Exchange rates are temporarily unavailable \u2014 please try again in a moment.",
+    { retryable: true }
+  );
+  if (internalDetail !== void 0) error.cause = new Error(internalDetail);
+  return error;
+}
+function mapPriceError(error) {
+  if (error instanceof ServiceError) return error;
+  if (error instanceof RangeError) {
+    return serviceError(400, "INVALID_REQUEST", error.message);
+  }
+  return ratesUnavailableError(error instanceof Error ? error.message : void 0);
+}
+function parseFiatAmount(value) {
+  const record = parseOptionalRecord(value, "fiat");
+  if (record === void 0) {
+    throw serviceError(400, "INVALID_REQUEST", "fiat must be a JSON object.");
+  }
+  const currency = nonEmptyString3(record.currency);
+  const amountValue = nonEmptyString3(record.value);
+  if (currency === void 0 || !/^[A-Z]{3}$/.test(currency)) {
+    throw serviceError(400, "INVALID_REQUEST", "fiat.currency must be an ISO 4217 uppercase code");
+  }
+  if (amountValue === void 0) {
+    throw serviceError(400, "INVALID_REQUEST", "fiat.value must be a decimal string");
+  }
+  return {
+    currency,
+    value: amountValue
+  };
+}
+function parseBitcoinAmount(value) {
+  const record = parseOptionalRecord(value, "amount");
+  if (record === void 0) {
+    throw serviceError(400, "INVALID_REQUEST", "amount must be a JSON object.");
+  }
+  const currency = nonEmptyString3(record.currency);
+  const amountValue = nonEmptyString3(record.value);
+  if (currency === void 0 || !["BTC", "SAT", "SATS"].includes(currency)) {
+    throw serviceError(
+      400,
+      "INVALID_REQUEST",
+      "amount.currency must be BTC, SAT, or SATS. Use fiat for price-feed currencies."
+    );
+  }
+  if (amountValue === void 0) {
+    throw serviceError(400, "INVALID_REQUEST", "amount.value must be a decimal string");
+  }
+  return {
+    currency,
+    value: amountValue
+  };
+}
+
+// src/service/checkouts.ts
+var OPENRECEIVE_INVOICE_EXPIRY_SECONDS = 10 * 60;
+var OPENRECEIVE_INVOICE_EXPIRY_TOLERANCE_SECONDS = 60;
+async function prepareCheckout(context, input) {
+  const resolved = await resolveCreateAmount({
+    body: createAmountRequest(normalizeCreateCheckoutAmount(input.amount)),
+    now: context.clock(),
+    priceProviders: context.priceProviders,
+    priceCurrencies: context.priceCurrencies
+  });
+  return {
+    amountMsats: resolved.amountMsats,
+    fiatQuote: resolved.fiatQuote
+  };
+}
+async function createCheckout(context, request) {
+  const input = normalizeCreateCheckoutRequest(request);
+  const now = context.clock();
+  const resolved = await resolveCreateAmount({
+    body: createAmountRequest(input.amount),
+    now,
+    priceProviders: context.priceProviders,
+    priceCurrencies: context.priceCurrencies
+  });
+  const expiry = input.expirySeconds ?? OPENRECEIVE_INVOICE_EXPIRY_SECONDS;
+  const metadata = {
+    ...input.metadata ?? {},
+    reference: input.reference
+  };
+  if (Buffer.byteLength(JSON.stringify(metadata), "utf8") > OPENRECEIVE_NWC_METADATA_MAX_BYTES2) {
+    throw serviceError(400, "INVALID_REQUEST", "metadata is too large for NIP-47.");
+  }
+  const walletInvoice = await context.options.client.makeInvoice({
+    amount_msats: BigInt(resolved.amountMsats),
+    ...getCreateDescriptionFields({
+      memo: input.memo,
+      descriptionHash: input.descriptionHash
+    }),
+    expiry,
+    metadata
+  });
+  const createdAt = walletInvoice.created_at ?? now;
+  const requestedExpiresAt = createdAt + expiry;
+  const expiresAt = walletInvoice.expires_at ?? requestedExpiresAt;
+  const shortfall = requestedExpiresAt - expiresAt;
+  if (Math.abs(expiresAt - requestedExpiresAt) > OPENRECEIVE_INVOICE_EXPIRY_TOLERANCE_SECONDS) {
+    const requiredFloor = input.expirySeconds !== void 0 && shortfall > OPENRECEIVE_INVOICE_EXPIRY_TOLERANCE_SECONDS;
+    emitLog(
+      context.options,
+      requiredFloor ? "error" : "warn",
+      requiredFloor ? "checkout.invoice_expiry.rejected" : "checkout.invoice_expiry.adjusted",
+      requiredFloor ? `The wallet did not honor the required invoice expiry (required ${expiry}s, got ${expiresAt - createdAt}s). Use a wallet whose make_invoice honors expiry.` : `The wallet clamped the requested invoice expiry (requested ${expiry}s, got ${expiresAt - createdAt}s); the wallet's own expiry is recorded on the attempt.`,
+      {
+        reference: input.reference,
+        payment_hash: walletInvoice.payment_hash.toLowerCase(),
+        requested_expiry_seconds: expiry,
+        actual_expiry_seconds: expiresAt - createdAt,
+        tolerance_seconds: OPENRECEIVE_INVOICE_EXPIRY_TOLERANCE_SECONDS
+      }
+    );
+    if (requiredFloor) {
+      throw serviceError(
+        502,
+        "UNSUPPORTED_METHOD",
+        "Error with the backing NWC wallet: it did not honor the requested invoice expiry."
+      );
+    }
+  }
+  return {
+    reference: input.reference,
+    paymentHash: walletInvoice.payment_hash.toLowerCase(),
+    bolt11: walletInvoice.invoice,
+    amountMsats: toSafeInteger(walletInvoice.amount_msats, "amount_msats"),
+    createdAt,
+    expiresAt,
+    fiatQuote: resolved.fiatQuote
+  };
+}
+function toSafeInteger(value, field) {
+  if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw serviceError(502, "INTERNAL", `${field} is outside the JSON safe integer range.`);
+  }
+  return Number(value);
+}
+
+// src/service/swaps.ts
+import { isValidSwapAddressForPayInAsset } from "@openreceive/core";
+
+// src/swap/state.ts
+var OPENRECEIVE_SWAP_STATES = {
+  creating_provider_order: {
+    state: "creating_provider_order",
+    label: "Preparing payment address",
+    detail: "Creating a payment address.",
+    phase: "preparing",
+    terminal: false
+  },
+  awaiting_deposit: {
+    state: "awaiting_deposit",
+    label: "Waiting for your payment",
+    detail: "Send exactly the amount shown below.",
+    phase: "awaiting_deposit",
+    terminal: false
+  },
+  confirming: {
+    state: "confirming",
+    label: "Confirming payment",
+    detail: "Your payment was detected and is confirming on-chain.",
+    phase: "processing",
+    terminal: false
+  },
+  exchanging: {
+    state: "exchanging",
+    label: "Converting payment",
+    detail: "Your payment is confirmed and being converted. This usually finishes within a minute.",
+    phase: "processing",
+    terminal: false
+  },
+  paying_invoice: {
+    state: "paying_invoice",
+    label: "Finalizing checkout",
+    detail: "The provider is sending the Lightning payment. This usually takes a few seconds.",
+    phase: "processing",
+    terminal: false
+  },
+  completed: {
+    state: "completed",
+    label: "Finalizing checkout",
+    detail: "The provider is sending the Lightning payment. This usually takes a few seconds.",
+    phase: "settling",
+    terminal: false
+  },
+  expired: {
+    state: "expired",
+    label: "Expired",
+    detail: "No payment was received before the payment window closed.",
+    phase: "terminal",
+    terminal: true
+  },
+  refund_required: {
+    state: "refund_required",
+    label: "Refund needed",
+    detail: "Enter an address you control to request a refund.",
+    phase: "refund",
+    terminal: false
+  },
+  refund_pending: {
+    state: "refund_pending",
+    label: "Refund pending",
+    detail: "Your refund request has been sent.",
+    phase: "refund",
+    terminal: false
+  },
+  refunded: {
+    state: "refunded",
+    label: "Refunded",
+    detail: "The provider reports the refund was sent.",
+    phase: "terminal",
+    terminal: true
+  },
+  attention: {
+    state: "attention",
+    label: "Needs attention",
+    detail: "This payment needs support review.",
+    phase: "attention",
+    terminal: true
+  },
+  failed: {
+    state: "failed",
+    label: "Failed",
+    detail: "This payment address can no longer be used.",
+    phase: "terminal",
+    terminal: true
+  }
+};
+
+// src/swap/weight-budget.ts
+import { compact as compact4 } from "@openreceive/core";
+var SWAP_PROVIDER_WEIGHT_WINDOW_SECONDS = 60;
+var SWAP_PROVIDER_WEIGHT_SOFT_CAP = 200;
+var SWAP_PROVIDER_CREATE_WEIGHT_GATE = 150;
+var SWAP_PROVIDER_CREATE_WEIGHT = 50;
+var SWAP_PROVIDER_DEFAULT_WEIGHT = 1;
+var SWAP_PROVIDER_WEIGHT_BACKOFF_SECONDS = 60;
+var SwapProviderWeightBudget = class {
+  constructor(providerId, now) {
+    this.providerId = providerId;
+    this.now = now;
+    this.#windowStart = now();
+  }
+  providerId;
+  now;
+  #windowStart;
+  #used = 0;
+  #backoffUntil;
+  weightForPath(path2) {
+    return path2 === "create" ? SWAP_PROVIDER_CREATE_WEIGHT : SWAP_PROVIDER_DEFAULT_WEIGHT;
+  }
+  async reserve(path2) {
+    this.#rollWindow();
+    const now = this.now();
+    const cost = this.weightForPath(path2);
+    const gate = this.#gate(path2);
+    if (this.#backoffUntil !== void 0 && this.#backoffUntil > now) {
+      this.#deny(
+        path2,
+        "backoff",
+        cost,
+        gate,
+        `Swap provider API is in backoff until ${this.#backoffUntil}.`
+      );
+    }
+    if (this.#used + cost > gate) {
+      this.#deny(
+        path2,
+        "exhausted",
+        cost,
+        gate,
+        `Swap provider API weight budget exhausted (${this.#used}+${cost} > ${gate}).`
+      );
+    }
+    this.#used += cost;
+  }
+  async markRateLimited() {
+    const now = this.now();
+    this.#used = Math.max(this.#used, SWAP_PROVIDER_WEIGHT_SOFT_CAP);
+    this.#backoffUntil = now + SWAP_PROVIDER_WEIGHT_BACKOFF_SECONDS;
+  }
+  // The weight window rolls; the 429 backoff does NOT ride along with it.
+  // Clearing it here cut a backoff arbitrarily short — markRateLimited() at
+  // second 59 of the window was forgiven one second later — so the backoff
+  // expires on its own clock, checked in reserve().
+  #rollWindow() {
+    const now = this.now();
+    if (now - this.#windowStart < SWAP_PROVIDER_WEIGHT_WINDOW_SECONDS) return;
+    this.#windowStart = now;
+    this.#used = 0;
+  }
+  #gate(path2) {
+    return path2 === "create" ? SWAP_PROVIDER_CREATE_WEIGHT_GATE : SWAP_PROVIDER_WEIGHT_SOFT_CAP;
+  }
+  // The denial carries its own diagnostics on the thrown error: there is no
+  // observer hook, because there was never a caller for one — the service maps
+  // a weight-budget throw to a retryable 503 and logs it there.
+  #deny(path2, reason, cost, gate, message) {
+    throw weightBudgetError(
+      message,
+      compact4({
+        provider: this.providerId,
+        path: path2,
+        reason,
+        message,
+        used: this.#used,
+        cost,
+        gate,
+        window_start: this.#windowStart,
+        backoff_until: this.#backoffUntil
+      })
+    );
+  }
+};
+function weightBudgetError(message, denial) {
+  const error = new Error(message);
+  Object.defineProperty(error, "weightBudget", { value: true });
+  Object.defineProperty(error, "denial", { value: denial, enumerable: true });
+  return error;
+}
+function isSwapProviderWeightBudgetError(error) {
+  return error instanceof Error && "weightBudget" in error && error.weightBudget === true;
+}
+
+// src/swap/transport-error.ts
+function isProviderApiError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const candidate = error;
+  return typeof candidate.kind === "string" && candidate.name === "FixedFloatApiError";
+}
+function classifySwapTransportFailure(error) {
+  if (isSwapProviderWeightBudgetError(error)) return "rate_limited";
+  if (!isProviderApiError(error)) return void 0;
+  if (error.kind === "rate_limited" || error.status === 429) return "rate_limited";
+  if (error.kind === "timeout" || error.kind === "network" || error.kind === "invalid_json" || error.status !== void 0 && error.status >= 500) {
+    return "unreachable";
+  }
+  return "refused";
+}
+
+// src/service/swaps.ts
+async function listSwapOptions(context, input) {
+  const providers = context.swapProviders;
+  if (providers.length === 0) {
+    emitLog(
+      context.options,
+      "debug",
+      "swap.options.resolved",
+      "No swap providers configured; payment methods are Lightning-only.",
+      { option_count: 0, available_count: 0 }
+    );
+    return { enabled: false, options: [] };
+  }
+  const amountMsats = parseAmountMsats(input.amountMsats);
+  const providerCatalog = await resolveSwapProviderCatalog(context, providers);
+  const catalogUnreachable = providerCatalog.size === 0;
+  const options = listSwapAssetInfo().map(
+    (asset) => swapCatalogOption({
+      asset,
+      amountMsats,
+      catalogUnreachable,
+      providerAsset: providerCatalog.get(asset.pay_in_asset)
+    })
+  );
+  const unavailableOptions = options.filter((option) => !option.available);
+  emitLog(
+    context.options,
+    "debug",
+    "swap.options.resolved",
+    "Resolved swap pay options with availability.",
+    {
+      amount_msats: amountMsats,
+      option_count: options.length,
+      available_count: options.length - unavailableOptions.length,
+      unavailable_count: unavailableOptions.length,
+      pay_in_assets: options.map((option) => option.payInAsset),
+      unavailable: unavailableOptions.map((option) => ({
+        pay_in_asset: option.payInAsset,
+        reason: option.unavailableReason
+      }))
+    }
+  );
+  return { enabled: true, options };
+}
+async function quoteSwap(context, input) {
+  const amount = normalizeCreateCheckoutAmount(input.amount);
+  const payInAsset = parsePayInAsset(input.payInAsset);
+  const resolved = await resolveCreateAmount({
+    body: createAmountRequest(amount),
+    now: context.clock(),
+    priceProviders: context.priceProviders,
+    priceCurrencies: context.priceCurrencies
+  });
+  const provider = await selectProvider(context, payInAsset);
+  const quote = await provider.quote({ payInAsset, invoiceAmountMsats: resolved.amountMsats });
+  return {
+    provider: quote.provider,
+    payAsset: quote.pay_asset,
+    available: quote.available,
+    ...quote.pay_amount === void 0 ? {} : { payAmount: quote.pay_amount },
+    ...quote.minimum_pay_amount === void 0 ? {} : { minimumPayAmount: quote.minimum_pay_amount },
+    ...quote.maximum_pay_amount === void 0 ? {} : { maximumPayAmount: quote.maximum_pay_amount },
+    ...quote.minimum_invoice_amount_msats === void 0 ? {} : { minimumInvoiceAmountMsats: quote.minimum_invoice_amount_msats },
+    ...quote.maximum_invoice_amount_msats === void 0 ? {} : { maximumInvoiceAmountMsats: quote.maximum_invoice_amount_msats },
+    ...quote.unavailable_reason === void 0 ? {} : { unavailableReason: quote.unavailable_reason },
+    ...quote.unavailable_message === void 0 ? {} : { unavailableMessage: quote.unavailable_message }
+  };
+}
+async function throughProvider(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    const failure = classifySwapTransportFailure(error);
+    if (failure === void 0) throw error;
+    if (failure === "refused") {
+      throw serviceError(502, "INTERNAL", "The swap provider refused this request.");
+    }
+    throw serviceError(
+      503,
+      "INTERNAL",
+      failure === "rate_limited" ? "The swap provider is rate limited. Please try again shortly." : "The swap provider is temporarily unreachable. Please try again shortly.",
+      { retryable: true }
+    );
+  }
+}
+async function createSwap(context, input) {
+  const payInAsset = parsePayInAsset(input.payInAsset);
+  const provider = await selectProvider(context, payInAsset);
+  const expirySeconds = provider.invoiceExpirySeconds?.({ payInAsset });
+  const { payInAsset: _payInAsset, ...checkoutRequest } = input;
+  const checkout = await createCheckout(context, { ...checkoutRequest, expirySeconds });
+  const order = await throughProvider(
+    () => provider.createSwap({
+      payInAsset,
+      bolt11: checkout.bolt11,
+      invoiceAmountMsats: checkout.amountMsats
+    })
+  );
+  const swapData = {
+    version: 1,
+    providerOrder: recoveryOrder(order)
+  };
+  return {
+    checkout,
+    swapData,
+    ...publicSwap(order, checkout.paymentHash, checkout.reference)
+  };
+}
+async function getSwap(context, input) {
+  const recovery = parseSwapData(input.swapData);
+  const paymentHash = parsePaymentHash(input.paymentHash);
+  const reference = parseReference(input.reference);
+  const provider = requireProvider(context, recovery.providerOrder.provider);
+  const current = await throughProvider(() => provider.getStatus(recovery.providerOrder));
+  return publicSwap(current, paymentHash, reference);
+}
+async function refundSwap(context, input) {
+  const recovery = parseSwapData(input.swapData);
+  const paymentHash = parsePaymentHash(input.paymentHash);
+  const reference = parseReference(input.reference);
+  const refundAddress = parseRefundAddress(
+    input.refundAddress,
+    recovery.providerOrder.pay_in_asset
+  );
+  const provider = requireProvider(context, recovery.providerOrder.provider);
+  const current = await throughProvider(() => provider.getStatus(recovery.providerOrder));
+  if (current.state !== "refund_required") {
+    throw serviceError(
+      409,
+      "CONFLICT",
+      `Swap cannot be refunded from provider state ${current.state}.`
+    );
+  }
+  await throughProvider(() => provider.requestRefund(current, refundAddress));
+  const refreshed = await throughProvider(() => provider.getStatus(current));
+  return publicSwap(refreshed, paymentHash, reference);
+}
+async function selectProvider(context, payInAsset) {
+  const providers = context.swapProviders;
+  if (providers.length === 0) {
+    throw serviceError(503, "INTERNAL", `No configured swap provider supports ${payInAsset}.`);
+  }
+  for (let index = 0; index < providers.length; index += 1) {
+    const provider = providers[index];
+    if (provider === void 0) continue;
+    try {
+      const supported = await provider.supportedPayInAssets();
+      if (supported.has(payInAsset)) {
+        if (index > 0) {
+          emitLog(
+            context.options,
+            "warn",
+            "swap.provider.failover",
+            "Primary swap provider unavailable; using backup.",
+            {
+              provider: provider.name,
+              pay_in_asset: payInAsset,
+              failed_providers: providers.slice(0, index).map((entry) => entry.name)
+            }
+          );
+        }
+        return provider;
+      }
+      throw serviceError(503, "INTERNAL", `No configured swap provider supports ${payInAsset}.`);
+    } catch (error) {
+      if (error instanceof ServiceError) throw error;
+    }
+  }
+  throw serviceError(503, "INTERNAL", `No configured swap provider supports ${payInAsset}.`);
+}
+function requireProvider(context, name) {
+  const provider = context.swapProviders.find((candidate) => candidate.name === name);
+  if (provider === void 0) {
+    throw serviceError(503, "INTERNAL", `Swap provider ${name} is not configured.`);
+  }
+  return provider;
+}
+function parseSwapData(value) {
+  const payload = value;
+  if (payload?.version !== 1 || typeof payload.providerOrder !== "object" || payload.providerOrder === null || typeof payload.providerOrder.provider !== "string" || payload.providerOrder.provider.length === 0 || typeof payload.providerOrder.provider_order_id !== "string" || payload.providerOrder.provider_order_id.length === 0) {
+    throw serviceError(400, "INVALID_REQUEST", "swapData is invalid.");
+  }
+  return payload;
+}
+function recoveryOrder(order) {
+  const { raw: _raw, ...safe } = order;
+  return structuredClone(safe);
+}
+function publicSwap(order, paymentHash, reference) {
+  return {
+    paymentHash,
+    reference,
+    provider: order.provider,
+    payInAsset: order.pay_in_asset,
+    depositAddress: order.deposit_address,
+    ...order.deposit_memo === void 0 ? {} : { depositMemo: order.deposit_memo },
+    depositAmount: order.deposit_amount,
+    providerState: order.state,
+    providerExpiresAt: order.expires_at,
+    ...order.deposit_tx_id === void 0 ? {} : { depositTxId: order.deposit_tx_id },
+    ...order.payout_tx_id === void 0 ? {} : { payoutTxId: order.payout_tx_id },
+    ...order.refund_tx_id === void 0 ? {} : { refundTxId: order.refund_tx_id },
+    ...order.refund_reason === void 0 ? {} : { refundReason: order.refund_reason },
+    ...order.refund_amount === void 0 ? {} : { refundAmount: order.refund_amount },
+    ...order.attention === void 0 ? {} : { attention: order.attention },
+    ...order.attention_reason === void 0 ? {} : { attentionReason: order.attention_reason },
+    ...order.deposit_received_amount === void 0 ? {} : { depositReceivedAmount: order.deposit_received_amount },
+    ...order.emergency_repeat === void 0 ? {} : { emergencyRepeat: order.emergency_repeat },
+    providerOrderId: order.provider_order_id,
+    ...order.fee === void 0 ? {} : { fee: order.fee }
+  };
+}
+function parsePaymentHash(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(normalized)) {
+    throw serviceError(400, "INVALID_REQUEST", "paymentHash is invalid.");
+  }
+  return normalized;
+}
+function parseReference(value) {
+  const normalized = value.trim();
+  if (normalized.length === 0 || normalized.length > 200) {
+    throw serviceError(400, "INVALID_REQUEST", "reference is invalid.");
+  }
+  return normalized;
+}
+function parsePayInAsset(value) {
+  if (!isSwapPayInAsset(value)) {
+    throw serviceError(400, "INVALID_REQUEST", "payInAsset is not supported.");
+  }
+  return value;
+}
+function parseRefundAddress(value, payInAsset) {
+  const normalized = value.trim();
+  if (normalized.length === 0 || normalized.length > 300) {
+    throw serviceError(400, "INVALID_REQUEST", "refundAddress is invalid.");
+  }
+  if (typeof payInAsset === "string" && !isValidSwapAddressForPayInAsset(payInAsset, normalized)) {
+    throw serviceError(
+      400,
+      "INVALID_REQUEST",
+      `refundAddress is not a valid ${payInAsset} address.`
+    );
+  }
+  return normalized;
+}
+function parseAmountMsats(value) {
+  if (!Number.isSafeInteger(value) || value < 1e3) {
+    throw serviceError(400, "INVALID_REQUEST", "amountMsats must be an integer >= 1000.");
+  }
+  return Math.ceil(value / 1e3) * 1e3;
+}
+async function resolveSwapProviderCatalog(context, providers) {
+  for (let index = 0; index < providers.length; index += 1) {
+    const provider = providers[index];
+    if (provider === void 0) continue;
+    let catalog;
+    try {
+      catalog = provider.payInAssetCatalog === void 0 ? Array.from(await provider.supportedPayInAssets(), (payInAsset) => ({
+        pay_asset: payInAsset
+      })) : await provider.payInAssetCatalog();
+    } catch {
+      continue;
+    }
+    if (index > 0) {
+      emitLog(
+        context.options,
+        "warn",
+        "swap.provider.failover",
+        "Primary swap provider unavailable; using backup.",
+        {
+          provider: provider.name,
+          failed_providers: providers.slice(0, index).map((entry) => entry.name)
+        }
+      );
+    }
+    const byAsset = /* @__PURE__ */ new Map();
+    for (const item of catalog) {
+      byAsset.set(item.pay_asset, {
+        ...item,
+        provider: provider.name
+      });
+    }
+    return byAsset;
+  }
+  return /* @__PURE__ */ new Map();
+}
+function swapCatalogOption(input) {
+  const { asset, amountMsats, providerAsset } = input;
+  if (providerAsset === void 0) {
+    return {
+      payInAsset: asset.pay_in_asset,
+      label: asset.label,
+      networkLabel: asset.network_label,
+      provider: "",
+      available: false,
+      ...input.catalogUnreachable ? {
+        unavailableReason: "provider_unreachable",
+        unavailableMessage: "The swap provider is temporarily unreachable."
+      } : {
+        unavailableReason: "provider_unconfigured",
+        unavailableMessage: "Automated swaps are not configured for this asset."
+      }
+    };
+  }
+  const limitReason = amountMsats > 0 && providerAsset.minimum_invoice_amount_msats !== void 0 && amountMsats < providerAsset.minimum_invoice_amount_msats ? "amount_too_small" : amountMsats > 0 && providerAsset.maximum_invoice_amount_msats !== void 0 && amountMsats > providerAsset.maximum_invoice_amount_msats ? "amount_too_large" : void 0;
+  const unavailableReason = limitReason ?? (providerAsset.available === false ? providerAsset.unavailable_reason : void 0);
+  const unavailableMessage = limitReason === "amount_too_small" ? "This invoice is below the provider minimum." : limitReason === "amount_too_large" ? "This invoice is above the provider maximum." : providerAsset.available === false ? providerAsset.unavailable_message : void 0;
+  return {
+    payInAsset: asset.pay_in_asset,
+    label: asset.label,
+    networkLabel: asset.network_label,
+    provider: providerAsset.provider,
+    available: unavailableReason === void 0 && providerAsset.available !== false,
+    ...unavailableReason === void 0 ? {} : { unavailableReason },
+    ...unavailableMessage === void 0 ? {} : { unavailableMessage },
+    ...providerAsset.minimum_pay_amount === void 0 ? {} : { minimumPayAmount: providerAsset.minimum_pay_amount },
+    ...providerAsset.maximum_pay_amount === void 0 ? {} : { maximumPayAmount: providerAsset.maximum_pay_amount },
+    ...providerAsset.minimum_invoice_amount_msats === void 0 ? {} : { minimumInvoiceAmountMsats: providerAsset.minimum_invoice_amount_msats },
+    ...providerAsset.maximum_invoice_amount_msats === void 0 ? {} : { maximumInvoiceAmountMsats: providerAsset.maximum_invoice_amount_msats }
+  };
+}
+
+// src/service.ts
+async function createOpenReceive(supplied = {}) {
+  const environment = supplied.env ?? process.env;
+  const options = attachLogging(supplied);
+  const clock = options.clock ?? unixSeconds;
+  const nwcLogger = createNwcEndpointLogger(options);
+  const allowSpendCapableWallet = options.allowSpendCapableWallet ?? isEnvironmentFlagEnabled(environment.OPENRECEIVE_ALLOW_SPEND_CAPABLE_NWC);
+  const client = options.client ?? createNwcReceiveClient({
+    connectionString: requireNwc(options.nwc ?? environment.NWC_URI, {
+      // Name the source the value actually came from, so the error does not
+      // talk about `nwc` when the host only set the env var (or vice versa).
+      subject: options.nwc === void 0 ? "NWC_URI" : "nwc"
+    }),
+    allowSpendCapableWallet,
+    logger: nwcLogger
+  });
+  await preflight(client);
+  const priceCurrencies = readPriceCurrencies(options.priceCurrencies);
+  const priceProviders = options.priceProviders ?? [
+    createPriceFeed({
+      currencies: priceCurrencies,
+      fetch: options.priceFetch,
+      clock,
+      env: environment
+    })
+  ];
+  const swapProviders = resolveSwapProviders(
+    options.swap,
+    () => createLscSwapProvidersFromEnvironment(environment, { now: clock })
+  );
+  const nodeOptions = { ...options, client };
+  emitLog(
+    nodeOptions,
+    "debug",
+    "swap.providers.resolved",
+    swapProviders.length === 0 ? "No swap providers configured; automated swaps are disabled." : "Resolved automated swap providers.",
+    {
+      provider_count: swapProviders.length,
+      providers: swapProviders.map((provider) => provider.name)
+    }
+  );
+  const swapCache = new TransientSwapCache(clock);
+  for (const provider of swapProviders) {
+    provider.attachSwapCache?.(swapCache);
+    provider.attachWeightBudget?.(new SwapProviderWeightBudget(provider.name, clock));
+    provider.attachApiRequestLogger?.(
+      (entry) => emitLog(
+        nodeOptions,
+        swapProviderApiLogLevel(entry.path),
+        "swap.provider.request",
+        "Swap provider API request.",
+        summarizeSwapProviderApiRequest(entry)
+      )
+    );
+    provider.attachApiResponseLogger?.(
+      (entry) => emitLog(
+        nodeOptions,
+        swapProviderApiLogLevel(entry.path),
+        "swap.provider.response",
+        "Swap provider API response.",
+        summarizeSwapProviderApiResponse(entry)
+      )
+    );
+  }
+  const context = {
+    options: nodeOptions,
+    clock,
+    priceProviders,
+    priceCurrencies,
+    swapProviders
+  };
+  const service = {
+    priceCurrencies,
+    prepareCheckout: (input) => prepareCheckout(context, input),
+    createCheckout: (input) => createCheckout(context, input),
+    reconcilePayments: async (input) => {
+      emitLog(
+        nodeOptions,
+        "debug",
+        "payment.reconcile.requested",
+        "Polling NWC wallet to reconcile payment attempts.",
+        { attempt_count: input.attempts.length }
+      );
+      try {
+        const walks = [];
+        const results = await reconcilePaymentAttempts({
+          client,
+          clock,
+          attempts: input.attempts,
+          until: input.until,
+          overlapSeconds: input.overlapSeconds,
+          maxPages: input.maxPages,
+          onWalk: (walk) => walks.push(walk)
+        });
+        emitLog(
+          nodeOptions,
+          "info",
+          "payment.reconcile.completed",
+          "NWC payment reconciliation completed.",
+          {
+            // Attempts scanned vs hashes decided: results collapse duplicate
+            // hashes and omit any the wallet walk could not reach, so a gap
+            // between these two is how a truncated scan shows up in the log.
+            attempt_count: input.attempts.length,
+            result_count: results.length,
+            settled_count: results.filter((result) => result.status === "settled").length,
+            pending_count: results.filter((result) => result.status === "pending").length,
+            not_found_count: results.filter((result) => result.status === "not_found").length,
+            // All pending attempts share these walks: one creation-time window,
+            // never one wallet call per invoice.
+            list_transactions_walks: walks.length,
+            ...walks[0] === void 0 ? {} : { window_from: walks[0].from, window_until: walks[0].until }
+          }
+        );
+        return results;
+      } catch (error) {
+        emitLog(
+          nodeOptions,
+          "error",
+          "payment.reconcile.failed",
+          "NWC payment reconciliation failed.",
+          {
+            attempt_count: input.attempts.length,
+            error_message: error instanceof Error ? error.message : String(error)
+          }
+        );
+        throw error;
+      }
+    },
+    subscribeWalletNotifications: async (handler) => {
+      const subscribe = client.subscribeNotifications;
+      if (typeof subscribe !== "function") {
+        throw new OpenReceiveError3({
+          code: "UNSUPPORTED_METHOD",
+          message: "NWC wallet client does not support NWC notifications (subscribeNotifications). Keep polling reconciliation.",
+          retryable: false
+        });
+      }
+      emitLog(
+        nodeOptions,
+        "debug",
+        "wallet.notifications.subscribe.requested",
+        "Subscribing to NWC-02 payment_received wallet notifications."
+      );
+      const unsubscribe = await subscribe.call(client, (notification) => {
+        emitLog(
+          nodeOptions,
+          "debug",
+          "wallet.notifications.received",
+          "NWC wallet notification received.",
+          {
+            notification_type: notification.type,
+            ...notification.payment_hash === void 0 ? {} : { payment_hash: notification.payment_hash }
+          }
+        );
+        handler(notification);
+      });
+      emitLog(
+        nodeOptions,
+        "info",
+        "wallet.notifications.subscribed",
+        "Subscribed to NWC-02 payment_received wallet notifications; polling reconciliation remains the safety net."
+      );
+      return async () => {
+        await unsubscribe();
+        emitLog(
+          nodeOptions,
+          "info",
+          "wallet.notifications.unsubscribed",
+          "Unsubscribed from NWC-02 wallet notifications."
+        );
+      };
+    },
+    quoteSwap: (input) => quoteSwap(context, input),
+    listSwapOptions: (input) => listSwapOptions(context, input),
+    createSwap: (input) => createSwap(context, input),
+    getSwap: (input) => getSwap(context, input),
+    refundSwap: (input) => refundSwap(context, input),
+    listRates: (input) => listRates(context, input),
+    quoteRates: (input) => quoteRates(context, input),
+    async close() {
+      await client.close?.();
+    }
+  };
+  return service;
+}
+function swapProviderApiLogLevel(path2) {
+  const normalized = path2.toLowerCase();
+  if (normalized.includes("rates") || normalized.includes("ccies") || normalized.includes("price")) {
+    return "debug";
+  }
+  return "info";
+}
+function requireNwc(value, { subject }) {
+  if (value === void 0 || value.trim().length === 0) {
+    throw new ConfigError({
+      code: "MISSING_NWC",
+      message: formatMissingNwcMessage(),
+      hint: "Set the receive-only connection in NWC_URI or pass nwc explicitly."
+    });
+  }
+  try {
+    parseNwcUri2(value.trim());
+  } catch (error) {
+    const reason = error instanceof NwcUriParseError ? error.description : "Invalid NWC URI.";
+    throw new ConfigError({
+      code: "INVALID_NWC",
+      message: formatInvalidNwcMessage({ reason, subject }),
+      hint: "Use a receive-only nostr+walletconnect URI from a trusted wallet.",
+      cause: error
+    });
+  }
+  return value.trim();
+}
+function resolveSwapProviders(swap, fromEnvironment) {
+  if (swap?.provider !== void 0) return [swap.provider, ...swap.failoverProviders ?? []];
+  if (swap?.failoverProviders !== void 0 && swap.failoverProviders.length > 0) {
+    throw new TypeError("swap.failoverProviders requires swap.provider.");
+  }
+  return fromEnvironment();
+}
+function isEnvironmentFlagEnabled(value) {
+  if (value === void 0) return false;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes"].includes(normalized)) return true;
+  if (normalized.length > 0) {
+    console.warn(
+      `[openreceive] Unrecognized OPENRECEIVE_ALLOW_SPEND_CAPABLE_NWC value ${JSON.stringify(value)}; treating it as disabled. Use 1/true/yes to enable.`
+    );
+  }
+  return false;
+}
+async function preflight(client) {
+  try {
+    await client.preflight();
+  } catch (cause) {
+    throw new ConfigError({
+      code: "WALLET_PREFLIGHT_FAILED",
+      message: "OpenReceive wallet preflight failed.",
+      hint: `Use a receive-only NWC connection advertising make_invoice and list_transactions. Get one at ${OPENRECEIVE_NWC_CODE_HELP_URL}`,
+      cause
+    });
+  }
+}
+
+// src/require-nwc.ts
+import {
+  formatInvalidNwcMessage as formatInvalidNwcMessage2,
+  formatMissingNwcMessage as formatMissingNwcMessage2,
+  NwcUriParseError as NwcUriParseError2,
+  parseNwcUri as parseNwcUri3
+} from "@openreceive/core";
+function readNwcFromEnvironment(options = {}) {
+  const subject = options.subject ?? "OpenReceive";
+  const value = (options.env ?? process.env).NWC_URI?.trim();
+  if (value === void 0 || value.length === 0) {
+    throw new Error(formatMissingNwcMessage2({ subject }));
+  }
+  try {
+    parseNwcUri3(value);
+  } catch (error) {
+    const reason = error instanceof NwcUriParseError2 ? error.description : "Invalid NWC URI.";
+    throw new Error(formatInvalidNwcMessage2({ reason }));
+  }
+  return value;
+}
+export {
+  ConfigError,
+  OPENRECEIVE_SWAP_PAY_IN_ASSETS,
+  OPENRECEIVE_SWAP_STATES,
+  OpenReceiveError4 as OpenReceiveError,
+  ReceiveCheckoutValidationError,
+  ServiceError,
+  WalletPreflightError,
+  createAppConsoleLogger,
+  createNwcReceiveClient,
+  createOpenReceive,
+  createPriceFeed,
+  fixedFloatCompatibleSwapProvider,
+  fixedFloatProvider,
+  formatLscUri,
+  readNwcFromEnvironment,
+  sanitizeEvent
+};