@satora/swap 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -292,6 +292,7 @@ __export(src_exports, {
   DEFAULT_ESPLORA_URLS: () => DEFAULT_ESPLORA_URLS,
   DEFAULT_EVM_RPCS: () => DEFAULT_EVM_RPCS,
   EvmContractManager: () => EvmContractManager,
+  HintTracker: () => HintTracker,
   SwapTracker: () => SwapTracker,
   SwapWorker: () => SwapWorker,
   WsStatusSource: () => WsStatusSource,
@@ -1504,6 +1505,113 @@ function defaultEvmReaders(overrides) {
   return readers;
 }
 
+// src/hints/hint-tracker.ts
+var HintTracker = class {
+  #fetchStatus;
+  #refreshIntervalMs;
+  #swaps = /* @__PURE__ */ new Map();
+  /** Last server-reported status per swap (seeded from storage, updated by hints). */
+  #statuses = /* @__PURE__ */ new Map();
+  /** Last actions emitted per swap — for dedupe and the subscribe-time snapshot. */
+  #lastActions = /* @__PURE__ */ new Map();
+  #subscribers = /* @__PURE__ */ new Set();
+  #timer;
+  constructor(options) {
+    this.#fetchStatus = options.fetchStatus;
+    this.#refreshIntervalMs = options.refreshIntervalMs ?? 5e3;
+  }
+  /**
+   * Always `true`: with no chain readers there is no reachability constraint.
+   * (Claim/refund execution has its own chain configuration, independent of
+   * tracking.)
+   */
+  canObserve(_swap) {
+    return true;
+  }
+  /** Register the swaps, derive each one's first action from its stored status. */
+  async startTracking(swaps) {
+    for (const swap of swaps) this.#admit(swap);
+    this.#recomputeAll();
+    if (this.#refreshIntervalMs > 0)
+      this.#timer = setInterval(
+        () => this.#recomputeAll(),
+        this.#refreshIntervalMs
+      );
+  }
+  /**
+   * Track one more swap after {@link startTracking}. Idempotent: a swap already
+   * tracked, or one already seen through to a terminal action, is ignored.
+   */
+  async track(swap) {
+    if (this.#swaps.has(swap.swapId) || this.#lastActions.has(swap.swapId))
+      return;
+    this.#admit(swap);
+    this.#recompute(swap);
+  }
+  #admit(swap) {
+    this.#swaps.set(swap.swapId, swap);
+    if (swap.storedStatus !== void 0 && !this.#statuses.has(swap.swapId))
+      this.#statuses.set(swap.swapId, swap.storedStatus);
+  }
+  /** The swap ids currently tracked — e.g. to subscribe them to the hint feed. */
+  trackedSwapIds() {
+    return [...this.#swaps.keys()];
+  }
+  /**
+   * Apply a server status to one swap and recompute its action. A hint that
+   * carries the pushed `status` is applied as-is; without one (the worker's
+   * retry and post-reconnect paths) the status is re-fetched from the server.
+   * A no-op for an untracked swap.
+   */
+  async applyHint(swapId, opts) {
+    const swap = this.#swaps.get(swapId);
+    if (!swap) return;
+    const status = opts?.status ?? await this.#fetchStatus(swapId);
+    if (!this.#swaps.has(swapId)) return;
+    this.#statuses.set(swapId, status);
+    this.#recompute(swap, opts?.force ?? false);
+  }
+  /** Notify `cb` of the current action for each tracked swap, then on every change. */
+  subscribeToActions(cb) {
+    this.#subscribers.add(cb);
+    for (const [swapId, actions] of this.#lastActions) cb(swapId, actions);
+    return () => this.#subscribers.delete(cb);
+  }
+  /** Stop tracking: drop the tick timer, tracked swaps, and subscribers. */
+  stop() {
+    if (this.#timer) clearInterval(this.#timer);
+    this.#timer = void 0;
+    this.#swaps.clear();
+    this.#subscribers.clear();
+  }
+  #recomputeAll() {
+    for (const swap of this.#swaps.values()) this.#recompute(swap);
+  }
+  #recompute(swap, force = false) {
+    const status = this.#statuses.get(swap.swapId);
+    if (status === void 0) return;
+    const now = Date.now();
+    const actions = deriveSwapActions({
+      status,
+      clientChainNow: now,
+      serverChainNow: now,
+      clientRefundLocktime: swap.clientRefundLocktime,
+      serverRefundLocktime: swap.serverRefundLocktime,
+      // Pay-on-Lightning swaps have no client-funded on-chain leg.
+      clientFunds: swap.clientHtlc !== void 0
+    });
+    const previous = this.#lastActions.get(swap.swapId);
+    if (!force && previous && JSON.stringify(previous) === JSON.stringify(actions))
+      return;
+    this.#lastActions.set(swap.swapId, actions);
+    for (const cb of this.#subscribers) cb(swap.swapId, actions);
+    if (actions.recommended === "none") {
+      this.#swaps.delete(swap.swapId);
+      this.#statuses.delete(swap.swapId);
+    }
+  }
+};
+
 // src/hints/swap-worker.ts
 var AUTO_EXECUTABLE = /* @__PURE__ */ new Set([
   "claim"
@@ -1537,8 +1645,8 @@ var SwapWorker = class {
     this.#started = true;
     this.#hintSource.subscribe(this.#tracker.trackedSwapIds());
     this.#unsubs.push(
-      this.#hintSource.onStatus(({ swapId }) => {
-        void this.#tracker.applyHint(swapId).catch((error) => {
+      this.#hintSource.onStatus(({ swapId, status }) => {
+        void this.#tracker.applyHint(swapId, { status }).catch((error) => {
           console.warn(`SwapWorker: applyHint(${swapId}) failed:`, error);
         });
       })
@@ -2700,8 +2808,11 @@ var Client = class {
   /**
    * Start observing the user's active swaps and deriving each one's next action.
    *
-   * Loads stored swaps, maps the ones whose ledgers are observable to
-   * {@link TrackedSwap}s, and runs the per-ledger monitors. Idempotent. Requires
+   * Loads stored swaps, maps them to {@link TrackedSwap}s, and derives each
+   * one's actions — by default from the server's status hints alone (TEMP while
+   * the chain monitors are buggy; see
+   * {@link ClientBuilder.withChainVerifiedTracking} to re-enable the per-ledger
+   * chain monitors). Idempotent. Requires
    * the client to have been built with {@link ClientBuilder.withTracking}.
    * Subscribe with {@link subscribeToActions}; release with
    * {@link stopTracking}.
@@ -2721,7 +2832,11 @@ var Client = class {
   }
   async #doStartTracking() {
     try {
-      const tracker = new SwapTracker(await this.#ensureManagers(), {
+      const chainVerified = this.#tracking.chainVerified || this.#tracking.managers !== void 0;
+      const tracker = chainVerified ? new SwapTracker(await this.#ensureManagers(), {
+        refreshIntervalMs: this.#tracking.refreshIntervalMs ?? 5e3
+      }) : new HintTracker({
+        fetchStatus: async (swapId) => (await this.getSwap(swapId, { updateStorage: true })).status,
         refreshIntervalMs: this.#tracking.refreshIntervalMs ?? 5e3
       });
       this.#tracker = tracker;
@@ -2770,7 +2885,9 @@ var Client = class {
     const swaps = await this.listAllSwaps();
     return swaps.filter((s) => !SETTLED_STORED_STATUSES.has(s.response.status)).map((s) => {
       try {
-        return swapToTracked(s);
+        const tracked = swapToTracked(s);
+        if (!tracked) return void 0;
+        return { ...tracked, storedStatus: s.response.status };
       } catch (error) {
         console.warn(
           `Client: skipping untrackable stored swap ${s.response.id}:`,
@@ -2848,7 +2965,7 @@ var Client = class {
    * otherwise it runs observe-only, hints in, no spends.
    */
   #startWorker(tracker) {
-    const serverUrl = this.#tracking.serverUrl;
+    const serverUrl = this.#tracking.serverUrl ?? legacyBaseUrl(this.#legacy);
     if (!serverUrl) return;
     const autoClaim = this.#tracking.autoClaim;
     const hintSource = new WsStatusSource({ serverUrl });
@@ -2946,6 +3063,7 @@ var ClientBuilder = class {
   #evmRpcUrls;
   #managers;
   #autoClaim;
+  #chainVerified = false;
   /**
    * Override the EVM JSON-RPC endpoint per chainId. Optional — tracking uses
    * tested public defaults otherwise; an override is tried first, with the
@@ -2972,6 +3090,16 @@ var ClientBuilder = class {
     this.#trackingEnabled = false;
     return this;
   }
+  /**
+   * Verify swap state against the chain (per-ledger contract managers) instead
+   * of trusting the server's status hints. TEMPORARILY off by default while the
+   * chain monitors are being fixed — without it, tracking derives actions from
+   * the server's pushed status alone, with zero chain access.
+   */
+  withChainVerifiedTracking() {
+    this.#chainVerified = true;
+    return this;
+  }
   /**
    * Advanced: supply per-ledger {@link ContractManager}s explicitly instead of
    * letting the client auto-build them from config (useful for tests or custom
@@ -3089,10 +3217,18 @@ var ClientBuilder = class {
       bitcoinNetwork: this.#bitcoinNetwork,
       bitcoinMinConfirmations: this.#bitcoinMinConfirmations,
       evmRpcUrls: this.#evmRpcUrls,
-      autoClaim: this.#autoClaim
+      autoClaim: this.#autoClaim,
+      chainVerified: this.#chainVerified
     });
   }
 };
+function legacyBaseUrl(legacy) {
+  try {
+    return legacy.baseUrl;
+  } catch {
+    return void 0;
+  }
+}
 var SETTLED_STORED_STATUSES = /* @__PURE__ */ new Set([
   "serverredeemed",
   "clientrefunded",
@@ -3118,6 +3254,7 @@ init_bitcoin_reader_esplora();
   DEFAULT_ESPLORA_URLS,
   DEFAULT_EVM_RPCS,
   EvmContractManager,
+  HintTracker,
   SwapTracker,
   SwapWorker,
   WsStatusSource,