@satora/swap 0.3.1 → 1.0.0

package/dist/index.js

@@ -3,6 +3,9 @@ import {
   esploraReader,
   htlcFactsFromEsploraTxs
 } from "./chunk-EIWELJJK.js";
+import {
+  electrumReader
+} from "./chunk-VHXEU534.js";
 
 // src/index.ts
 export * from "@lendasat/lendaswap-sdk-pure";
@@ -311,6 +314,7 @@ function payOnLightningStatus(serverHtlc) {
 
 // src/client.ts
 import {
+  DEFAULT_ELECTRUM_WS_URLS,
   Client as LegacyClient
 } from "@lendasat/lendaswap-sdk-pure";
 
@@ -344,10 +348,12 @@ function arkadeObservation(facts) {
 }
 function classifyArkadeSpend(encodedSpendTx, paymentHash) {
   const tx = Transaction.fromPSBT(base64.decode(encodedSpendTx));
-  for (const witness of getArkPsbtFields(tx, 0, 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 getArkPsbtFields(tx, inputIndex, ConditionWitness)) {
+      for (const element of witness) {
+        if (element.length === 32 && preimageMatches(element, paymentHash)) {
+          return { spend: "claim", preimage: element };
+        }
       }
     }
   }
@@ -551,6 +557,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;
@@ -563,10 +571,24 @@ var BitcoinContractManager = class _BitcoinContractManager {
   }
   static async create(config) {
     const { esploraReader: esploraReader2 } = await import("./bitcoin-reader-esplora-HV6CANAA.js");
+    let reader = esploraReader2(
+      config.esploraUrl,
+      void 0,
+      { minConfirmations: config.minConfirmations }
+    );
+    if (config.electrumWsUrl) {
+      const [{ electrumReader: electrumReader2 }, { ElectrumWsClient }] = await Promise.all([
+        import("./bitcoin-reader-electrum-4DOJ7NGH.js"),
+        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
     });
   }
@@ -579,10 +601,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);
@@ -617,6 +654,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. */
@@ -1519,9 +1558,8 @@ function defaultWebSocketFactory(url) {
 }
 
 // src/contracts/arkade-vhtlc.ts
-import { VHTLC, VHTLCContractHandler } from "@arkade-os/sdk";
+import { VHTLCContractHandler } from "@arkade-os/sdk";
 import {
-  ARKADE_HTLC_SCRIPT_VERSION_LEGACY,
   ARKADE_HTLC_SCRIPT_VERSION_STRICT,
   StrictVhtlcScript
 } from "@lendasat/lendaswap-sdk-pure";
@@ -1551,18 +1589,12 @@ function buildArkadeVhtlcRef(input) {
       input.unilateralRefundWithoutReceiverDelay
     )
   };
-  const vhtlc = (() => {
-    switch (input.arkadeHtlcScriptVersion ?? ARKADE_HTLC_SCRIPT_VERSION_LEGACY) {
-      case ARKADE_HTLC_SCRIPT_VERSION_LEGACY:
-        return new VHTLC.Script(params);
-      case ARKADE_HTLC_SCRIPT_VERSION_STRICT:
-        return new StrictVhtlcScript(params);
-      default:
-        throw new Error(
-          `Unsupported Arkade HTLC script version: ${input.arkadeHtlcScriptVersion}`
-        );
-    }
-  })();
+  if (input.arkadeHtlcScriptVersion !== void 0 && input.arkadeHtlcScriptVersion !== ARKADE_HTLC_SCRIPT_VERSION_STRICT) {
+    throw new Error(
+      `Unsupported Arkade HTLC script version: ${input.arkadeHtlcScriptVersion}`
+    );
+  }
+  const vhtlc = new StrictVhtlcScript(params);
   return {
     ledger: "arkade",
     script: hex5.encode(vhtlc.pkScript),
@@ -1759,47 +1791,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.
@@ -1816,27 +1807,6 @@ 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":
-      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)
-      };
     default:
       return void 0;
   }
@@ -2347,12 +2317,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));
   }
@@ -2369,22 +2333,6 @@ var Client = class {
     );
   }
   /** Delegated to the legacy client (migration checkpoint). */
-  createArkadeToLightningSwap(...args) {
-    return this.#trackAfterCreate(
-      this.#legacy.createArkadeToLightningSwap(...args)
-    );
-  }
-  /** 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)
@@ -2395,12 +2343,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);
   }
@@ -2520,7 +2462,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.
@@ -2640,7 +2592,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) {
@@ -2652,10 +2611,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 ?? DEFAULT_ELECTRUM_WS_URLS[network],
+        network,
         chainTime,
         minConfirmations: bitcoinMinConfirmations
       })
@@ -2672,6 +2634,8 @@ var ClientBuilder = class {
   #serverUrl;
   #arkadeServerUrl;
   #esploraUrl;
+  #electrumWsUrl;
+  #bitcoinNetwork;
   #bitcoinMinConfirmations;
   #evmRpcUrls;
   #managers;
@@ -2737,6 +2701,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
@@ -2793,6 +2779,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
@@ -2828,6 +2816,7 @@ export {
   defaultEvmReaders,
   deriveSwapActions,
   deriveSwapStatus,
+  electrumReader,
   esploraReader,
   evmReaderFromClient,
   htlcFactsFromEsploraTxs,