@openreceive/node 0.2.1

package/dist/chunk-6HALOJYF.js

@@ -0,0 +1,1482 @@
+// src/swap/assets.ts
+var OPENRECEIVE_SWAP_PAY_IN_ASSETS = [
+  "SOL_SOL",
+  "USDT_TRON",
+  "USDT_SOL",
+  "USDC_SOL",
+  "ETH_ETH",
+  "USDT_ETH",
+  "USDC_ETH"
+];
+var ASSET_INFO = {
+  SOL_SOL: {
+    pay_in_asset: "SOL_SOL",
+    label: "SOL",
+    network_label: "Solana",
+    coin: "SOL",
+    network: "SOL"
+  },
+  USDT_TRON: {
+    pay_in_asset: "USDT_TRON",
+    label: "USDT",
+    network_label: "Tron",
+    coin: "USDT",
+    network: "TRX"
+  },
+  USDT_SOL: {
+    pay_in_asset: "USDT_SOL",
+    label: "USDT",
+    network_label: "Solana",
+    coin: "USDT",
+    network: "SOL"
+  },
+  USDC_SOL: {
+    pay_in_asset: "USDC_SOL",
+    label: "USDC",
+    network_label: "Solana",
+    coin: "USDC",
+    network: "SOL"
+  },
+  ETH_ETH: {
+    pay_in_asset: "ETH_ETH",
+    label: "ETH",
+    network_label: "Ethereum",
+    coin: "ETH",
+    network: "ETH"
+  },
+  USDT_ETH: {
+    pay_in_asset: "USDT_ETH",
+    label: "USDT",
+    network_label: "Ethereum",
+    coin: "USDT",
+    network: "ETH"
+  },
+  USDC_ETH: {
+    pay_in_asset: "USDC_ETH",
+    label: "USDC",
+    network_label: "Ethereum",
+    coin: "USDC",
+    network: "ETH"
+  }
+};
+function isSwapPayInAsset(value) {
+  return typeof value === "string" && OPENRECEIVE_SWAP_PAY_IN_ASSETS.includes(value);
+}
+function getSwapAssetInfo(payInAsset) {
+  return ASSET_INFO[payInAsset];
+}
+function listSwapAssetInfo() {
+  return OPENRECEIVE_SWAP_PAY_IN_ASSETS.map((asset) => ASSET_INFO[asset]);
+}
+function normalizeSwapNetwork(value) {
+  return value.toUpperCase().replace(/[^A-Z0-9]+/g, "");
+}
+function swapNetworkMatches(expected, actual) {
+  const normalizedExpected = normalizeSwapNetwork(expected);
+  const normalizedActual = normalizeSwapNetwork(actual);
+  if (normalizedActual === normalizedExpected) return true;
+  if (normalizedExpected === "TRX") {
+    return normalizedActual === "TRON" || normalizedActual === "TRC20" || normalizedActual === "TRC";
+  }
+  if (normalizedExpected === "ETH") {
+    return normalizedActual === "ETHEREUM" || normalizedActual === "ERC20" || normalizedActual === "ERC";
+  }
+  if (normalizedExpected === "SOL") {
+    return normalizedActual === "SOLANA";
+  }
+  return false;
+}
+function isLightningNetwork(value) {
+  const normalized = normalizeSwapNetwork(value);
+  return normalized === "LN" || normalized === "LIGHTNING" || normalized === "LIGHTNINGNETWORK" || normalized === "BTCLN" || normalized === "BTCBOLT11";
+}
+
+// src/swap/fixedfloat.ts
+import { ceilDiv as ceilDiv2, OPENRECEIVE_SATS_PER_BTC as OPENRECEIVE_SATS_PER_BTC2, recordOrEmpty as recordOrEmpty4, unixSeconds } from "@openreceive/core";
+
+// src/swap/fixedfloat-currencies.ts
+import { recordOrEmpty as recordOrEmpty2 } from "@openreceive/core";
+
+// src/swap/fixedfloat-fields.ts
+import { recordOrEmpty } from "@openreceive/core";
+function optionalCoercedString(value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return void 0;
+}
+function optionalStringField(record, field) {
+  if (record === void 0) return void 0;
+  return optionalCoercedString(record[field]);
+}
+function optionalNestedString(value, path) {
+  let current = value;
+  for (const key of path) {
+    current = recordOrEmpty(current)[key];
+  }
+  return optionalCoercedString(current);
+}
+function optionalStringArrayField(record, field) {
+  if (record === void 0) return [];
+  const value = record[field];
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => {
+      const string2 = optionalCoercedString(item);
+      return string2 === void 0 ? [] : [string2];
+    });
+  }
+  const string = optionalCoercedString(value);
+  return string === void 0 ? [] : [string];
+}
+function requiredString(value, field) {
+  const string = optionalCoercedString(value);
+  if (string === void 0) {
+    throw new Error(`FixedFloat response missing ${field}.`);
+  }
+  return string;
+}
+function readUnixSeconds(value) {
+  const numeric = typeof value === "string" ? Number(value) : value;
+  return typeof numeric === "number" && Number.isSafeInteger(numeric) && numeric >= 0 ? numeric : void 0;
+}
+function readDecimalAmountString(value, label) {
+  if (value === void 0) return void 0;
+  if (!/^[0-9]+(\.[0-9]+)?$/.test(value)) {
+    throw new Error(`FixedFloat ${label} is not a decimal amount.`);
+  }
+  return value;
+}
+
+// src/swap/fixedfloat-rates.ts
+import {
+  ceilDiv,
+  decimalScaleFactor,
+  formatDecimal,
+  OPENRECEIVE_SATS_PER_BTC,
+  parseDecimal
+} from "@openreceive/core";
+var PAY_AMOUNT_FRACTION_DIGITS = 8;
+function fixedFloatRatesPairKey(from, to) {
+  return `${from.trim().toUpperCase()}:${to.trim().toUpperCase()}`;
+}
+function fixedFloatRatesXmlPath(rateType = "fixed") {
+  return `/rates/${rateType}.xml`;
+}
+async function fetchFixedFloatRatesIndex(input) {
+  const rateType = input.rateType ?? "fixed";
+  const url = `${input.baseUrl.replace(/\/+$/, "")}${fixedFloatRatesXmlPath(rateType)}`;
+  const timeoutMs = input.requestTimeoutMs ?? 1e4;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await input.fetch(url, {
+      method: "GET",
+      redirect: "follow",
+      signal: controller.signal,
+      headers: { Accept: "application/xml, text/xml, */*" }
+    });
+  } catch (error) {
+    const aborted = error instanceof Error && (error.name === "AbortError" || error.message.toLowerCase().includes("abort"));
+    throw new Error(
+      aborted ? `FixedFloat rates ${rateType}.xml request timed out.` : `FixedFloat rates ${rateType}.xml request failed before a response was received.`,
+      { cause: error }
+    );
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (!response.ok) {
+    throw new Error(`FixedFloat rates ${rateType}.xml failed with HTTP ${response.status}.`);
+  }
+  const xml = await response.text();
+  return {
+    fetched_at: input.now(),
+    // Provider dumps include thousands of non-LN market pairs; OpenReceive only
+    // ever pays out over Lightning, so drop everything else before caching.
+    pairs: retainFixedFloatLightningPayoutPairs(parseFixedFloatRatesXml(xml))
+  };
+}
+function retainFixedFloatLightningPayoutPairs(pairs) {
+  const retained = {};
+  for (const [key, pair] of Object.entries(pairs)) {
+    if (isLightningNetwork(pair.to)) retained[key] = pair;
+  }
+  return retained;
+}
+function retainFixedFloatRatePairsForKeys(index, pairKeys) {
+  if (pairKeys.size === 0) {
+    return { fetched_at: index.fetched_at, pairs: {} };
+  }
+  const pairs = {};
+  for (const key of pairKeys) {
+    const pair = index.pairs[key];
+    if (pair !== void 0) pairs[key] = pair;
+  }
+  return { fetched_at: index.fetched_at, pairs };
+}
+function parseFixedFloatRatesXml(xml) {
+  const pairs = {};
+  for (const itemXml of matchTags(xml, "item")) {
+    const from = readTagText(itemXml, "from");
+    const to = readTagText(itemXml, "to");
+    const inAmount = readTagText(itemXml, "in");
+    const outAmount = readTagText(itemXml, "out");
+    const amount = readTagText(itemXml, "amount");
+    const minamount = readTagText(itemXml, "minamount");
+    const maxamount = readTagText(itemXml, "maxamount");
+    if (from === void 0 || to === void 0 || inAmount === void 0 || outAmount === void 0 || amount === void 0 || minamount === void 0 || maxamount === void 0) {
+      continue;
+    }
+    const tofee = readTagText(itemXml, "tofee");
+    const pair = {
+      from: from.trim(),
+      to: to.trim(),
+      in: stripCurrencySuffix(inAmount),
+      out: stripCurrencySuffix(outAmount),
+      amount: stripCurrencySuffix(amount),
+      minamount: stripCurrencySuffix(minamount),
+      maxamount: stripCurrencySuffix(maxamount),
+      ...tofee === void 0 ? {} : { tofee: tofee.trim() }
+    };
+    pairs[fixedFloatRatesPairKey(pair.from, pair.to)] = pair;
+  }
+  return pairs;
+}
+function serializeFixedFloatRatesIndex(index) {
+  return JSON.stringify({
+    fetched_at: index.fetched_at,
+    pairs: index.pairs
+  });
+}
+function deserializeFixedFloatRatesIndex(value) {
+  const parsed = JSON.parse(value);
+  if (typeof parsed.fetched_at !== "number" || !Number.isSafeInteger(parsed.fetched_at) || parsed.pairs === null || typeof parsed.pairs !== "object" || Array.isArray(parsed.pairs)) {
+    throw new Error("Invalid FixedFloat rates cache blob.");
+  }
+  const pairs = {};
+  for (const [key, raw] of Object.entries(parsed.pairs)) {
+    const pair = readStoredPair(raw);
+    if (pair !== void 0) pairs[key] = pair;
+  }
+  return { fetched_at: parsed.fetched_at, pairs };
+}
+function quotePayAmountFromFixedFloatRate(input) {
+  if (!Number.isSafeInteger(input.invoiceAmountMsats) || input.invoiceAmountMsats <= 0) {
+    return void 0;
+  }
+  const rateIn = parsePositiveDecimal(input.pair.in);
+  const rateOut = parsePositiveDecimal(input.pair.out);
+  if (rateIn === void 0 || rateOut === void 0) return void 0;
+  const invoiceSats = ceilDiv(BigInt(input.invoiceAmountMsats), 1000n);
+  const tofeeSats = parseToFeeBtcSats(input.pair.tofee) ?? 0n;
+  const totalSats = invoiceSats + tofeeSats;
+  const payAt8Dp = ceilDiv(
+    totalSats * rateIn.units * decimalScaleFactor(rateOut.scale),
+    decimalScaleFactor(rateIn.scale) * rateOut.units
+  );
+  return formatPayAmount(payAt8Dp, PAY_AMOUNT_FRACTION_DIGITS, PAY_AMOUNT_FRACTION_DIGITS);
+}
+function invoiceLimitsFromFixedFloatRate(pair) {
+  const minimumPayAmount = pair.minamount;
+  const maximumPayAmount = pair.maxamount;
+  return {
+    minimum_pay_amount: minimumPayAmount,
+    maximum_pay_amount: maximumPayAmount,
+    ...payAmountToInvoiceMsats(pair, minimumPayAmount, "ceil") === void 0 ? {} : {
+      minimum_invoice_amount_msats: payAmountToInvoiceMsats(pair, minimumPayAmount, "ceil")
+    },
+    ...payAmountToInvoiceMsats(pair, maximumPayAmount, "floor") === void 0 ? {} : {
+      maximum_invoice_amount_msats: payAmountToInvoiceMsats(pair, maximumPayAmount, "floor")
+    }
+  };
+}
+function compareFixedFloatDecimalAmounts(left, right) {
+  const a = parsePositiveDecimal(left);
+  const b = parsePositiveDecimal(right);
+  if (a === void 0 || b === void 0) return void 0;
+  const leftScaled = a.units * decimalScaleFactor(b.scale);
+  const rightScaled = b.units * decimalScaleFactor(a.scale);
+  if (leftScaled < rightScaled) return -1;
+  if (leftScaled > rightScaled) return 1;
+  return 0;
+}
+function payAmountToInvoiceMsats(pair, payAmount, rounding) {
+  const pay = parsePositiveDecimal(payAmount);
+  const rateIn = parsePositiveDecimal(pair.in);
+  const rateOut = parsePositiveDecimal(pair.out);
+  if (pay === void 0 || rateIn === void 0 || rateOut === void 0) return void 0;
+  const numerator = pay.units * rateOut.units * OPENRECEIVE_SATS_PER_BTC * decimalScaleFactor(rateIn.scale);
+  const denominator = decimalScaleFactor(pay.scale) * decimalScaleFactor(rateOut.scale) * rateIn.units;
+  if (denominator <= 0n) return void 0;
+  const invoiceSats = rounding === "ceil" ? ceilDiv(numerator, denominator) : numerator / denominator;
+  if (invoiceSats <= 0n) return void 0;
+  const msats = invoiceSats * 1000n;
+  if (msats > BigInt(Number.MAX_SAFE_INTEGER)) return void 0;
+  return Number(msats);
+}
+function parseToFeeBtcSats(tofee) {
+  if (tofee === void 0) return void 0;
+  const match = tofee.trim().match(/^([0-9]+(?:\.[0-9]+)?)\s*([A-Za-z]+)?$/);
+  if (match === null) return void 0;
+  const amount = match[1];
+  const unit = (match[2] ?? "BTC").toUpperCase();
+  if (unit !== "BTC" && unit !== "BTCLN") return void 0;
+  const parsed = parsePositiveDecimal(amount);
+  if (parsed === void 0) return void 0;
+  return ceilDiv(parsed.units * OPENRECEIVE_SATS_PER_BTC, decimalScaleFactor(parsed.scale));
+}
+function parsePositiveDecimal(value) {
+  let parsed;
+  try {
+    parsed = parseDecimal(value);
+  } catch {
+    return void 0;
+  }
+  return parsed.units > 0n ? parsed : void 0;
+}
+function formatPayAmount(units, scale, maxFractionDigits) {
+  const target = decimalScaleFactor(maxFractionDigits);
+  const current = decimalScaleFactor(scale);
+  const rescaled = scale <= maxFractionDigits ? units * (target / current) : ceilDiv(units * target, current);
+  const text = formatDecimal(rescaled, maxFractionDigits);
+  return text.includes(".") ? text.replace(/0+$/, "").replace(/\.$/, "") : text;
+}
+function stripCurrencySuffix(value) {
+  const match = value.trim().match(/^([0-9]+(?:\.[0-9]+)?)/);
+  return match?.[1] ?? value.trim();
+}
+function matchTags(xml, tag) {
+  const pattern = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`, "gi");
+  const matches = [];
+  for (const match of xml.matchAll(pattern)) {
+    matches.push(match[1] ?? "");
+  }
+  return matches;
+}
+function readTagText(xml, tag) {
+  const pattern = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`, "i");
+  const match = xml.match(pattern);
+  if (match === null) return void 0;
+  const text = (match[1] ?? "").trim();
+  return text.length === 0 ? void 0 : text;
+}
+function readStoredPair(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const record = value;
+  const from = typeof record.from === "string" ? record.from : void 0;
+  const to = typeof record.to === "string" ? record.to : void 0;
+  const inAmount = typeof record.in === "string" ? record.in : void 0;
+  const outAmount = typeof record.out === "string" ? record.out : void 0;
+  const amount = typeof record.amount === "string" ? record.amount : void 0;
+  const minamount = typeof record.minamount === "string" ? record.minamount : void 0;
+  const maxamount = typeof record.maxamount === "string" ? record.maxamount : void 0;
+  if (from === void 0 || to === void 0 || inAmount === void 0 || outAmount === void 0 || amount === void 0 || minamount === void 0 || maxamount === void 0) {
+    return void 0;
+  }
+  return {
+    from,
+    to,
+    in: inAmount,
+    out: outAmount,
+    amount,
+    minamount,
+    maxamount,
+    ...typeof record.tofee === "string" ? { tofee: record.tofee } : {}
+  };
+}
+
+// src/swap/fixedfloat-currencies.ts
+function resolveFixedFloatCurrencies(data, input) {
+  const currencies = readFixedFloatCurrencies(data);
+  const payIn = /* @__PURE__ */ new Map();
+  for (const asset of listSwapAssetInfo()) {
+    const found = currencies.find(
+      (currency) => currency.coin.toUpperCase() === asset.coin && swapNetworkMatches(asset.network, currency.network) && // /ccies recv=false means FixedFloat will not accept deposits for this
+      // currency — omit it from the catalog rather than failing at /create.
+      currency.recv !== false
+    );
+    if (found !== void 0) payIn.set(asset.pay_in_asset, found);
+  }
+  const lightningCurrency = input.lightningCcy === void 0 ? currencies.find(
+    (currency) => currency.coin.toUpperCase() === "BTC" && isLightningNetwork(currency.network) && // Payout side must be sendable to the merchant's bolt11.
+    currency.send !== false
+  ) : currencies.find(
+    (currency) => currency.code === input.lightningCcy && currency.send !== false
+  );
+  if (lightningCurrency === void 0) {
+    throw new Error("FixedFloat /ccies did not include a BTC Lightning payout currency.");
+  }
+  return {
+    fetched_at: input.fetchedAt,
+    pay_in: payIn,
+    lightning: lightningCurrency
+  };
+}
+function serializeFixedFloatCurrencyResolution(resolution) {
+  return JSON.stringify({
+    fetched_at: resolution.fetched_at,
+    pay_in: Array.from(resolution.pay_in.entries()),
+    lightning: resolution.lightning
+  });
+}
+function deserializeFixedFloatCurrencyResolution(value) {
+  const parsed = JSON.parse(value);
+  return {
+    fetched_at: parsed.fetched_at,
+    pay_in: new Map(parsed.pay_in),
+    lightning: parsed.lightning
+  };
+}
+function requiredFixedFloatCurrency(resolution, payInAsset) {
+  const currency = resolution.pay_in.get(payInAsset);
+  if (currency === void 0) {
+    const label = getSwapAssetInfo(payInAsset).pay_in_asset;
+    throw new Error(`FixedFloat does not currently support ${label}.`);
+  }
+  return currency.code;
+}
+function fixedFloatRatePairKeys(resolution) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const currency of resolution.pay_in.values()) {
+    keys.add(fixedFloatRatesPairKey(currency.code, resolution.lightning.code));
+  }
+  return keys;
+}
+function readFixedFloatCurrencies(data) {
+  const record = recordOrEmpty2(data);
+  const items = Array.isArray(data) ? data : Array.isArray(record.ccies) ? record.ccies : Array.isArray(record.currencies) ? record.currencies : [];
+  const currencies = [];
+  for (const item of items) {
+    const record2 = recordOrEmpty2(item);
+    const code = optionalStringField(record2, "code") ?? optionalStringField(record2, "ticker");
+    const coin = optionalStringField(record2, "coin") ?? optionalStringField(record2, "currency") ?? optionalStringField(record2, "symbol");
+    const network = optionalStringField(record2, "network") ?? optionalStringField(record2, "chain") ?? optionalStringField(record2, "networkName") ?? optionalStringField(record2, "name");
+    if (code !== void 0 && coin !== void 0 && network !== void 0) {
+      currencies.push({
+        code,
+        coin: coin.toUpperCase(),
+        network,
+        ...typeof record2.recv === "boolean" ? { recv: record2.recv } : {},
+        ...typeof record2.send === "boolean" ? { send: record2.send } : {}
+      });
+    }
+  }
+  return currencies;
+}
+
+// src/swap/fixedfloat-orders.ts
+import { recordOrEmpty as recordOrEmpty3 } from "@openreceive/core";
+function normalizeFixedFloatOrder(data, input) {
+  const fields = extractFixedFloatOrderFields(recordOrEmpty3(data), input);
+  const { attention, attention_reason } = fields.status;
+  return {
+    provider: input.provider,
+    provider_order_id: fields.providerOrderId,
+    provider_token: fields.providerToken,
+    pay_in_asset: input.payInAsset,
+    deposit_address: fields.depositAddress,
+    ...fields.depositMemo === void 0 ? {} : { deposit_memo: fields.depositMemo },
+    deposit_amount: fields.depositAmount,
+    expires_at: fields.expiresAt,
+    state: fields.status.state,
+    ...fields.depositTxId === void 0 ? {} : { deposit_tx_id: fields.depositTxId },
+    ...fields.payoutTxId === void 0 ? {} : { payout_tx_id: fields.payoutTxId },
+    ...fields.refundTxId === void 0 ? {} : { refund_tx_id: fields.refundTxId },
+    ...attention === void 0 ? {} : { attention },
+    ...attention_reason === void 0 ? {} : { attention_reason },
+    ...fields.refundReason === void 0 ? {} : { refund_reason: fields.refundReason },
+    ...fields.depositReceivedAmount === void 0 ? {} : { deposit_received_amount: fields.depositReceivedAmount },
+    ...fields.refundAmount === void 0 ? {} : { refund_amount: fields.refundAmount },
+    ...fields.emergencyRepeat === void 0 ? {} : { emergency_repeat: fields.emergencyRepeat },
+    ...fields.fee === void 0 ? {} : { fee: fields.fee },
+    raw: data
+  };
+}
+function readFixedFloatOrderFee(record) {
+  const payInFiat = optionalNestedString(record, ["from", "usd"]);
+  const payoutFiat = optionalNestedString(record, ["to", "usd"]);
+  if (payInFiat === void 0 || payoutFiat === void 0) return void 0;
+  return { currency: "USD", pay_in_fiat: payInFiat, payout_fiat: payoutFiat };
+}
+function requiredOrderField(record, field, fallback, label) {
+  return optionalStringField(record, field) ?? fallback ?? requiredString(record[field], label);
+}
+function requiredExpiresAt(expiresAt) {
+  if (expiresAt === void 0) {
+    throw new Error("FixedFloat order is missing time.expiration.");
+  }
+  return expiresAt;
+}
+function persistedStatus(fallback) {
+  return {
+    state: fallback.state,
+    ...fallback.attention === void 0 ? {} : { attention: fallback.attention },
+    ...fallback.attention_reason === void 0 ? {} : { attention_reason: fallback.attention_reason },
+    ...fallback.refund_reason === void 0 ? {} : { refund_reason: fallback.refund_reason }
+  };
+}
+function extractFixedFloatOrderFields(record, input) {
+  const fallback = input.fallback;
+  const from = recordOrEmpty3(record.from);
+  const emergency = recordOrEmpty3(record.emergency);
+  const refundTxId = optionalNestedString(record, ["back", "tx", "id"]) ?? optionalNestedString(record, ["refund", "tx", "id"]) ?? fallback?.refund_tx_id;
+  const rawStatus = optionalStringField(record, "status");
+  const status = rawStatus === void 0 && fallback !== void 0 ? persistedStatus(fallback) : normalizeFixedFloatStatus(rawStatus ?? "NEW", emergency, refundTxId);
+  return {
+    status,
+    depositAddress: requiredOrderField(from, "address", fallback?.deposit_address, "from.address"),
+    refundTxId,
+    providerOrderId: requiredOrderField(record, "id", fallback?.provider_order_id, "id"),
+    providerToken: requiredOrderField(record, "token", fallback?.provider_token, "token"),
+    depositAmount: requiredOrderField(from, "amount", fallback?.deposit_amount, "from.amount"),
+    // No invented deadline: the provider states the expiry, and on a thin poll
+    // body the one we already persisted stands. A create body without either is
+    // a provider contract break, not something to paper over with now + 10min.
+    expiresAt: requiredExpiresAt(
+      readUnixSeconds(recordOrEmpty3(record.time).expiration) ?? fallback?.expires_at
+    ),
+    depositMemo: optionalStringField(from, "tag") ?? fallback?.deposit_memo,
+    depositTxId: optionalNestedString(record, ["from", "tx", "id"]) ?? fallback?.deposit_tx_id,
+    payoutTxId: optionalNestedString(record, ["to", "tx", "id"]) ?? fallback?.payout_tx_id,
+    depositReceivedAmount: readDecimalAmountString(
+      optionalNestedString(record, ["from", "tx", "amount"]),
+      "from.tx.amount"
+    ) ?? fallback?.deposit_received_amount,
+    refundAmount: readDecimalAmountString(optionalNestedString(record, ["back", "amount"]), "back.amount") ?? fallback?.refund_amount,
+    refundReason: status.refund_reason ?? (isRefundPathState(status.state) ? fallback?.refund_reason : void 0),
+    emergencyRepeat: readEmergencyRepeat(emergency) ?? fallback?.emergency_repeat,
+    fee: readFixedFloatOrderFee(record) ?? fallback?.fee
+  };
+}
+function normalizeFixedFloatStatus(status, emergency, refundTxId) {
+  const normalized = status.toUpperCase();
+  if (refundTxId !== void 0 && (normalized === "DONE" || normalized === "FINISHED")) {
+    return { state: "refunded" };
+  }
+  if (normalized === "NEW") return { state: "awaiting_deposit" };
+  if (normalized === "PENDING") return { state: "confirming" };
+  if (normalized === "EXCHANGE") return { state: "exchanging" };
+  if (normalized === "WITHDRAW") return { state: "paying_invoice" };
+  if (normalized === "DONE") return { state: "completed" };
+  if (normalized === "EXPIRED") return { state: "expired" };
+  if (normalized === "EMERGENCY") {
+    const choice = optionalStringField(emergency, "choice")?.toUpperCase();
+    const emergencyStatuses = optionalStringArrayField(emergency, "status").map(
+      (item) => item.toUpperCase()
+    );
+    const refundReason = refundReasonFromEmergencyStatuses(emergencyStatuses);
+    if (choice === "REFUND" && refundTxId !== void 0) {
+      return {
+        state: "refunded",
+        ...refundReason === void 0 ? {} : { refund_reason: refundReason }
+      };
+    }
+    if (choice === "REFUND") {
+      return {
+        state: "refund_pending",
+        ...refundReason === void 0 ? {} : { refund_reason: refundReason }
+      };
+    }
+    if (choice === "EXCHANGE") {
+      return {
+        state: "attention",
+        attention: true,
+        attention_reason: "provider_reported_emergency"
+      };
+    }
+    if (emergencyStatuses.includes("MORE") || emergencyStatuses.includes("OVER") || emergencyStatuses.includes("OVERPAID")) {
+      return {
+        state: "attention",
+        attention: true,
+        attention_reason: "provider_reported_emergency"
+      };
+    }
+    return {
+      state: "refund_required",
+      ...refundReason === void 0 ? {} : { refund_reason: refundReason }
+    };
+  }
+  if (normalized.includes("FAIL")) return { state: "failed" };
+  return { state: "attention", attention: true, attention_reason: "provider_status_unrecognized" };
+}
+function refundReasonFromEmergencyStatuses(statuses) {
+  const less = statuses.includes("LESS");
+  const expired = statuses.includes("EXPIRED");
+  if (less && expired) return "underpaid_and_late";
+  if (less) return "underpaid";
+  if (expired) return "late_deposit";
+  return void 0;
+}
+function isRefundPathState(state) {
+  return state === "refund_required" || state === "refund_pending" || state === "refunded";
+}
+function readEmergencyRepeat(emergency) {
+  if (emergency === void 0) return void 0;
+  const value = emergency.repeat;
+  if (typeof value === "boolean") return value;
+  if (value === 0 || value === "0") return false;
+  if (value === 1 || value === "1") return true;
+  return void 0;
+}
+
+// src/swap/fixedfloat-quote.ts
+function fixedFloatQuoteFromRatePair(input) {
+  const { pair } = input;
+  if (pair === void 0) {
+    return {
+      pay_asset: input.payInAsset,
+      available: false,
+      unavailable_reason: "pair_temporarily_unavailable",
+      unavailable_message: fixedFloatAvailabilityMessage("pair_temporarily_unavailable"),
+      provider: input.provider
+    };
+  }
+  const limits = invoiceLimitsFromFixedFloatRate(pair);
+  const payAmount = quotePayAmountFromFixedFloatRate({
+    pair,
+    invoiceAmountMsats: input.invoiceAmountMsats
+  });
+  if (payAmount === void 0) {
+    return {
+      pay_asset: input.payInAsset,
+      available: false,
+      unavailable_reason: "pair_temporarily_unavailable",
+      unavailable_message: fixedFloatAvailabilityMessage("pair_temporarily_unavailable"),
+      provider: input.provider,
+      ...limits
+    };
+  }
+  const payBelowMin = compareFixedFloatDecimalAmounts(payAmount, limits.minimum_pay_amount) === -1;
+  const payAboveMax = compareFixedFloatDecimalAmounts(payAmount, limits.maximum_pay_amount) === 1;
+  const amountTooSmall = payBelowMin || limits.minimum_invoice_amount_msats !== void 0 && input.invoiceAmountMsats < limits.minimum_invoice_amount_msats;
+  const amountTooLarge = payAboveMax || limits.maximum_invoice_amount_msats !== void 0 && input.invoiceAmountMsats > limits.maximum_invoice_amount_msats;
+  if (amountTooSmall || amountTooLarge) {
+    const reason = amountTooSmall ? "amount_too_small" : "amount_too_large";
+    return {
+      pay_asset: input.payInAsset,
+      available: false,
+      unavailable_reason: reason,
+      unavailable_message: fixedFloatAvailabilityMessage(reason),
+      provider: input.provider,
+      ...limits
+    };
+  }
+  return {
+    pay_amount: payAmount,
+    pay_asset: input.payInAsset,
+    available: true,
+    provider: input.provider,
+    ...limits
+  };
+}
+function fixedFloatAvailabilityMessage(reason) {
+  if (reason === "amount_too_small") return "This invoice is below the provider minimum.";
+  if (reason === "amount_too_large") return "This invoice is above the provider maximum.";
+  if (reason === "provider_rate_limited") return "The swap provider is rate limited.";
+  if (reason === "provider_unreachable") return "The swap provider is temporarily unreachable.";
+  return "This payment route is temporarily unavailable.";
+}
+
+// src/swap/fixedfloat-transport.ts
+import { createHmac } from "crypto";
+var FixedFloatApiError = class _FixedFloatApiError extends Error {
+  path;
+  kind;
+  status;
+  fixedFloatCode;
+  fixedFloatMessage;
+  constructor(input) {
+    super(input.message, input.cause === void 0 ? void 0 : { cause: input.cause });
+    this.name = "FixedFloatApiError";
+    this.path = input.path;
+    this.kind = input.kind;
+    this.status = input.status;
+    this.fixedFloatCode = input.fixedFloatCode;
+    this.fixedFloatMessage = input.fixedFloatMessage;
+  }
+  static fromFetchError(path, error) {
+    const aborted = error instanceof Error && (error.name === "AbortError" || error.message.toLowerCase().includes("abort"));
+    return new _FixedFloatApiError({
+      path,
+      kind: aborted ? "timeout" : "network",
+      message: aborted ? `FixedFloat ${path} request timed out.` : `FixedFloat ${path} request failed before a response was received.`,
+      cause: error
+    });
+  }
+};
+var FixedFloatTransport = class {
+  /** Already stripped of trailing slashes; also the origin of the XML rates GET. */
+  baseUrl;
+  fetcher;
+  requestTimeoutMs;
+  provider;
+  key;
+  secret;
+  apiRequestLogger;
+  apiResponseLogger;
+  weightBudget;
+  constructor(input) {
+    this.provider = input.provider;
+    this.key = input.key;
+    this.secret = input.secret;
+    this.baseUrl = input.baseUrl;
+    this.fetcher = input.fetch;
+    this.requestTimeoutMs = input.requestTimeoutMs;
+  }
+  attachApiRequestLogger(log) {
+    this.apiRequestLogger = log;
+  }
+  attachApiResponseLogger(log) {
+    this.apiResponseLogger = log;
+  }
+  attachWeightBudget(budget) {
+    this.weightBudget = budget;
+  }
+  async post(path, body) {
+    if (this.weightBudget !== void 0) {
+      await this.weightBudget.reserve(path);
+    }
+    const bodyString = JSON.stringify(body);
+    this.logApiRequest(path, body);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+    let response;
+    try {
+      response = await this.fetcher(`${this.baseUrl}/api/v2/${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json; charset=UTF-8",
+          "X-API-KEY": this.key,
+          "X-API-SIGN": createHmac("sha256", this.secret).update(bodyString).digest("hex")
+        },
+        body: bodyString,
+        signal: controller.signal
+      });
+    } catch (error) {
+      const apiError = FixedFloatApiError.fromFetchError(path, error);
+      this.logApiResponse({
+        path,
+        status: 0,
+        ok: false,
+        msg: apiError.message
+      });
+      throw apiError;
+    } finally {
+      clearTimeout(timeout);
+    }
+    const text = await response.text();
+    let parsed;
+    try {
+      parsed = text.length === 0 ? {} : JSON.parse(text);
+    } catch (error) {
+      this.logApiResponse({
+        path,
+        status: response.status,
+        ok: false,
+        msg: `FixedFloat ${path} returned invalid JSON.`
+      });
+      throw new FixedFloatApiError({
+        path,
+        kind: "invalid_json",
+        status: response.status,
+        message: `FixedFloat ${path} returned invalid JSON.`,
+        cause: error
+      });
+    }
+    this.logApiResponse({
+      path,
+      status: response.status,
+      ok: response.ok,
+      code: parsed.code,
+      msg: parsed.msg,
+      data: parsed.data
+    });
+    if (!response.ok) {
+      if (response.status === 429 && this.weightBudget !== void 0) {
+        await this.weightBudget.markRateLimited();
+      }
+      throw new FixedFloatApiError({
+        path,
+        kind: response.status === 429 ? "rate_limited" : "http",
+        status: response.status,
+        fixedFloatMessage: optionalCoercedString(parsed.msg),
+        message: formatFixedFloatApiErrorMessage(path, response.status, parsed.msg)
+      });
+    }
+    if (parsed.code !== 0) {
+      throw new FixedFloatApiError({
+        path,
+        kind: "api",
+        fixedFloatCode: parsed.code,
+        fixedFloatMessage: optionalCoercedString(parsed.msg),
+        message: typeof parsed.msg === "string" ? parsed.msg : `FixedFloat ${path} failed.`
+      });
+    }
+    return parsed.data;
+  }
+  logApiRequest(path, body = {}) {
+    this.apiRequestLogger?.({
+      provider: this.provider,
+      path,
+      body
+    });
+  }
+  logApiResponse(input) {
+    this.apiResponseLogger?.({
+      provider: this.provider,
+      path: input.path,
+      status: input.status,
+      ok: input.ok,
+      code: input.code,
+      msg: input.msg,
+      data: input.data
+    });
+  }
+};
+function formatFixedFloatApiErrorMessage(path, status, msg) {
+  const fixedFloatMessage = optionalCoercedString(msg);
+  return fixedFloatMessage === void 0 ? `FixedFloat ${path} failed with HTTP ${status}.` : `FixedFloat ${path} failed with HTTP ${status}: ${fixedFloatMessage}`;
+}
+
+// src/swap/limits-cache.ts
+var SWAP_LIMITS_MAX_STALE_SECONDS = 48 * 60 * 60;
+var SWAP_LIMITS_REFRESH_CLAIM_SECONDS = 60;
+function swapLimitsMetaKey(providerName) {
+  return `swap_limits:${providerName}`;
+}
+var TransientSwapCache = class {
+  #states = /* @__PURE__ */ new Map();
+  #inflight = /* @__PURE__ */ new Map();
+  #clock;
+  #warn;
+  constructor(clock, options = {}) {
+    this.#clock = clock;
+    this.#warn = options.warn ?? (() => {
+    });
+  }
+  async resolve(key, options) {
+    const now = this.#clock();
+    const state = this.#states.get(key);
+    if (state?.value !== void 0 && state.fetchedAt !== void 0 && now - state.fetchedAt < options.refreshSeconds) {
+      return options.deserialize(state.value);
+    }
+    const claimSeconds = options.claimSeconds ?? SWAP_LIMITS_REFRESH_CLAIM_SECONDS;
+    if (state?.failedAt !== void 0 && now - state.failedAt < claimSeconds) {
+      return this.#staleOrThrow(key, state, now, options);
+    }
+    const active = this.#inflight.get(key);
+    if (active !== void 0) return await active;
+    const refresh = this.#refresh(key, state, now, options);
+    this.#inflight.set(key, refresh);
+    try {
+      return await refresh;
+    } finally {
+      if (this.#inflight.get(key) === refresh) this.#inflight.delete(key);
+    }
+  }
+  async #refresh(key, previous, now, options) {
+    try {
+      const value = await options.fetch();
+      this.#states.set(key, { value: options.serialize(value), fetchedAt: now });
+      return value;
+    } catch (error) {
+      const failed = {
+        ...previous?.value === void 0 ? {} : { value: previous.value },
+        ...previous?.fetchedAt === void 0 ? {} : { fetchedAt: previous.fetchedAt },
+        failedAt: now,
+        error: error instanceof Error ? error.message : String(error)
+      };
+      this.#states.set(key, failed);
+      return this.#staleOrThrow(key, failed, now, options, error);
+    }
+  }
+  #staleOrThrow(key, state, now, options, cause) {
+    if (options.serveStaleOnFailure !== false && state.value !== void 0 && state.fetchedAt !== void 0 && now - state.fetchedAt < options.maxStaleSeconds) {
+      this.#warn("Serving stale swap provider data after refresh failed.", {
+        key,
+        error: state.error
+      });
+      return options.deserialize(state.value);
+    }
+    if (cause instanceof Error) throw cause;
+    throw new Error(state.error ?? "Swap provider cache refresh failed.");
+  }
+};
+
+// src/swap/rates-cache.ts
+var SWAP_RATES_REFRESH_SECONDS = 15;
+var SWAP_RATES_MAX_STALE_SECONDS = SWAP_RATES_REFRESH_SECONDS;
+function swapRatesMetaKey(providerName, rateType = "fixed") {
+  return `swap_rates:${providerName}:${rateType}`;
+}
+
+// src/swap/fixedfloat.ts
+var DEFAULT_FIXED_FLOAT_BASE_URL = "https://ff.io";
+var DEFAULT_CCIES_CACHE_SECONDS = 24 * 60 * 60;
+var DEFAULT_RATES_CACHE_SECONDS = SWAP_RATES_REFRESH_SECONDS;
+var DEFAULT_FIXED_FLOAT_REQUEST_TIMEOUT_MS = 1e4;
+var DEFAULT_FIXED_FLOAT_DEPOSIT_WINDOW_SECONDS = 10 * 60;
+var DEFAULT_FIXED_FLOAT_SETTLEMENT_SLA_SECONDS = 15 * 60;
+var DEFAULT_FIXED_FLOAT_INVOICE_EXPIRY_MARGIN_SECONDS = 5 * 60;
+function fixedFloatProvider(options) {
+  return fixedFloatCompatibleSwapProvider({
+    ...options,
+    id: "fixedfloat"
+  });
+}
+function fixedFloatCompatibleSwapProvider(options) {
+  return new FixedFloatProvider(options);
+}
+var FixedFloatProvider = class {
+  name;
+  lightningCcy;
+  now;
+  cacheSeconds;
+  ratesCacheSeconds;
+  invoiceExpirySecondsValue;
+  transport;
+  cache;
+  constructor(options) {
+    this.name = readFixedFloatCompatibleProviderId(options.id);
+    if (options.key.trim().length === 0) {
+      throw new TypeError("FixedFloat-compatible API key must not be empty.");
+    }
+    if (options.secret.trim().length === 0) {
+      throw new TypeError("FixedFloat-compatible API secret must not be empty.");
+    }
+    const fetcher = options.fetch ?? globalThis.fetch;
+    if (fetcher === void 0) {
+      throw new TypeError("FixedFloat-compatible provider requires fetch.");
+    }
+    const lightningCcy = options.lightningCcy?.trim();
+    this.lightningCcy = lightningCcy === void 0 || lightningCcy.length === 0 ? void 0 : lightningCcy;
+    this.now = options.now ?? unixSeconds;
+    this.cacheSeconds = options.cacheSeconds ?? DEFAULT_CCIES_CACHE_SECONDS;
+    this.ratesCacheSeconds = options.ratesCacheSeconds ?? DEFAULT_RATES_CACHE_SECONDS;
+    if (!Number.isSafeInteger(this.ratesCacheSeconds) || this.ratesCacheSeconds <= 0) {
+      throw new TypeError("FixedFloat ratesCacheSeconds must be a positive safe integer.");
+    }
+    const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_FIXED_FLOAT_REQUEST_TIMEOUT_MS;
+    if (!Number.isSafeInteger(requestTimeoutMs) || requestTimeoutMs <= 0) {
+      throw new TypeError("FixedFloat requestTimeoutMs must be a positive safe integer.");
+    }
+    this.transport = new FixedFloatTransport({
+      provider: this.name,
+      key: options.key,
+      secret: options.secret,
+      baseUrl: (options.baseUrl ?? DEFAULT_FIXED_FLOAT_BASE_URL).replace(/\/+$/, ""),
+      fetch: fetcher,
+      requestTimeoutMs
+    });
+    const depositWindowSeconds = options.depositWindowSeconds ?? DEFAULT_FIXED_FLOAT_DEPOSIT_WINDOW_SECONDS;
+    const settlementSlaSeconds = options.settlementSlaSeconds ?? DEFAULT_FIXED_FLOAT_SETTLEMENT_SLA_SECONDS;
+    const invoiceExpiryMarginSeconds = options.invoiceExpiryMarginSeconds ?? DEFAULT_FIXED_FLOAT_INVOICE_EXPIRY_MARGIN_SECONDS;
+    for (const [name, value] of [
+      ["FixedFloat depositWindowSeconds", depositWindowSeconds],
+      ["FixedFloat settlementSlaSeconds", settlementSlaSeconds],
+      ["FixedFloat invoiceExpiryMarginSeconds", invoiceExpiryMarginSeconds]
+    ]) {
+      if (!Number.isSafeInteger(value) || value < 0) {
+        throw new TypeError(`${name} must be a non-negative safe integer.`);
+      }
+    }
+    const minimumInvoiceExpirySeconds = depositWindowSeconds + settlementSlaSeconds + invoiceExpiryMarginSeconds;
+    this.invoiceExpirySecondsValue = options.invoiceExpirySeconds ?? minimumInvoiceExpirySeconds;
+    if (!Number.isSafeInteger(this.invoiceExpirySecondsValue) || this.invoiceExpirySecondsValue < minimumInvoiceExpirySeconds) {
+      throw new TypeError(
+        `FixedFloat provider ${JSON.stringify(this.name)}: invoice_expiry_seconds (${this.invoiceExpirySecondsValue}) must be at least ${minimumInvoiceExpirySeconds} = deposit_window(${depositWindowSeconds}) + settlement_sla(${settlementSlaSeconds}) + margin(${invoiceExpiryMarginSeconds}). Omit invoice_expiry_seconds to auto-derive it, or raise it above that floor.`
+      );
+    }
+  }
+  attachSwapCache(cache) {
+    this.cache = cache;
+  }
+  attachApiRequestLogger(log) {
+    this.transport.attachApiRequestLogger(log);
+  }
+  attachApiResponseLogger(log) {
+    this.transport.attachApiResponseLogger(log);
+  }
+  attachWeightBudget(budget) {
+    this.transport.attachWeightBudget(budget);
+  }
+  async supportedPayInAssets() {
+    const resolution = await this.resolveCurrencies();
+    return new Set(resolution.pay_in.keys());
+  }
+  async payInAssetCatalog() {
+    const resolution = await this.resolveCurrencies();
+    const rates = await this.resolveRatesIndex(resolution);
+    return Array.from(resolution.pay_in.entries(), ([payInAsset, currency]) => {
+      const pair = rates.pairs[fixedFloatRatesPairKey(currency.code, resolution.lightning.code)];
+      if (pair === void 0) {
+        return {
+          pay_asset: payInAsset,
+          available: false,
+          unavailable_reason: "pair_temporarily_unavailable",
+          unavailable_message: fixedFloatAvailabilityMessage("pair_temporarily_unavailable")
+        };
+      }
+      return {
+        pay_asset: payInAsset,
+        ...invoiceLimitsFromFixedFloatRate(pair)
+      };
+    });
+  }
+  invoiceExpirySeconds() {
+    return this.invoiceExpirySecondsValue;
+  }
+  async quote(input) {
+    const resolution = await this.resolveCurrencies();
+    const fromCcy = requiredFixedFloatCurrency(resolution, input.payInAsset);
+    const rates = await this.resolveRatesIndex(resolution);
+    return fixedFloatQuoteFromRatePair({
+      pair: rates.pairs[fixedFloatRatesPairKey(fromCcy, resolution.lightning.code)],
+      payInAsset: input.payInAsset,
+      invoiceAmountMsats: input.invoiceAmountMsats,
+      provider: this.name
+    });
+  }
+  async createSwap(input) {
+    const resolution = await this.resolveCurrencies();
+    const fromCcy = requiredFixedFloatCurrency(resolution, input.payInAsset);
+    const data = await this.transport.post("create", {
+      type: "fixed",
+      fromCcy,
+      toCcy: resolution.lightning.code,
+      direction: "to",
+      amount: amountMsatsToBtcString(input.invoiceAmountMsats),
+      toAddress: input.bolt11
+    });
+    const order = normalizeFixedFloatOrder(data, {
+      provider: this.name,
+      payInAsset: input.payInAsset
+    });
+    if (order.fee !== void 0) return order;
+    const fee = await this.fetchFixedFloatOrderFee(
+      fromCcy,
+      resolution.lightning.code,
+      input.invoiceAmountMsats
+    );
+    return fee === void 0 ? order : { ...order, fee };
+  }
+  async fetchFixedFloatOrderFee(fromCcy, toCcy, invoiceAmountMsats) {
+    try {
+      const data = await this.transport.post("price", {
+        type: "fixed",
+        fromCcy,
+        toCcy,
+        direction: "to",
+        amount: amountMsatsToBtcString(invoiceAmountMsats)
+      });
+      return readFixedFloatOrderFee(recordOrEmpty4(data));
+    } catch {
+      return void 0;
+    }
+  }
+  async getStatus(order) {
+    const data = await this.transport.post("order", {
+      id: order.provider_order_id,
+      token: order.provider_token
+    });
+    return {
+      ...order,
+      ...normalizeFixedFloatOrder(data, {
+        provider: this.name,
+        payInAsset: order.pay_in_asset,
+        fallback: order
+      })
+    };
+  }
+  async requestRefund(order, refundAddress) {
+    await this.transport.post("emergency", {
+      id: order.provider_order_id,
+      token: order.provider_token,
+      choice: "REFUND",
+      address: refundAddress
+    });
+  }
+  async resolveCurrencies() {
+    const cache = this.cache;
+    if (cache === void 0) {
+      return await this.fetchCurrencyResolution();
+    }
+    return await cache.resolve(swapLimitsMetaKey(this.name), {
+      refreshSeconds: this.cacheSeconds,
+      maxStaleSeconds: Math.max(SWAP_LIMITS_MAX_STALE_SECONDS, this.cacheSeconds),
+      fetch: () => this.fetchCurrencyResolution(),
+      serialize: serializeFixedFloatCurrencyResolution,
+      deserialize: deserializeFixedFloatCurrencyResolution
+    });
+  }
+  async resolveRatesIndex(resolution) {
+    const cache = this.cache;
+    if (cache === void 0) {
+      return await this.fetchRatesIndex(resolution);
+    }
+    return await cache.resolve(swapRatesMetaKey(this.name, "fixed"), {
+      refreshSeconds: this.ratesCacheSeconds,
+      maxStaleSeconds: Math.max(SWAP_RATES_MAX_STALE_SECONDS, this.ratesCacheSeconds),
+      // Crypto rates must not linger after a failed refresh — fail closed so the
+      // service can skip this provider and try the next configured LSC connection.
+      serveStaleOnFailure: false,
+      fetch: () => this.fetchRatesIndex(resolution),
+      serialize: serializeFixedFloatRatesIndex,
+      deserialize: deserializeFixedFloatRatesIndex
+    });
+  }
+  async fetchRatesIndex(resolution) {
+    const path = fixedFloatRatesXmlPath("fixed").replace(/^\//, "");
+    this.transport.logApiRequest(path);
+    try {
+      const fetched = await fetchFixedFloatRatesIndex({
+        baseUrl: this.transport.baseUrl,
+        rateType: "fixed",
+        fetch: this.transport.fetcher,
+        now: this.now,
+        requestTimeoutMs: this.transport.requestTimeoutMs
+      });
+      const index = retainFixedFloatRatePairsForKeys(fetched, fixedFloatRatePairKeys(resolution));
+      this.transport.logApiResponse({
+        path,
+        status: 200,
+        ok: true,
+        data: { pair_count: Object.keys(index.pairs).length }
+      });
+      return index;
+    } catch (error) {
+      this.transport.logApiResponse({
+        path,
+        status: 0,
+        ok: false,
+        msg: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async fetchCurrencyResolution() {
+    const now = this.now();
+    const data = await this.transport.post("ccies", {});
+    return resolveFixedFloatCurrencies(data, { fetchedAt: now, lightningCcy: this.lightningCcy });
+  }
+};
+function readFixedFloatCompatibleProviderId(id) {
+  const normalized = id.trim();
+  if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
+    throw new TypeError(
+      "FixedFloat-compatible provider id must use lowercase letters, numbers, underscores, or hyphens."
+    );
+  }
+  return normalized;
+}
+function amountMsatsToBtcString(amountMsats) {
+  if (!Number.isSafeInteger(amountMsats) || amountMsats <= 0) {
+    throw new RangeError("invoiceAmountMsats must be a positive safe integer.");
+  }
+  const sats = ceilDiv2(BigInt(amountMsats), 1000n);
+  const wholeBtc = sats / OPENRECEIVE_SATS_PER_BTC2;
+  const fractional = String(sats % OPENRECEIVE_SATS_PER_BTC2).padStart(8, "0").replace(/0+$/, "");
+  return fractional.length === 0 ? String(wholeBtc) : `${wholeBtc}.${fractional}`;
+}
+
+// src/lsc-uri.ts
+import { compact } from "@openreceive/core";
+var LSC_URI_PROTOCOL = "lightning+swapconnect:";
+var LSC_ENV_NAMES = ["LSC_URI_PRIMARY", "LSC_URI_BACKUP"];
+var LSC_QUERY_PARAMETERS = /* @__PURE__ */ new Set(["key", "secret"]);
+var MAX_LSC_URI_LENGTH = 8192;
+var MAX_LSC_CREDENTIAL_LENGTH = 2048;
+function parseLscUri(value) {
+  const input = requiredCredential(value, "LSC URI", MAX_LSC_URI_LENGTH);
+  let uri;
+  try {
+    uri = new URL(input);
+  } catch {
+    throw new TypeError("LSC URI is not a valid absolute URI.");
+  }
+  if (uri.protocol !== LSC_URI_PROTOCOL) {
+    throw new TypeError(`LSC URI must use ${LSC_URI_PROTOCOL}//.`);
+  }
+  if (uri.username !== "" || uri.password !== "") {
+    throw new TypeError("LSC URI must not use URI userinfo.");
+  }
+  if (uri.hostname === "") {
+    throw new TypeError("LSC URI requires a provider hostname.");
+  }
+  if (uri.hash !== "") {
+    throw new TypeError("LSC URI must not contain a fragment.");
+  }
+  if (/%(?![0-9a-f]{2})/i.test(uri.search)) {
+    throw new TypeError("LSC URI query encoding is invalid.");
+  }
+  for (const parameter of uri.searchParams.keys()) {
+    if (!LSC_QUERY_PARAMETERS.has(parameter)) {
+      throw new TypeError("LSC URI contains an unsupported query parameter.");
+    }
+  }
+  const key = requiredCredential(
+    singleParameter(uri, "key"),
+    "LSC URI key",
+    MAX_LSC_CREDENTIAL_LENGTH
+  );
+  const secret = requiredCredential(
+    singleParameter(uri, "secret"),
+    "LSC URI secret",
+    MAX_LSC_CREDENTIAL_LENGTH
+  );
+  const baseUrl = `https://${uri.host}${normalizeEndpointPath(uri.pathname)}`;
+  return {
+    uriProtocol: LSC_URI_PROTOCOL,
+    baseUrl,
+    providerId: providerIdFromUri(uri),
+    key,
+    secret
+  };
+}
+function formatLscUri(input) {
+  const endpoint = parseHttpsEndpoint(input.baseUrl);
+  const key = requiredCredential(input.key, "LSC key", MAX_LSC_CREDENTIAL_LENGTH);
+  const secret = requiredCredential(input.secret, "LSC secret", MAX_LSC_CREDENTIAL_LENGTH);
+  const uri = new URL(
+    `${LSC_URI_PROTOCOL}//${endpoint.host}${normalizeEndpointPath(endpoint.pathname)}`
+  );
+  uri.searchParams.set("key", key);
+  uri.searchParams.set("secret", secret);
+  return uri.toString();
+}
+function readLscConnectionsFromEnvironment(environment = process.env) {
+  const connections = [];
+  const providerIds = /* @__PURE__ */ new Set();
+  for (const name of LSC_ENV_NAMES) {
+    const value = environment[name]?.trim();
+    if (!value) continue;
+    let connection;
+    try {
+      connection = parseLscUri(value);
+    } catch (error) {
+      throw new TypeError(
+        `${name} is invalid: ${error instanceof Error ? error.message : "invalid LSC URI"}`
+      );
+    }
+    if (providerIds.has(connection.providerId)) {
+      throw new TypeError(`${name} duplicates another LSC provider id.`);
+    }
+    providerIds.add(connection.providerId);
+    connections.push(connection);
+  }
+  return connections;
+}
+function createLscSwapProvidersFromEnvironment(environment = process.env, options = {}) {
+  return readLscConnectionsFromEnvironment(environment).map(
+    (connection) => fixedFloatCompatibleSwapProvider(
+      compact({
+        id: connection.providerId,
+        baseUrl: connection.baseUrl,
+        key: connection.key,
+        secret: connection.secret,
+        fetch: options.fetch,
+        now: options.now
+      })
+    )
+  );
+}
+function singleParameter(uri, name) {
+  const values = uri.searchParams.getAll(name);
+  if (values.length !== 1) {
+    throw new TypeError(`LSC URI requires exactly one ${name} parameter.`);
+  }
+  return values[0] ?? "";
+}
+function requiredCredential(value, label, maximumLength) {
+  const normalized = value.trim();
+  if (normalized.length === 0) throw new TypeError(`${label} must not be empty.`);
+  if (normalized.length > maximumLength) throw new TypeError(`${label} is too long.`);
+  return normalized;
+}
+function parseHttpsEndpoint(value) {
+  let endpoint;
+  try {
+    endpoint = new URL(value);
+  } catch {
+    throw new TypeError("LSC baseUrl must be a valid HTTPS URL.");
+  }
+  if (endpoint.protocol !== "https:" || endpoint.hostname === "" || endpoint.username !== "" || endpoint.password !== "" || endpoint.search !== "" || endpoint.hash !== "") {
+    throw new TypeError(
+      "LSC baseUrl must be an HTTPS URL without userinfo, query parameters, or a fragment."
+    );
+  }
+  return endpoint;
+}
+function normalizeEndpointPath(pathname) {
+  if (pathname === "" || pathname === "/") return "/";
+  return pathname.endsWith("/") ? pathname : `${pathname}/`;
+}
+function providerIdFromUri(uri) {
+  const path = uri.pathname.split("/").filter(Boolean).join("-");
+  const raw = `${uri.hostname}${uri.port ? `-${uri.port}` : ""}${path ? `-${path}` : ""}`.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  if (!raw) throw new TypeError("LSC URI could not derive a provider id.");
+  return raw;
+}
+
+// src/service/logging.ts
+import { compact as compact2, isRecord } from "@openreceive/core";
+function emitLog(options, level, event, message, fields = {}) {
+  emitEvent(options, {
+    level,
+    event,
+    message,
+    ...fields
+  });
+}
+function emitEvent(options, event) {
+  if (options.onEvent === void 0 && options.logger === void 0) return;
+  const sanitized = sanitizeEvent(event);
+  try {
+    options.onEvent?.(sanitized);
+  } catch {
+  }
+  try {
+    options.logger?.(sanitized);
+  } catch {
+  }
+}
+function createNwcEndpointLogger(options) {
+  if (options.onEvent === void 0 && options.logger === void 0) return void 0;
+  return (entry) => emitEvent(options, entry);
+}
+function sanitizeEvent(entry) {
+  const clean = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (isSensitiveLogKey(key)) {
+      clean[key] = "[REDACTED]";
+    } else {
+      clean[key] = sanitizeLogValue(value);
+    }
+  }
+  return clean;
+}
+function sanitizeLogValue(value) {
+  if (typeof value === "string") return redactSecrets(value);
+  if (Array.isArray(value)) return value.map(sanitizeLogValue);
+  if (typeof value !== "object" || value === null) return value;
+  const clean = {};
+  for (const [key, nested] of Object.entries(value)) {
+    if (isSensitiveLogKey(key)) {
+      clean[key] = "[REDACTED]";
+    } else {
+      clean[key] = sanitizeLogValue(nested);
+    }
+  }
+  return clean;
+}
+function isSensitiveLogKey(key) {
+  if (/_present$/i.test(key)) return false;
+  return /secret|token|authorization|cookie|nwc|dsn|preimage|invoice|bolt11|swap_?data|(?:private|api)[_-]?key|^key$|api[_-]?sign/i.test(
+    key
+  );
+}
+function redactSecrets(value) {
+  return value.replace(/nostr\+walletconnect:[^\s"'`<>]+/g, "[REDACTED_NWC]").replace(/lightning\+swapconnect:[^\s"'`<>]+/g, "[REDACTED_LSC]").replace(/([?&](?:token|secret|key)=)[^&\s"'`<>]+/gi, "$1[REDACTED]");
+}
+function summarizeSwapProviderApiRequest(entry) {
+  const body = isRecord(entry.body) ? entry.body : void 0;
+  return compact2({
+    provider: entry.provider,
+    path: entry.path,
+    reference: optionalLogString(body?.id),
+    choice: optionalLogString(body?.choice),
+    from_ccy: optionalLogString(body?.fromCcy),
+    to_ccy: optionalLogString(body?.toCcy),
+    amount: optionalLogString(body?.amount) ?? optionalLogNumber(body?.amount)
+  });
+}
+function summarizeSwapProviderApiResponse(entry) {
+  const summary = {
+    provider: entry.provider,
+    path: entry.path,
+    status: entry.status,
+    ok: entry.ok
+  };
+  if (entry.code !== void 0 && entry.code !== null) summary.code = entry.code;
+  const msg = optionalLogString(entry.msg);
+  if (msg !== void 0 && msg !== "OK") summary.msg = msg;
+  const data = entry.data;
+  if (Array.isArray(data)) {
+    summary.items = data.length;
+    return summary;
+  }
+  if (!isRecord(data)) return summary;
+  const pairCount = optionalLogNumber(data.pair_count);
+  if (pairCount !== void 0) {
+    summary.pair_count = pairCount;
+    return summary;
+  }
+  const reference = optionalLogString(data.id);
+  const orderStatus = optionalLogString(data.status);
+  if (reference !== void 0) summary.reference = reference;
+  if (orderStatus !== void 0) summary.order_status = orderStatus;
+  const from = summarizeSwapProviderSide(data.from);
+  const to = summarizeSwapProviderSide(data.to);
+  if (from !== void 0) summary.from = from;
+  if (to !== void 0) summary.to = to;
+  if (isRecord(data.time)) {
+    const left = optionalLogNumber(data.time.left);
+    if (left !== void 0) summary.left = left;
+  }
+  if (isRecord(data.emergency)) {
+    const choice = optionalLogString(data.emergency.choice);
+    if (choice !== void 0 && choice !== "NONE") summary.emergency = choice;
+    const statuses = Array.isArray(data.emergency.status) ? data.emergency.status.filter((item) => typeof item === "string" && item.length > 0).map((item) => item.toUpperCase()) : [];
+    if (statuses.length > 0) summary.emergency_status = statuses.join(",");
+    const repeat = data.emergency.repeat;
+    if (repeat === true || repeat === "1" || repeat === 1) summary.emergency_repeat = true;
+  }
+  if (isRecord(data.from) && isRecord(data.from.tx)) {
+    const received = optionalLogString(data.from.tx.amount);
+    if (received !== void 0) summary.deposit_received = received;
+  }
+  if (isRecord(data.back)) {
+    const refundAmount = optionalLogString(data.back.amount);
+    if (refundAmount !== void 0) summary.refund_amount = refundAmount;
+  }
+  if (reference === void 0) {
+    const fromRecord = isRecord(data.from) ? data.from : void 0;
+    const toRecord = isRecord(data.to) ? data.to : void 0;
+    const fromAmount = optionalLogString(fromRecord?.amount) ?? optionalLogString(data.fromAmount);
+    const toAmount = optionalLogString(toRecord?.amount) ?? optionalLogString(data.toAmount);
+    if (fromAmount !== void 0) summary.from_amount = fromAmount;
+    if (toAmount !== void 0) summary.to_amount = toAmount;
+  }
+  return summary;
+}
+function summarizeSwapProviderSide(side) {
+  if (!isRecord(side)) return void 0;
+  const code = optionalLogString(side.code) ?? optionalLogString(side.coin);
+  const amount = optionalLogString(side.amount);
+  if (code === void 0 && amount === void 0) return void 0;
+  if (code !== void 0 && amount !== void 0) return `${code} ${amount}`;
+  return code ?? amount;
+}
+function optionalLogString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function optionalLogNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+export {
+  OPENRECEIVE_SWAP_PAY_IN_ASSETS,
+  isSwapPayInAsset,
+  listSwapAssetInfo,
+  TransientSwapCache,
+  fixedFloatProvider,
+  fixedFloatCompatibleSwapProvider,
+  formatLscUri,
+  readLscConnectionsFromEnvironment,
+  createLscSwapProvidersFromEnvironment,
+  emitLog,
+  createNwcEndpointLogger,
+  sanitizeEvent,
+  redactSecrets,
+  summarizeSwapProviderApiRequest,
+  summarizeSwapProviderApiResponse
+};