@satora/swap 0.3.2 → 1.1.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -19,6 +21,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/contracts/bitcoin-reader-esplora.ts
@@ -41,11 +51,17 @@ function htlcFactsFromEsploraTxs(txs, address, opts) {
         spendWitness: spend.witness ?? []
       };
   }
-  const funding = txs.find(
-    (tx) => tx.vout.some((vout) => vout.scriptpubkey_address === address)
-  );
+  const paidSats = (tx) => tx.vout.filter((vout) => vout.scriptpubkey_address === address).reduce((sum, vout) => sum + (vout.value ?? 0), 0);
+  let funding;
+  let fundedSats = 0;
+  for (const tx of txs) {
+    const paid = paidSats(tx);
+    if (paid > fundedSats) {
+      funding = tx;
+      fundedSats = paid;
+    }
+  }
   if (funding) {
-    const fundedSats = funding.vout.filter((vout) => vout.scriptpubkey_address === address).reduce((sum, vout) => sum + (vout.value ?? 0), 0);
     const minConf = opts?.minConfirmations ?? 0;
     let deepEnough;
     if (funding.status?.confirmed) {
@@ -108,6 +124,164 @@ var init_bitcoin_reader_esplora = __esm({
   }
 });
 
+// src/contracts/bitcoin-reader-electrum.ts
+var bitcoin_reader_electrum_exports = {};
+__export(bitcoin_reader_electrum_exports, {
+  electrumReader: () => electrumReader
+});
+function toBtcSignerNetwork(network) {
+  switch (network) {
+    case "mainnet":
+      return btc.NETWORK;
+    case "testnet":
+    case "signet":
+      return btc.TEST_NETWORK;
+    case "regtest":
+      return REGTEST_NETWORK;
+  }
+}
+function scriptHashOf(script) {
+  return import_base5.hex.encode((0, import_sha22.sha256)(script).reverse());
+}
+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)
+  );
+  async function getHtlcFactsElectrum(address, required) {
+    const script = scriptFor(address);
+    const scripthash = scriptHashOf(script);
+    const history = await client.request(
+      "blockchain.scripthash.get_history",
+      [scripthash]
+    );
+    if (!history || history.length === 0)
+      return { funding: "absent", fundedSats: 0 };
+    const txs = await Promise.all(
+      history.map(async (entry) => {
+        const raw = await client.request("blockchain.transaction.get", [
+          entry.tx_hash
+        ]);
+        return {
+          entry,
+          tx: btc.Transaction.fromRaw(import_base5.hex.decode(raw), {
+            allowUnknownOutputs: true,
+            allowUnknownInputs: true,
+            disableScriptCheck: true
+          })
+        };
+      })
+    );
+    const scriptHex = import_base5.hex.encode(script);
+    const outputIndicesPaying = (tx) => {
+      const indices = [];
+      for (let i = 0; i < tx.outputsLength; i++) {
+        const out = tx.getOutput(i);
+        if (out.script && import_base5.hex.encode(out.script) === scriptHex) indices.push(i);
+      }
+      return indices;
+    };
+    let funding;
+    let fundedSats = 0;
+    for (const candidate of txs) {
+      let paid = 0;
+      for (const i of outputIndicesPaying(candidate.tx))
+        paid += Number(candidate.tx.getOutput(i).amount ?? 0n);
+      if (paid > fundedSats) {
+        funding = candidate;
+        fundedSats = paid;
+      }
+    }
+    if (!funding) return { funding: "absent", fundedSats: 0 };
+    const fundedVouts = outputIndicesPaying(funding.tx);
+    for (const { tx } of txs) {
+      for (let i = 0; i < tx.inputsLength; i++) {
+        const input = tx.getInput(i);
+        if (input.txid && import_base5.hex.encode(input.txid) === funding.entry.tx_hash && input.index !== void 0 && fundedVouts.includes(input.index)) {
+          return {
+            funding: "confirmed",
+            fundedSats: 0,
+            // already spent — the amount no longer matters
+            spendWitness: (input.finalScriptWitness ?? []).map(
+              (item) => import_base5.hex.encode(item)
+            )
+          };
+        }
+      }
+    }
+    const height = funding.entry.height;
+    const isConfirmed = height > 0;
+    let deepEnough;
+    if (isConfirmed) {
+      if (required <= 1) {
+        deepEnough = true;
+      } else {
+        const tip = await client.request(
+          "blockchain.headers.subscribe",
+          []
+        );
+        deepEnough = tip.height - height + 1 >= required;
+      }
+    } else {
+      deepEnough = required === 0;
+    }
+    return { funding: deepEnough ? "confirmed" : "mempool", fundedSats };
+  }
+  return {
+    async getHtlcFacts(address, minConfirmations) {
+      const required = minConfirmations ?? defaultMinConf;
+      try {
+        return await getHtlcFactsElectrum(address, required);
+      } catch (error) {
+        if (!fallback2) throw error;
+        console.warn(
+          "electrumReader: falling back to secondary reader:",
+          error instanceof Error ? error.message : error
+        );
+        return fallback2.getHtlcFacts(address, minConfirmations);
+      }
+    },
+    subscribe(address, onChange) {
+      let scripthash;
+      try {
+        scripthash = scriptHashOf(scriptFor(address));
+      } catch (error) {
+        console.warn(
+          "electrumReader: subscribe skipped (address decode failed):",
+          error instanceof Error ? error.message : error
+        );
+        return () => {
+        };
+      }
+      const handler = () => onChange();
+      client.subscribeScriptHash(scripthash, handler).catch((error) => {
+        console.warn(
+          "electrumReader: scripthash subscribe failed:",
+          error instanceof Error ? error.message : error
+        );
+      });
+      return () => client.unsubscribeScriptHash(scripthash, handler);
+    }
+  };
+}
+var import_sha22, import_base5, btc, REGTEST_NETWORK;
+var init_bitcoin_reader_electrum = __esm({
+  "src/contracts/bitcoin-reader-electrum.ts"() {
+    "use strict";
+    import_sha22 = require("@noble/hashes/sha2.js");
+    import_base5 = require("@scure/base");
+    btc = __toESM(require("@scure/btc-signer"), 1);
+    REGTEST_NETWORK = {
+      bech32: "bcrt",
+      pubKeyHash: 111,
+      scriptHash: 196,
+      wif: 239
+    };
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -127,6 +301,7 @@ __export(src_exports, {
   defaultEvmReaders: () => defaultEvmReaders,
   deriveSwapActions: () => deriveSwapActions,
   deriveSwapStatus: () => deriveSwapStatus,
+  electrumReader: () => electrumReader,
   esploraReader: () => esploraReader,
   evmReaderFromClient: () => evmReaderFromClient,
   htlcFactsFromEsploraTxs: () => htlcFactsFromEsploraTxs,
@@ -468,10 +643,12 @@ function arkadeObservation(facts) {
 }
 function classifyArkadeSpend(encodedSpendTx, paymentHash) {
   const tx = import_sdk.Transaction.fromPSBT(import_base2.base64.decode(encodedSpendTx));
-  for (const witness of (0, import_sdk.getArkPsbtFields)(tx, 0, import_sdk.ConditionWitness)) {
-    for (const element of witness) {
-      if (element.length === 32 && preimageMatches(element, paymentHash)) {
-        return { spend: "claim", preimage: element };
+  for (let inputIndex = 0; inputIndex < tx.inputsLength; inputIndex++) {
+    for (const witness of (0, import_sdk.getArkPsbtFields)(tx, inputIndex, import_sdk.ConditionWitness)) {
+      for (const element of witness) {
+        if (element.length === 32 && preimageMatches(element, paymentHash)) {
+          return { spend: "claim", preimage: element };
+        }
       }
     }
   }
@@ -640,7 +817,7 @@ function defaultArkadeServerUrl(network) {
 }
 
 // src/contracts/bitcoin-manager.ts
-var import_base5 = require("@scure/base");
+var import_base6 = require("@scure/base");
 
 // src/contracts/bitcoin.ts
 var import_base4 = require("@scure/base");
@@ -675,6 +852,8 @@ var BitcoinContractManager = class _BitcoinContractManager {
   #obs = /* @__PURE__ */ new Map();
   /** address → the preimage a claim revealed. */
   #preimages = /* @__PURE__ */ new Map();
+  /** address → push-subscription teardown (only when the reader supports push). */
+  #subscriptions = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Set();
   /** Last MTP reading (ms) + when it was fetched, for extrapolation. */
   #now;
@@ -687,10 +866,24 @@ var BitcoinContractManager = class _BitcoinContractManager {
   }
   static async create(config) {
     const { esploraReader: esploraReader2 } = await Promise.resolve().then(() => (init_bitcoin_reader_esplora(), bitcoin_reader_esplora_exports));
+    let reader = esploraReader2(
+      config.esploraUrl,
+      void 0,
+      { minConfirmations: config.minConfirmations }
+    );
+    if (config.electrumWsUrl) {
+      const [{ electrumReader: electrumReader2 }, { ElectrumWsClient }] = await Promise.all([
+        Promise.resolve().then(() => (init_bitcoin_reader_electrum(), bitcoin_reader_electrum_exports)),
+        import("@lendasat/lendaswap-sdk-pure")
+      ]);
+      reader = electrumReader2(new ElectrumWsClient(config.electrumWsUrl), {
+        network: config.network,
+        minConfirmations: config.minConfirmations,
+        fallback: reader
+      });
+    }
     return _BitcoinContractManager.fromDeps({
-      reader: esploraReader2(config.esploraUrl, void 0, {
-        minConfirmations: config.minConfirmations
-      }),
+      reader,
       chainTime: config.chainTime
     });
   }
@@ -703,10 +896,25 @@ var BitcoinContractManager = class _BitcoinContractManager {
         `BitcoinContractManager can't track a '${ref.ledger}' HTLC`
       );
     this.#refs.set(ref.address, ref);
+    if (this.#reader.subscribe && !this.#subscriptions.has(ref.address)) {
+      this.#subscriptions.set(
+        ref.address,
+        this.#reader.subscribe(ref.address, () => {
+          this.#reconcileRef(ref).catch((error) => {
+            console.warn(
+              "BitcoinContractManager: push reconcile failed:",
+              error instanceof Error ? error.message : error
+            );
+          });
+        })
+      );
+    }
     await this.#reconcileRef(ref);
   }
   async unregister(ref) {
     if (ref.ledger !== "bitcoin") return;
+    this.#subscriptions.get(ref.address)?.();
+    this.#subscriptions.delete(ref.address);
     this.#refs.delete(ref.address);
     this.#obs.delete(ref.address);
     this.#preimages.delete(ref.address);
@@ -741,6 +949,8 @@ var BitcoinContractManager = class _BitcoinContractManager {
     this.#now = { mtpMs: await this.#chainTime(), fetchedAtMs: Date.now() };
   }
   dispose() {
+    for (const unsubscribe of this.#subscriptions.values()) unsubscribe();
+    this.#subscriptions.clear();
     this.#listeners.clear();
   }
   /** The preimage a claim revealed on this HTLC, if one was seen. */
@@ -754,7 +964,7 @@ var BitcoinContractManager = class _BitcoinContractManager {
     );
     const { observation, preimage } = bitcoinObservation(
       facts,
-      import_base5.hex.decode(ref.preimageHash),
+      import_base6.hex.decode(ref.preimageHash),
       ref.expectedSats
     );
     if (preimage) this.#preimages.set(ref.address, preimage);
@@ -1639,19 +1849,19 @@ function defaultWebSocketFactory(url) {
 var import_sdk3 = require("@arkade-os/sdk");
 var import_lendaswap_sdk_pure = require("@lendasat/lendaswap-sdk-pure");
 var import_legacy2 = require("@noble/hashes/legacy.js");
-var import_base6 = require("@scure/base");
+var import_base7 = require("@scure/base");
 function strip0x(value) {
   return value.startsWith("0x") ? value.slice(2) : value;
 }
 function xOnly(pubKeyHex) {
-  const bytes = import_base6.hex.decode(strip0x(pubKeyHex));
+  const bytes = import_base7.hex.decode(strip0x(pubKeyHex));
   if (bytes.length === 33) return bytes.slice(1);
   if (bytes.length === 32) return bytes;
   throw new Error(`invalid public key length: ${bytes.length}`);
 }
 var seconds = (value) => ({ type: "seconds", value: BigInt(value) });
 function buildArkadeVhtlcRef(input) {
-  const hashLockBytes = import_base6.hex.decode(strip0x(input.hashLock));
+  const hashLockBytes = import_base7.hex.decode(strip0x(input.hashLock));
   const params = {
     sender: xOnly(input.senderPk),
     receiver: xOnly(input.receiverPk),
@@ -1664,21 +1874,15 @@ function buildArkadeVhtlcRef(input) {
       input.unilateralRefundWithoutReceiverDelay
     )
   };
-  const vhtlc = (() => {
-    switch (input.arkadeHtlcScriptVersion ?? import_lendaswap_sdk_pure.ARKADE_HTLC_SCRIPT_VERSION_LEGACY) {
-      case import_lendaswap_sdk_pure.ARKADE_HTLC_SCRIPT_VERSION_LEGACY:
-        return new import_sdk3.VHTLC.Script(params);
-      case import_lendaswap_sdk_pure.ARKADE_HTLC_SCRIPT_VERSION_STRICT:
-        return new import_lendaswap_sdk_pure.StrictVhtlcScript(params);
-      default:
-        throw new Error(
-          `Unsupported Arkade HTLC script version: ${input.arkadeHtlcScriptVersion}`
-        );
-    }
-  })();
+  if (input.arkadeHtlcScriptVersion !== void 0 && input.arkadeHtlcScriptVersion !== import_lendaswap_sdk_pure.ARKADE_HTLC_SCRIPT_VERSION_STRICT) {
+    throw new Error(
+      `Unsupported Arkade HTLC script version: ${input.arkadeHtlcScriptVersion}`
+    );
+  }
+  const vhtlc = new import_lendaswap_sdk_pure.StrictVhtlcScript(params);
   return {
     ledger: "arkade",
-    script: import_base6.hex.encode(vhtlc.pkScript),
+    script: import_base7.hex.encode(vhtlc.pkScript),
     address: input.address,
     preimageHash: strip0x(input.hashLock),
     expectedSats: input.expectedSats,
@@ -1872,47 +2076,6 @@ function swapToTracked(stored) {
         serverRefundLocktime: ms(r.vhtlc_refund_locktime)
       };
     // ─── Lightning: one on-chain leg, one off-chain LN payment ───────────────
-    // Receive-on-Lightning: the client funds an on-chain HTLC and is paid over
-    // Lightning. No server leg to watch — the server sweeping the client's leg
-    // (with the preimage it got by paying the invoice) is the done signal.
-    // Client funds the Arkade VHTLC; Boltz pays the invoice. The deposit is
-    // `boltz_amount_sats` (source minus fees) — the amount actually locked, not
-    // `source_amount` — else the client's own funding reads as under-funded.
-    case "arkade_to_lightning":
-      return {
-        swapId: r.id,
-        clientHtlc: arkadeLeg(
-          r,
-          r.arkade_vhtlc_address,
-          Number(r.boltz_amount_sats)
-        ),
-        clientRefundLocktime: ms(r.vhtlc_refund_locktime),
-        serverRefundLocktime: 0
-        // no on-chain server leg
-      };
-    // Client funds the EVM HTLC (server claims it after paying the invoice).
-    case "evm_to_lightning":
-      return {
-        swapId: r.id,
-        clientHtlc: evmLeg({
-          chainId: r.evm_chain_id,
-          htlc: r.evm_htlc_address,
-          hashLock: r.hash_lock,
-          claimAddress: r.server_evm_address,
-          // the server claims the client's leg
-          expectedSats: r.evm_expected_sats,
-          // evm_to_lightning 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
-          timelockSec: r.evm_refund_locktime,
-          createdAt: r.created_at
-        }),
-        clientRefundLocktime: ms(r.evm_refund_locktime),
-        serverRefundLocktime: 0
-        // no on-chain server leg
-      };
     // Pay-on-Lightning: the client pays a Lightning invoice (off-chain, nothing to
     // watch) and claims an on-chain HTLC. No client-funded leg — the client's
     // claim completes the swap; a hold invoice that never settles auto-unwinds.
@@ -1929,26 +2092,20 @@ function swapToTracked(stored) {
         // no on-chain client leg
         serverRefundLocktime: ms(r.vhtlc_refund_locktime)
       };
-    // Client pays the invoice, then claims the EVM HTLC.
-    case "lightning_to_evm":
+    // Client funds the Arkade VHTLC (source_amount); the server pays the
+    // Lightning invoice off-chain and claims the VHTLC — no server leg to
+    // watch.
+    case "arkade_to_lightning":
       return {
         swapId: r.id,
-        serverHtlc: evmLeg({
-          chainId: r.evm_chain_id,
-          htlc: r.evm_htlc_address,
-          hashLock: r.hash_lock,
-          claimAddress: r.client_evm_address,
-          // the client claims the server's leg
-          expectedSats: r.evm_expected_sats,
-          token: r.wbtc_address,
-          sender: r.server_evm_address,
-          // the server funded it
-          timelockSec: r.evm_refund_locktime,
-          createdAt: r.created_at
-        }),
-        clientRefundLocktime: 0,
-        // no on-chain client leg
-        serverRefundLocktime: ms(r.evm_refund_locktime)
+        clientHtlc: arkadeLeg(
+          r,
+          r.arkade_vhtlc_address,
+          Number(r.source_amount)
+        ),
+        clientRefundLocktime: ms(r.vhtlc_refund_locktime),
+        serverRefundLocktime: 0
+        // no on-chain server leg
       };
     default:
       return void 0;
@@ -2460,12 +2617,6 @@ var Client = class {
     );
   }
   /** Delegated to the legacy client (migration checkpoint). */
-  createLightningToEvmSwapGeneric(...args) {
-    return this.#trackAfterCreate(
-      this.#legacy.createLightningToEvmSwapGeneric(...args)
-    );
-  }
-  /** Delegated to the legacy client (migration checkpoint). */
   createBitcoinToEvmSwap(...args) {
     return this.#trackAfterCreate(this.#legacy.createBitcoinToEvmSwap(...args));
   }
@@ -2488,16 +2639,6 @@ var Client = class {
     );
   }
   /** Delegated to the legacy client (migration checkpoint). */
-  getArkadeToLightningQuote(...args) {
-    return this.#legacy.getArkadeToLightningQuote(...args);
-  }
-  /** Delegated to the legacy client (migration checkpoint). */
-  retryArkadeToLightningSwap(...args) {
-    return this.#trackAfterRetry(
-      this.#legacy.retryArkadeToLightningSwap(...args)
-    );
-  }
-  /** Delegated to the legacy client (migration checkpoint). */
   createEvmToArkadeSwapGeneric(...args) {
     return this.#trackAfterCreate(
       this.#legacy.createEvmToArkadeSwapGeneric(...args)
@@ -2508,12 +2649,6 @@ var Client = class {
     return this.#trackAfterCreate(this.#legacy.createEvmToBitcoinSwap(...args));
   }
   /** Delegated to the legacy client (migration checkpoint). */
-  createEvmToLightningSwapGeneric(...args) {
-    return this.#trackAfterCreate(
-      this.#legacy.createEvmToLightningSwapGeneric(...args)
-    );
-  }
-  /** Delegated to the legacy client (migration checkpoint). */
   getCoordinatorFundingCallDataPermit2(...args) {
     return this.#legacy.getCoordinatorFundingCallDataPermit2(...args);
   }
@@ -2633,7 +2768,17 @@ var Client = class {
   /** Every stored swap whose ledgers are observable, mapped to a {@link TrackedSwap}. */
   async #loadTrackedSwaps() {
     const swaps = await this.listAllSwaps();
-    return swaps.filter((s) => !SETTLED_STORED_STATUSES.has(s.response.status)).map(swapToTracked).filter((s) => s !== void 0);
+    return swaps.filter((s) => !SETTLED_STORED_STATUSES.has(s.response.status)).map((s) => {
+      try {
+        return swapToTracked(s);
+      } catch (error) {
+        console.warn(
+          `Client: skipping untrackable stored swap ${s.response.id}:`,
+          error
+        );
+        return void 0;
+      }
+    }).filter((s) => s !== void 0);
   }
   /**
    * Run a create, then fold the new swap into tracking.
@@ -2753,7 +2898,14 @@ var Client = class {
       return this.#managers;
     }
     const managers = /* @__PURE__ */ new Map();
-    const { arkadeServerUrl, evmRpcUrls, esploraUrl, bitcoinMinConfirmations } = this.#tracking;
+    const {
+      arkadeServerUrl,
+      evmRpcUrls,
+      esploraUrl,
+      electrumWsUrl,
+      bitcoinNetwork,
+      bitcoinMinConfirmations
+    } = this.#tracking;
     const chainTime = async () => (await this.getMtp()).mtp * 1e3;
     const arkadeUrl = arkadeServerUrl ?? defaultArkadeServerUrl("bitcoin");
     if (arkadeUrl) {
@@ -2765,10 +2917,13 @@ var Client = class {
     const readers = defaultEvmReaders(evmRpcUrls);
     if (readers.size > 0)
       managers.set("evm", EvmContractManager.fromDeps({ readers }));
+    const network = bitcoinNetwork ?? "mainnet";
     managers.set(
       "bitcoin",
       await BitcoinContractManager.create({
         esploraUrl: esploraUrl ? [esploraUrl] : DEFAULT_ESPLORA_URLS,
+        electrumWsUrl: electrumWsUrl ?? import_lendaswap_sdk_pure2.DEFAULT_ELECTRUM_WS_URLS[network],
+        network,
         chainTime,
         minConfirmations: bitcoinMinConfirmations
       })
@@ -2785,6 +2940,8 @@ var ClientBuilder = class {
   #serverUrl;
   #arkadeServerUrl;
   #esploraUrl;
+  #electrumWsUrl;
+  #bitcoinNetwork;
   #bitcoinMinConfirmations;
   #evmRpcUrls;
   #managers;
@@ -2850,6 +3007,28 @@ var ClientBuilder = class {
     this.#esploraUrl = url;
     return this;
   }
+  /**
+   * Set an Electrum server WebSocket URL (a Fulcrum `ws`/`wss` port) for
+   * Bitcoin claim/refund chain access. When set, the underlying client
+   * prefers it over Esplora for lookups and broadcasts, and waits for HTLC
+   * fundings via `blockchain.scripthash.subscribe` push instead of polling.
+   * Esplora remains the fallback whenever the Electrum server errors.
+   */
+  withElectrumWsUrl(url) {
+    this.#inner.withElectrumWsUrl(url);
+    this.#electrumWsUrl = url;
+    return this;
+  }
+  /**
+   * Declare the Bitcoin network of this deployment's HTLC addresses. Only
+   * needed together with {@link withElectrumWsUrl} on a non-mainnet
+   * deployment — the Electrum reader decodes addresses to scripthashes and
+   * defaults to mainnet parameters.
+   */
+  withBitcoinNetwork(network) {
+    this.#bitcoinNetwork = network;
+    return this;
+  }
   /**
    * Confirmations a Bitcoin funding tx needs before it observes as `confirmed`
    * (gating e.g. the evm→bitcoin claim). Default `0`: claim as soon as the
@@ -2906,6 +3085,8 @@ var ClientBuilder = class {
       managers: this.#managers,
       arkadeServerUrl: this.#arkadeServerUrl,
       esploraUrl: this.#esploraUrl,
+      electrumWsUrl: this.#electrumWsUrl,
+      bitcoinNetwork: this.#bitcoinNetwork,
       bitcoinMinConfirmations: this.#bitcoinMinConfirmations,
       evmRpcUrls: this.#evmRpcUrls,
       autoClaim: this.#autoClaim
@@ -2926,6 +3107,7 @@ function createdSwapId(result) {
 }
 
 // src/index.ts
+init_bitcoin_reader_electrum();
 init_bitcoin_reader_esplora();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2945,6 +3127,7 @@ init_bitcoin_reader_esplora();
   defaultEvmReaders,
   deriveSwapActions,
   deriveSwapStatus,
+  electrumReader,
   esploraReader,
   evmReaderFromClient,
   htlcFactsFromEsploraTxs,