@satora/swap 1.4.0 → 1.6.0

package/dist/index.cjs

@@ -36,8 +36,12 @@ var bitcoin_reader_esplora_exports = {};
 __export(bitcoin_reader_esplora_exports, {
   DEFAULT_ESPLORA_URLS: () => DEFAULT_ESPLORA_URLS,
   esploraReader: () => esploraReader,
-  htlcFactsFromEsploraTxs: () => htlcFactsFromEsploraTxs
+  htlcFactsFromEsploraTxs: () => htlcFactsFromEsploraTxs,
+  resolveMinConfirmations: () => resolveMinConfirmations
 });
+function resolveMinConfirmations(source) {
+  return (typeof source === "function" ? source() : source) ?? 0;
+}
 function htlcFactsFromEsploraTxs(txs, address, opts) {
   for (const tx of txs) {
     const spend = tx.vin.find(
@@ -80,11 +84,10 @@ function esploraReader(esploraUrls, fetchImpl = fetch, policy) {
   const bases = (Array.isArray(esploraUrls) ? esploraUrls : [esploraUrls]).map(
     (url) => url.replace(/\/+$/, "")
   );
-  const minConf = policy?.minConfirmations ?? 0;
   let start = 0;
   return {
     async getHtlcFacts(address, minConfirmations) {
-      const required = minConfirmations ?? minConf;
+      const required = minConfirmations ?? resolveMinConfirmations(policy?.minConfirmations);
       const from = start++ % bases.length;
       let lastError;
       for (let i = 0; i < bases.length; i++) {
@@ -145,11 +148,12 @@ function scriptHashOf(script) {
 }
 function electrumReader(client, opts) {
   const network = opts?.network ?? "mainnet";
-  const defaultMinConf = opts?.minConfirmations ?? 0;
   const fallback2 = opts?.fallback;
-  const scriptFor = (address) => btc.OutScript.encode(
-    btc.Address(toBtcSignerNetwork(network)).decode(address)
-  );
+  const scriptFor = (address) => {
+    const decoded = btc.Address(toBtcSignerNetwork(network)).decode(address);
+    if (!decoded) throw new Error(`Unrecognised Bitcoin address: ${address}`);
+    return btc.OutScript.encode(decoded);
+  };
   async function getHtlcFactsElectrum(address, required) {
     const script = scriptFor(address);
     const scripthash = scriptHashOf(script);
@@ -231,7 +235,7 @@ function electrumReader(client, opts) {
   }
   return {
     async getHtlcFacts(address, minConfirmations) {
-      const required = minConfirmations ?? defaultMinConf;
+      const required = minConfirmations ?? resolveMinConfirmations(opts?.minConfirmations);
       try {
         return await getHtlcFactsElectrum(address, required);
       } catch (error) {
@@ -273,6 +277,7 @@ var init_bitcoin_reader_electrum = __esm({
     import_sha22 = require("@noble/hashes/sha2.js");
     import_base5 = require("@scure/base");
     btc = __toESM(require("@scure/btc-signer"), 1);
+    init_bitcoin_reader_esplora();
     REGTEST_NETWORK = {
       bech32: "bcrt",
       pubKeyHash: 111,
@@ -308,6 +313,7 @@ __export(src_exports, {
   htlcFactsFromEsploraTxs: () => htlcFactsFromEsploraTxs,
   htlcKey: () => htlcKey,
   htlcQueryKey: () => htlcQueryKey,
+  resolveMinConfirmations: () => resolveMinConfirmations,
   swapToTracked: () => swapToTracked
 });
 module.exports = __toCommonJS(src_exports);
@@ -667,7 +673,7 @@ function payOnLightningStatus(serverHtlc) {
 }
 
 // src/client.ts
-var import_lendaswap_sdk_pure2 = require("@lendasat/lendaswap-sdk-pure");
+var import_lendaswap_sdk_pure3 = require("@lendasat/lendaswap-sdk-pure");
 
 // src/contracts/arkade-manager.ts
 var import_sdk2 = require("@arkade-os/sdk");
@@ -1112,7 +1118,10 @@ function refQueryKey(ref) {
 var AVG_BLOCK_MS = {
   1: 12e3,
   137: 2100,
-  42161: 250
+  42161: 250,
+  30: 3e4,
+  31: 3e4
+  // Rootstock testnet: same merge-mined cadence
 };
 var SCAN_MARGIN_BLOCKS = 1000n;
 var EvmContractManager = class _EvmContractManager {
@@ -1293,7 +1302,10 @@ var EvmContractManager = class _EvmContractManager {
     for (const ref of refs) {
       const { observation, preimage } = evmObservation(
         events.get(refQueryKey(ref)) ?? [],
-        { amount: ref.expectedAmount, token: ref.expectedToken }
+        {
+          amount: ref.minAmount ?? ref.expectedAmount,
+          token: ref.expectedToken
+        }
       );
       const key = htlcKey(ref);
       if (preimage) this.#preimages.set(key, preimage);
@@ -1368,7 +1380,10 @@ var DEFAULT_EVM_RPCS = {
     "https://arb1.arbitrum.io/rpc",
     "https://arbitrum.drpc.org",
     "https://arbitrum-one-rpc.publicnode.com"
-  ]
+  ],
+  // Rootstock: the public node, HTTP only (no WebSocket endpoint exists).
+  30: ["https://public-node.rsk.co"],
+  31: ["https://public-node.testnet.rsk.co"]
 };
 var SWAP_CREATED = (0, import_viem.parseAbiItem)(
   "event SwapCreated(bytes32 indexed preimageHash, address indexed refundAddress, address indexed claimAddress, address token, uint256 amount, uint256 timelock, bytes32 key)"
@@ -1401,25 +1416,52 @@ function activeKey(q) {
     }
   });
 }
-function evmReaderFromClient(client) {
+function evmReaderFromClient(client, options = {}) {
+  const { maxBlockRange } = options;
+  async function getLogs(filter, fromBlock) {
+    if (maxBlockRange === void 0) {
+      return client.request({
+        method: "eth_getLogs",
+        params: [{ ...filter, fromBlock: (0, import_viem.numberToHex)(fromBlock) }]
+      });
+    }
+    const latest = (await client.getBlock()).number;
+    if (latest === null) {
+      throw new Error("latest block has no number");
+    }
+    const logs = [];
+    for (let from = fromBlock; from <= latest; from += maxBlockRange) {
+      const to = from + maxBlockRange - 1n < latest ? from + maxBlockRange - 1n : latest;
+      logs.push(
+        ...await client.request({
+          method: "eth_getLogs",
+          params: [
+            {
+              ...filter,
+              fromBlock: (0, import_viem.numberToHex)(from),
+              toBlock: (0, import_viem.numberToHex)(to)
+            }
+          ]
+        })
+      );
+    }
+    return logs;
+  }
   return {
     async getHtlcEventsBatch(queries, fromBlock = 0n) {
       const results = /* @__PURE__ */ new Map();
       if (queries.length === 0) return results;
       for (const q of queries) results.set(htlcQueryKey(q), []);
-      const logs = await client.request({
-        method: "eth_getLogs",
-        params: [
-          {
-            address: unique(queries.map((q) => q.htlc)),
-            topics: [
-              HTLC_EVENT_TOPICS,
-              unique(queries.map((q) => q.preimageHash))
-            ],
-            fromBlock: (0, import_viem.numberToHex)(fromBlock)
-          }
-        ]
-      });
+      const logs = await getLogs(
+        {
+          address: unique(queries.map((q) => q.htlc)),
+          topics: [
+            HTLC_EVENT_TOPICS,
+            unique(queries.map((q) => q.preimageHash))
+          ]
+        },
+        fromBlock
+      );
       const grouped = /* @__PURE__ */ new Map();
       for (const log of logs) {
         const decoded = tryDecode(log);
@@ -1535,12 +1577,16 @@ function toHtlcEvent(decoded, query) {
 function unique(values) {
   return [...new Set(values)];
 }
-function createEvmRpcReader(rpcUrls) {
+function createEvmRpcReader(rpcUrls, options = {}) {
   const urls = Array.isArray(rpcUrls) ? rpcUrls : [rpcUrls];
   const transport = urls.length > 1 ? (0, import_viem.fallback)(urls.map((url) => (0, import_viem.http)(url))) : (0, import_viem.http)(urls[0]);
   const client = (0, import_viem.createPublicClient)({ transport });
-  return evmReaderFromClient(client);
+  return evmReaderFromClient(client, options);
 }
+var EVM_LOG_RANGE_LIMITS = {
+  30: 2000n,
+  31: 2000n
+};
 function defaultEvmReaders(overrides) {
   const chainIds = /* @__PURE__ */ new Set([
     ...Object.keys(DEFAULT_EVM_RPCS).map(Number),
@@ -1551,7 +1597,13 @@ function defaultEvmReaders(overrides) {
     const override = overrides?.[chainId];
     const defaults = DEFAULT_EVM_RPCS[chainId] ?? [];
     const urls = override ? [override, ...defaults] : defaults;
-    if (urls.length > 0) readers.set(chainId, createEvmRpcReader(urls));
+    if (urls.length > 0)
+      readers.set(
+        chainId,
+        createEvmRpcReader(urls, {
+          maxBlockRange: EVM_LOG_RANGE_LIMITS[chainId]
+        })
+      );
   }
   return readers;
 }
@@ -2006,6 +2058,9 @@ function defaultWebSocketFactory(url) {
   return new WS(url);
 }
 
+// src/tracker/from-swap.ts
+var import_lendaswap_sdk_pure2 = require("@lendasat/lendaswap-sdk-pure");
+
 // src/contracts/arkade-vhtlc.ts
 var import_sdk3 = require("@arkade-os/sdk");
 var import_lendaswap_sdk_pure = require("@lendasat/lendaswap-sdk-pure");
@@ -2091,6 +2146,7 @@ function evmLeg(args) {
     preimageHash: ensure0x(args.hashLock),
     claimAddress: ensure0x(args.claimAddress),
     expectedAmount: BigInt(args.expectedSats),
+    minAmount: args.minAmount,
     expectedToken: args.token ? ensure0x(args.token) : void 0,
     sender: args.sender ? ensure0x(args.sender) : void 0,
     timelockSec: args.timelockSec,
@@ -2098,6 +2154,13 @@ function evmLeg(args) {
   };
 }
 var CLIENT_FUNDING_MIN_CONFIRMATIONS = 1;
+var FEE_ROUNDING_SLACK_SATS = 2;
+function minServerPayout(r) {
+  return Math.max(
+    0,
+    Number(r.target_amount) - r.fee_sats - FEE_ROUNDING_SLACK_SATS
+  );
+}
 function bitcoinLeg(address, hashLock, expectedSats, minConfirmations) {
   return {
     ledger: "bitcoin",
@@ -2142,15 +2205,19 @@ function swapToTracked(stored) {
           claimAddress: r.server_evm_address,
           // the server claims the client's EVM HTLC
           expectedSats: r.evm_expected_sats,
-          // evm_to_arkade doesn't expose the locked token — fall back to the
-          // per-chain mainnet constant so the isActive tuple is complete.
-          token: lockedTokenFallback(r.evm_chain_id, r.network),
-          sender: r.client_evm_address,
-          // the client funded it
+          minAmount: 0n,
+          // see SHORT_LOCK_RULE
+          // A native lock's asset word is zero; an ERC20 lock's token is not
+          // on this response yet, so fall back to the per-chain mainnet
+          // constant to complete the isActive tuple.
+          token: r.evm_htlc_kind === "native" ? import_lendaswap_sdk_pure2.NATIVE_TOKEN_ADDRESS : lockedTokenFallback(r.evm_chain_id, r.network),
+          // The coordinator created the HTLC on the client's behalf, so it
+          // is the lock's sender (refund address), as on evm_to_lightning.
+          sender: r.evm_coordinator_address,
           timelockSec: r.evm_refund_locktime,
           createdAt: r.created_at
         }),
-        serverHtlc: arkadeLeg(r, r.btc_vhtlc_address, Number(r.target_amount)),
+        serverHtlc: arkadeLeg(r, r.btc_vhtlc_address, minServerPayout(r)),
         clientRefundLocktime: ms(r.evm_refund_locktime),
         serverRefundLocktime: ms(r.vhtlc_refund_locktime)
       };
@@ -2191,16 +2258,19 @@ function swapToTracked(stored) {
           claimAddress: r.server_evm_address,
           // the server claims the client's EVM HTLC
           expectedSats: r.evm_expected_sats,
+          minAmount: 0n,
+          // see SHORT_LOCK_RULE
           token: r.wbtc_address,
-          sender: r.client_evm_address,
-          // the client funded it
+          // The coordinator created the HTLC on the client's behalf, so it
+          // is the lock's sender (refund address).
+          sender: r.evm_coordinator_address,
           timelockSec: r.evm_refund_locktime,
           createdAt: r.created_at
         }),
         serverHtlc: bitcoinLeg(
           r.btc_htlc_address,
           r.evm_hash_lock,
-          Number(r.target_amount)
+          minServerPayout(r)
         ),
         clientRefundLocktime: ms(r.evm_refund_locktime),
         serverRefundLocktime: ms(r.btc_refund_locktime)
@@ -2318,21 +2388,38 @@ function swapToTracked(stored) {
 }
 
 // src/tracker/swap-tracker.ts
+var CLAIM_SUBMITTED = /* @__PURE__ */ new Set([
+  "clientredeeming",
+  "clientredeemed",
+  "serverredeemed"
+]);
+var DEFAULT_AT_RISK_RECONCILE_INTERVAL_MS = 6e4;
+var RETRY_UNREGISTERED_INTERVAL_MS = 6e4;
 var SwapTracker = class {
   #managers;
   #swaps = /* @__PURE__ */ new Map();
+  /**
+   * Swaps whose startup registration failed (a chain read that errored).
+   * Retried every minute; dropping them would leave an active swap
+   * unwatched for the whole session with no claim or refund surfaced.
+   */
+  #unregistered = /* @__PURE__ */ new Map();
   /** Last actions emitted per swap — for dedupe and the subscribe-time snapshot. */
   #lastActions = /* @__PURE__ */ new Map();
+  /** The latest server status hint per swap, for {@link #withClaimHint}. */
+  #hintStatuses = /* @__PURE__ */ new Map();
   #subscribers = /* @__PURE__ */ new Set();
   #refreshIntervalMs;
   #atRiskReconcileIntervalMs;
   #lastAtRiskReconcileAt = 0;
+  #lastRetryAt = 0;
   #eventUnsubs = [];
   #timer;
   constructor(managers, options) {
     this.#managers = managers;
     this.#refreshIntervalMs = options?.refreshIntervalMs ?? 0;
-    this.#atRiskReconcileIntervalMs = options?.atRiskReconcileIntervalMs ?? 6e4;
+    const atRisk = options?.atRiskReconcileIntervalMs ?? DEFAULT_AT_RISK_RECONCILE_INTERVAL_MS;
+    this.#atRiskReconcileIntervalMs = typeof atRisk === "function" ? atRisk : () => atRisk;
   }
   /**
    * Whether every on-chain leg of `swap` is observable — i.e. the tracker can
@@ -2355,7 +2442,22 @@ var SwapTracker = class {
         continue;
       }
       this.#swaps.set(swap.swapId, swap);
-      for (const leg of legsOf(swap)) await this.#managerFor(leg).register(leg);
+      const registered = [];
+      try {
+        for (const leg of legsOf(swap)) {
+          await this.#managerFor(leg).register(leg);
+          registered.push(leg);
+        }
+      } catch (error) {
+        this.#swaps.delete(swap.swapId);
+        for (const leg of registered)
+          void this.#managerFor(leg).unregister(leg);
+        this.#unregistered.set(swap.swapId, swap);
+        console.warn(
+          `SwapTracker: swap ${swap.swapId} not tracked yet, registering its legs failed (will retry):`,
+          error
+        );
+      }
     }
     for (const manager of new Set(this.#managers.values())) {
       this.#eventUnsubs.push(manager.onEvent(() => this.#recomputeAll()));
@@ -2363,6 +2465,7 @@ var SwapTracker = class {
     await this.#refreshManagers();
     this.#recomputeAll();
     this.#lastAtRiskReconcileAt = Date.now();
+    this.#lastRetryAt = this.#lastAtRiskReconcileAt;
     if (this.#refreshIntervalMs > 0)
       this.#timer = setInterval(
         () => void this.#tick(),
@@ -2412,7 +2515,11 @@ var SwapTracker = class {
    */
   async #tick() {
     const now = Date.now();
-    if (now - this.#lastAtRiskReconcileAt >= this.#atRiskReconcileIntervalMs) {
+    if (now - this.#lastRetryAt >= RETRY_UNREGISTERED_INTERVAL_MS) {
+      this.#lastRetryAt = now;
+      await this.#retryUnregistered();
+    }
+    if (now - this.#lastAtRiskReconcileAt >= this.#atRiskReconcileIntervalMs()) {
       this.#lastAtRiskReconcileAt = now;
       const legs = [...this.#swaps.values()].filter((swap) => this.#isAtRisk(swap)).flatMap((swap) => legsOf(swap));
       await Promise.all(
@@ -2425,6 +2532,25 @@ var SwapTracker = class {
     }
     this.#recomputeAll();
   }
+  /**
+   * Second attempt at swaps whose startup registration failed, on its own
+   * cadence so a slow at-risk interval can't delay it. `track` is idempotent
+   * and rolls back on failure, so a chain that is still down just leaves the
+   * swap here for the next round.
+   */
+  async #retryUnregistered() {
+    for (const [swapId, swap] of this.#unregistered) {
+      try {
+        await this.track(swap);
+        this.#unregistered.delete(swapId);
+      } catch (error) {
+        console.warn(
+          `SwapTracker: retrying registration of ${swapId} failed:`,
+          error
+        );
+      }
+    }
+  }
   /**
    * Whether a swap needs chain-verified monitoring independent of the server:
    * its client leg holds (or held) funds on-chain, so knowing when a refund
@@ -2484,6 +2610,7 @@ var SwapTracker = class {
   async applyHint(swapId, opts) {
     const swap = this.#swaps.get(swapId);
     if (!swap) return;
+    if (opts?.status !== void 0) this.#hintStatuses.set(swapId, opts.status);
     const legs = legsOf(swap);
     const results = await Promise.allSettled(
       legs.map((leg) => this.#managerFor(leg).reconcile(leg))
@@ -2520,6 +2647,7 @@ var SwapTracker = class {
       for (const leg of legsOf(swap))
         void this.#managerFor(leg).unregister(leg);
     this.#swaps.clear();
+    this.#unregistered.clear();
     this.#subscribers.clear();
   }
   #managerFor(ref) {
@@ -2531,6 +2659,28 @@ var SwapTracker = class {
   #recomputeAll() {
     for (const swap of this.#swaps.values()) this.#recompute(swap);
   }
+  /**
+   * A server hint that the claim was submitted overrides a chain view that
+   * still says "claim now". The claim is relayed by the server, so once it
+   * reports the redeem in flight, another claim can only be refused; and a
+   * chain that cannot be read (no `eth_getLogs` on the public Rootstock RPCs)
+   * keeps its stale pre-claim observation for good. The chain still wins once
+   * it moves: a fresh `spent_claim` derives past the hint on its own, and a
+   * refund observed on chain is not overridden.
+   *
+   * The override lasts only while the server's claim window is open. Once the
+   * server can refund its leg, the chain view is what protects the client: the
+   * `serverfunded` rules never claim then and lead to the client's own refund
+   * at its timelock. A claim that really landed shows up on chain long before
+   * that; a hint that never did must not hide the refund.
+   */
+  #withClaimHint(swap, derived, serverChainNow) {
+    const hint = this.#hintStatuses.get(swap.swapId);
+    if (hint === void 0 || !CLAIM_SUBMITTED.has(hint)) return derived;
+    if (derived !== "serverfunded") return derived;
+    const claimWindowOpen = serverChainNow < swap.serverRefundLocktime;
+    return claimWindowOpen ? hint : derived;
+  }
   #recompute(swap, force = false) {
     let clientHtlc;
     let serverHtlc;
@@ -2550,8 +2700,9 @@ var SwapTracker = class {
       if (serverHtlc === void 0 || now === void 0) return;
       serverChainNow = now;
     }
-    const status = deriveSwapStatus({ clientHtlc, serverHtlc });
-    if (status === void 0) return;
+    const derived = deriveSwapStatus({ clientHtlc, serverHtlc });
+    if (derived === void 0) return;
+    const status = this.#withClaimHint(swap, derived, serverChainNow);
     const actions = {
       ...deriveSwapActions({
         status,
@@ -2602,14 +2753,18 @@ var Client = class {
   #startPromise;
   /** Swap ids whose settled status was already re-fetched this session. */
   #settledSyncDone = /* @__PURE__ */ new Set();
+  /** Read per chain read, so it can change without rebuilding the client. */
+  #bitcoinMinConfirmations;
   constructor(...args) {
-    if (args[0] instanceof import_lendaswap_sdk_pure2.Client) {
+    if (args[0] instanceof import_lendaswap_sdk_pure3.Client) {
       this.#legacy = args[0];
       this.#tracking = args[1] ?? {
         enabled: false
       };
+      assertMinConfirmations(this.#tracking.bitcoinMinConfirmations);
+      this.#bitcoinMinConfirmations = this.#tracking.bitcoinMinConfirmations;
     } else {
-      this.#legacy = new import_lendaswap_sdk_pure2.Client(
+      this.#legacy = new import_lendaswap_sdk_pure3.Client(
         ...args
       );
       this.#tracking = { enabled: false };
@@ -2790,6 +2945,10 @@ var Client = class {
     return this.#legacy.claim(...args);
   }
   /** Delegated to the legacy client (migration checkpoint). */
+  claimEvmWithSigner(...args) {
+    return this.#legacy.claimEvmWithSigner(...args);
+  }
+  /** Delegated to the legacy client (migration checkpoint). */
   claimViaGasless(...args) {
     return this.#legacy.claimViaGasless(...args);
   }
@@ -2918,6 +3077,22 @@ var Client = class {
     return this.#legacy.hasReceivedVtxo(...args);
   }
   // --- Satora-native features go below ---
+  /** Confirmations a server-funded Bitcoin HTLC needs before it is claimable. */
+  getBitcoinMinConfirmations() {
+    return this.#bitcoinMinConfirmations;
+  }
+  /**
+   * At `0` the claim goes out against a mempool funding, trusting the funder
+   * not to replace it once the claim reveals the preimage.
+   *
+   * Only the chain monitors read a depth, so this does nothing unless the
+   * client was built with {@link ClientBuilder.withChainVerifiedTracking}.
+   * Takes effect on subsequent reads, including swaps already tracked.
+   */
+  setBitcoinMinConfirmations(minConfirmations) {
+    assertMinConfirmations(minConfirmations);
+    this.#bitcoinMinConfirmations = minConfirmations;
+  }
   /**
    * Start observing the user's active swaps and deriving each one's next action.
    *
@@ -2946,8 +3121,18 @@ var Client = class {
   async #doStartTracking() {
     try {
       const chainVerified = this.#tracking.chainVerified || this.#tracking.managers !== void 0;
+      if (!chainVerified && (this.#bitcoinMinConfirmations ?? 0) > 0)
+        console.warn(
+          "Client: bitcoinMinConfirmations is set but tracking follows server hints, which carry no depth. Build with ClientBuilder.withChainVerifiedTracking() for the depth to gate the claim."
+        );
       const tracker = chainVerified ? new SwapTracker(await this.#ensureManagers(), {
-        refreshIntervalMs: this.#tracking.refreshIntervalMs ?? 5e3
+        refreshIntervalMs: this.#tracking.refreshIntervalMs ?? 5e3,
+        // Depth is only re-derived on a chain read, and nothing pushes on a
+        // new block (an Electrum scripthash status doesn't change once the
+        // funding is in a block), so a deep policy would otherwise sit out
+        // the default interval after the block that satisfied it. Read per
+        // tick, like the depth itself, so a setter call after start counts.
+        atRiskReconcileIntervalMs: () => (this.#bitcoinMinConfirmations ?? 0) > 1 ? 15e3 : DEFAULT_AT_RISK_RECONCILE_INTERVAL_MS
       }) : new HintTracker({
         fetchStatus: async (swapId) => (await this.getSwap(swapId, { updateStorage: true })).status,
         refreshIntervalMs: this.#tracking.refreshIntervalMs ?? 5e3
@@ -3133,8 +3318,7 @@ var Client = class {
       evmRpcUrls,
       esploraUrl,
       electrumWsUrl,
-      bitcoinNetwork,
-      bitcoinMinConfirmations
+      bitcoinNetwork
     } = this.#tracking;
     const chainTime = async () => (await this.getMtp()).mtp * 1e3;
     const arkadeUrl = arkadeServerUrl ?? defaultArkadeServerUrl("bitcoin");
@@ -3152,10 +3336,10 @@ var Client = class {
       "bitcoin",
       await BitcoinContractManager.create({
         esploraUrl: esploraUrl ? [esploraUrl] : DEFAULT_ESPLORA_URLS,
-        electrumWsUrl: electrumWsUrl ?? import_lendaswap_sdk_pure2.DEFAULT_ELECTRUM_WS_URLS[network],
+        electrumWsUrl: electrumWsUrl ?? import_lendaswap_sdk_pure3.DEFAULT_ELECTRUM_WS_URLS[network],
         network,
         chainTime,
-        minConfirmations: bitcoinMinConfirmations
+        minConfirmations: () => this.#bitcoinMinConfirmations
       })
     );
     this.#managers = managers;
@@ -3163,7 +3347,7 @@ var Client = class {
   }
 };
 var ClientBuilder = class {
-  #inner = import_lendaswap_sdk_pure2.Client.builder();
+  #inner = import_lendaswap_sdk_pure3.Client.builder();
   // Observe-mode tracking is on by default; the built client auto-builds its
   // managers from config unless disabled or given an explicit override.
   #trackingEnabled = true;
@@ -3276,9 +3460,11 @@ var ClientBuilder = class {
    * funding hits the mempool, which TRUSTS the funder not to double-spend it
    * (claiming publishes the preimage, so a funder that then replaced its
    * funding could take both legs). Set `1` (or more) for a block-depth policy
-   * that doesn't rely on the funder's good behaviour.
+   * that doesn't rely on the funder's good behaviour. Read only by the chain
+   * monitors, so it needs {@link withChainVerifiedTracking} to have any effect.
    */
   withBitcoinMinConfirmations(minConfirmations) {
+    assertMinConfirmations(minConfirmations);
     this.#bitcoinMinConfirmations = minConfirmations;
     return this;
   }
@@ -3335,6 +3521,13 @@ var ClientBuilder = class {
     });
   }
 };
+function assertMinConfirmations(value) {
+  if (value === void 0) return;
+  if (!Number.isInteger(value) || value < 0)
+    throw new Error(
+      `bitcoinMinConfirmations must be a non-negative integer, got ${value}`
+    );
+}
 function legacyBaseUrl(legacy) {
   try {
     return legacy.baseUrl;
@@ -3383,6 +3576,7 @@ init_bitcoin_reader_esplora();
   htlcFactsFromEsploraTxs,
   htlcKey,
   htlcQueryKey,
+  resolveMinConfirmations,
   swapToTracked,
   ...require("@lendasat/lendaswap-sdk-pure")
 });