@satora/swap 1.7.1 → 1.8.0

package/dist/index.d.cts

@@ -396,6 +396,81 @@ interface ContractManager {
     dispose(): void;
 }
 
+/**
+ * A standalone subscriber to the server's swap-status WebSocket (`GET /ws`).
+ *
+ * Holds a single reconnecting connection, tracks a live set of subscribed swap
+ * ids, and emits `{ swapId, status }` on every status transition the server
+ * pushes — including the snapshot the server sends right after a subscribe. This
+ * is a *hint* feed only: it neither trusts nor acts on the status. A consumer is
+ * expected to verify against the chain (the contract managers) before doing
+ * anything with it.
+ *
+ * Protocol (see `swap/src/api/ws.rs`):
+ *   → {"op":"subscribe","channel":"swap_status","args":[<uuid>,...]}   (≤64 ids/frame)
+ *   ← {"channel":"swap_status","data":{"<uuid>":"<status>",...}}
+ *   ← {"op":"subscribed",...} (ack)     ← {"op":...,"message":...} (error)
+ * A single connection carries up to 256 subscriptions; that cap is enforced
+ * client-side (see {@link WsStatusSource.subscribe}) because the server silently
+ * drops the overflow.
+ */
+
+/** A status update pushed by the server for one swap. */
+type SwapStatusUpdate = {
+    swapId: string;
+    status: SwapStatus;
+};
+/** The minimal WebSocket surface the source needs (the global `WebSocket` satisfies it). */
+interface WebSocketLike {
+    send(data: string): void;
+    close(): void;
+    onopen: (() => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onclose: (() => void) | null;
+    onerror: ((event: unknown) => void) | null;
+}
+type WsStatusSourceOptions = {
+    /** Server base URL (http/https); the `ws(s)://…/ws` endpoint is derived from it. */
+    serverUrl: string;
+    /** WebSocket factory — defaults to the global `WebSocket` (browsers, Node ≥ 22). */
+    webSocketFactory?: (url: string) => WebSocketLike;
+    /** Reconnect backoff floor/ceiling (ms). Defaults: 1_000 / 30_000. */
+    reconnectMinMs?: number;
+    reconnectMaxMs?: number;
+};
+declare class WsStatusSource {
+    #private;
+    constructor(options: WsStatusSourceOptions);
+    /** Open the connection and begin (re)subscribing. Idempotent. */
+    start(): void;
+    /** Close the connection and stop reconnecting. */
+    stop(): void;
+    /** Emit for each pushed status update. Returns an unsubscribe fn. */
+    onStatus(cb: (update: SwapStatusUpdate) => void): () => void;
+    /**
+     * Emit whenever the socket comes (back) up after a disruption — a drop, or a
+     * first connect that had to be retried. NOT emitted on a pristine first open:
+     * hints were never live before it, so there is no gap to recover from. While
+     * the socket was down, pushed transitions were lost for good (the server only
+     * snapshots on subscribe), so a consumer should re-verify its world against
+     * the chain on this signal.
+     */
+    onReconnect(cb: () => void): () => void;
+    /**
+     * Track these swap ids — subscribe on the socket now if open, else on next open.
+     *
+     * Enforces the server's per-connection cap locally. The server silently stops
+     * adding once it is full (it breaks out of the loop but still acks every id),
+     * so sending more would leave us believing ids are subscribed that will never
+     * receive an update. Overflow is queued instead and promoted as slots free.
+     */
+    subscribe(swapIds: string[]): void;
+    /** Stop tracking these swap ids, promoting queued ones into the freed slots. */
+    unsubscribe(swapIds: string[]): void;
+}
+
 /**
  * The reactive orchestration.
  *
@@ -533,6 +608,8 @@ type TrackingConfig = {
      * remain the source of truth.
      */
     serverUrl?: string;
+    /** WebSocket factory for the hint feed; defaults to the global `WebSocket` (testing). */
+    webSocketFactory?: (url: string) => WebSocketLike;
     /** Explicit per-ledger managers, bypassing auto-construction (advanced/testing). */
     managers?: Map<Ledger, ContractManager>;
     /** Ark server URL override; defaults to the mainnet server when unset. */
@@ -675,6 +752,7 @@ declare class Client {
     /** Delegated to the legacy client (migration checkpoint). */
     claim(...args: Parameters<Client$1["claim"]>): ReturnType<Client$1["claim"]>;
     /** Delegated to the legacy client (migration checkpoint). */
+    canSponsorClaim(...args: Parameters<Client$1["canSponsorClaim"]>): boolean;
     claimEvmWithSigner(...args: Parameters<Client$1["claimEvmWithSigner"]>): ReturnType<Client$1["claimEvmWithSigner"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     claimViaGasless(...args: Parameters<Client$1["claimViaGasless"]>): ReturnType<Client$1["claimViaGasless"]>;
@@ -689,6 +767,16 @@ declare class Client {
     /** Delegated to the legacy client (migration checkpoint). */
     buildCollabRefundEvmTypedData(...args: Parameters<Client$1["buildCollabRefundEvmTypedData"]>): ReturnType<Client$1["buildCollabRefundEvmTypedData"]>;
     /** Delegated to the legacy client (migration checkpoint). */
+    getCollabRefundEvmSignature(...args: Parameters<Client$1["getCollabRefundEvmSignature"]>): ReturnType<Client$1["getCollabRefundEvmSignature"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
+    getRehashEvmParams(...args: Parameters<Client$1["getRehashEvmParams"]>): ReturnType<Client$1["getRehashEvmParams"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
+    signRehashEvm(...args: Parameters<Client$1["signRehashEvm"]>): ReturnType<Client$1["signRehashEvm"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
+    retrySwapWithInvoice(...args: Parameters<Client$1["retrySwapWithInvoice"]>): ReturnType<Client$1["retrySwapWithInvoice"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
+    retrySwapWithInvoiceWithSigner(...args: Parameters<Client$1["retrySwapWithInvoiceWithSigner"]>): ReturnType<Client$1["retrySwapWithInvoiceWithSigner"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
     collabRefundEvmSwap(...args: Parameters<Client$1["collabRefundEvmSwap"]>): ReturnType<Client$1["collabRefundEvmSwap"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     submitCollabRefundEvm(...args: Parameters<Client$1["submitCollabRefundEvm"]>): ReturnType<Client$1["submitCollabRefundEvm"]>;
@@ -718,7 +806,10 @@ declare class Client {
     getCoordinatorFundingCallDataPermit2(...args: Parameters<Client$1["getCoordinatorFundingCallDataPermit2"]>): ReturnType<Client$1["getCoordinatorFundingCallDataPermit2"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     getPermit2FundingParamsUnsigned(...args: Parameters<Client$1["getPermit2FundingParamsUnsigned"]>): ReturnType<Client$1["getPermit2FundingParamsUnsigned"]>;
-    /** Delegated to the legacy client (migration checkpoint). */
+    /**
+     * Fund the swap, then re-verify it against the chain so the lock shows up
+     * in the derived actions without waiting on a server hint.
+     */
     fundSwap(...args: Parameters<Client$1["fundSwap"]>): ReturnType<Client$1["fundSwap"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     fundSwapFromSolana(...args: Parameters<Client$1["fundSwapFromSolana"]>): ReturnType<Client$1["fundSwapFromSolana"]>;
@@ -733,6 +824,8 @@ declare class Client {
     /** Delegated to the legacy client (migration checkpoint). */
     fundSwapGasless(...args: Parameters<Client$1["fundSwapGasless"]>): ReturnType<Client$1["fundSwapGasless"]>;
     /** Delegated to the legacy client (migration checkpoint). */
+    getEvmFundingExpectation(...args: Parameters<Client$1["getEvmFundingExpectation"]>): ReturnType<Client$1["getEvmFundingExpectation"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
     getSwapDepositorKey(...args: Parameters<Client$1["getSwapDepositorKey"]>): ReturnType<Client$1["getSwapDepositorKey"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     getEvmDepositorKey(...args: Parameters<Client$1["getEvmDepositorKey"]>): ReturnType<Client$1["getEvmDepositorKey"]>;
@@ -1538,7 +1631,7 @@ type SwapWorkerOptions = {
      * Resolve once submitted. OMIT for observe-only mode: hints still trigger
      * chain re-verifies (fast, cheap derivations), but nothing is ever run.
      */
-    execute?: (swapId: string, actionId: SwapActionId) => Promise<void>;
+    execute?: (swapId: string, actionId: SwapActionId, actions: SwapActions) => Promise<void>;
     /**
      * Surface an action that needs the user rather than being auto-run — a manual
      * `fund`, a refund the user must confirm, or a claim whose retries are spent.
@@ -1553,83 +1646,16 @@ declare class SwapWorker {
     constructor(options: SwapWorkerOptions);
     /** Watch tracked swaps on the hint feed, wire hints → verify, react to actions. */
     start(): void;
-    /** Stop reacting, cancel pending retries, and close the hint feed. */
-    stop(): void;
-}
-
-/**
- * A standalone subscriber to the server's swap-status WebSocket (`GET /ws`).
- *
- * Holds a single reconnecting connection, tracks a live set of subscribed swap
- * ids, and emits `{ swapId, status }` on every status transition the server
- * pushes — including the snapshot the server sends right after a subscribe. This
- * is a *hint* feed only: it neither trusts nor acts on the status. A consumer is
- * expected to verify against the chain (the contract managers) before doing
- * anything with it.
- *
- * Protocol (see `swap/src/api/ws.rs`):
- *   → {"op":"subscribe","channel":"swap_status","args":[<uuid>,...]}   (≤64 ids/frame)
- *   ← {"channel":"swap_status","data":{"<uuid>":"<status>",...}}
- *   ← {"op":"subscribed",...} (ack)     ← {"op":...,"message":...} (error)
- * A single connection carries up to 256 subscriptions; that cap is enforced
- * client-side (see {@link WsStatusSource.subscribe}) because the server silently
- * drops the overflow.
- */
-
-/** A status update pushed by the server for one swap. */
-type SwapStatusUpdate = {
-    swapId: string;
-    status: SwapStatus;
-};
-/** The minimal WebSocket surface the source needs (the global `WebSocket` satisfies it). */
-interface WebSocketLike {
-    send(data: string): void;
-    close(): void;
-    onopen: (() => void) | null;
-    onmessage: ((event: {
-        data: unknown;
-    }) => void) | null;
-    onclose: (() => void) | null;
-    onerror: ((event: unknown) => void) | null;
-}
-type WsStatusSourceOptions = {
-    /** Server base URL (http/https); the `ws(s)://…/ws` endpoint is derived from it. */
-    serverUrl: string;
-    /** WebSocket factory — defaults to the global `WebSocket` (browsers, Node ≥ 22). */
-    webSocketFactory?: (url: string) => WebSocketLike;
-    /** Reconnect backoff floor/ceiling (ms). Defaults: 1_000 / 30_000. */
-    reconnectMinMs?: number;
-    reconnectMaxMs?: number;
-};
-declare class WsStatusSource {
-    #private;
-    constructor(options: WsStatusSourceOptions);
-    /** Open the connection and begin (re)subscribing. Idempotent. */
-    start(): void;
-    /** Close the connection and stop reconnecting. */
-    stop(): void;
-    /** Emit for each pushed status update. Returns an unsubscribe fn. */
-    onStatus(cb: (update: SwapStatusUpdate) => void): () => void;
-    /**
-     * Emit whenever the socket comes (back) up after a disruption — a drop, or a
-     * first connect that had to be retried. NOT emitted on a pristine first open:
-     * hints were never live before it, so there is no gap to recover from. While
-     * the socket was down, pushed transitions were lost for good (the server only
-     * snapshots on subscribe), so a consumer should re-verify its world against
-     * the chain on this signal.
-     */
-    onReconnect(cb: () => void): () => void;
     /**
-     * Track these swap ids — subscribe on the socket now if open, else on next open.
-     *
-     * Enforces the server's per-connection cap locally. The server silently stops
-     * adding once it is full (it breaks out of the loop but still acks every id),
-     * so sending more would leave us believing ids are subscribed that will never
-     * receive an update. Overflow is queued instead and promoted as slots free.
+     * Put swaps on the hint feed as soon as they are tracked. {@link #onActions}
+     * subscribes a swap when its first action is emitted, but a swap whose leg
+     * cannot be classified yet (an unfunded lock on a chain without `eth_getLogs`)
+     * emits nothing, and without this it would never receive the server hint
+     * that its funding landed.
      */
     subscribe(swapIds: string[]): void;
-    /** Stop tracking these swap ids, promoting queued ones into the freed slots. */
-    unsubscribe(swapIds: string[]): void;
+    /** Stop reacting, cancel pending retries, and close the hint feed. */
+    stop(): void;
 }
 
 /**

package/dist/index.d.ts

@@ -396,6 +396,81 @@ interface ContractManager {
     dispose(): void;
 }
 
+/**
+ * A standalone subscriber to the server's swap-status WebSocket (`GET /ws`).
+ *
+ * Holds a single reconnecting connection, tracks a live set of subscribed swap
+ * ids, and emits `{ swapId, status }` on every status transition the server
+ * pushes — including the snapshot the server sends right after a subscribe. This
+ * is a *hint* feed only: it neither trusts nor acts on the status. A consumer is
+ * expected to verify against the chain (the contract managers) before doing
+ * anything with it.
+ *
+ * Protocol (see `swap/src/api/ws.rs`):
+ *   → {"op":"subscribe","channel":"swap_status","args":[<uuid>,...]}   (≤64 ids/frame)
+ *   ← {"channel":"swap_status","data":{"<uuid>":"<status>",...}}
+ *   ← {"op":"subscribed",...} (ack)     ← {"op":...,"message":...} (error)
+ * A single connection carries up to 256 subscriptions; that cap is enforced
+ * client-side (see {@link WsStatusSource.subscribe}) because the server silently
+ * drops the overflow.
+ */
+
+/** A status update pushed by the server for one swap. */
+type SwapStatusUpdate = {
+    swapId: string;
+    status: SwapStatus;
+};
+/** The minimal WebSocket surface the source needs (the global `WebSocket` satisfies it). */
+interface WebSocketLike {
+    send(data: string): void;
+    close(): void;
+    onopen: (() => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onclose: (() => void) | null;
+    onerror: ((event: unknown) => void) | null;
+}
+type WsStatusSourceOptions = {
+    /** Server base URL (http/https); the `ws(s)://…/ws` endpoint is derived from it. */
+    serverUrl: string;
+    /** WebSocket factory — defaults to the global `WebSocket` (browsers, Node ≥ 22). */
+    webSocketFactory?: (url: string) => WebSocketLike;
+    /** Reconnect backoff floor/ceiling (ms). Defaults: 1_000 / 30_000. */
+    reconnectMinMs?: number;
+    reconnectMaxMs?: number;
+};
+declare class WsStatusSource {
+    #private;
+    constructor(options: WsStatusSourceOptions);
+    /** Open the connection and begin (re)subscribing. Idempotent. */
+    start(): void;
+    /** Close the connection and stop reconnecting. */
+    stop(): void;
+    /** Emit for each pushed status update. Returns an unsubscribe fn. */
+    onStatus(cb: (update: SwapStatusUpdate) => void): () => void;
+    /**
+     * Emit whenever the socket comes (back) up after a disruption — a drop, or a
+     * first connect that had to be retried. NOT emitted on a pristine first open:
+     * hints were never live before it, so there is no gap to recover from. While
+     * the socket was down, pushed transitions were lost for good (the server only
+     * snapshots on subscribe), so a consumer should re-verify its world against
+     * the chain on this signal.
+     */
+    onReconnect(cb: () => void): () => void;
+    /**
+     * Track these swap ids — subscribe on the socket now if open, else on next open.
+     *
+     * Enforces the server's per-connection cap locally. The server silently stops
+     * adding once it is full (it breaks out of the loop but still acks every id),
+     * so sending more would leave us believing ids are subscribed that will never
+     * receive an update. Overflow is queued instead and promoted as slots free.
+     */
+    subscribe(swapIds: string[]): void;
+    /** Stop tracking these swap ids, promoting queued ones into the freed slots. */
+    unsubscribe(swapIds: string[]): void;
+}
+
 /**
  * The reactive orchestration.
  *
@@ -533,6 +608,8 @@ type TrackingConfig = {
      * remain the source of truth.
      */
     serverUrl?: string;
+    /** WebSocket factory for the hint feed; defaults to the global `WebSocket` (testing). */
+    webSocketFactory?: (url: string) => WebSocketLike;
     /** Explicit per-ledger managers, bypassing auto-construction (advanced/testing). */
     managers?: Map<Ledger, ContractManager>;
     /** Ark server URL override; defaults to the mainnet server when unset. */
@@ -675,6 +752,7 @@ declare class Client {
     /** Delegated to the legacy client (migration checkpoint). */
     claim(...args: Parameters<Client$1["claim"]>): ReturnType<Client$1["claim"]>;
     /** Delegated to the legacy client (migration checkpoint). */
+    canSponsorClaim(...args: Parameters<Client$1["canSponsorClaim"]>): boolean;
     claimEvmWithSigner(...args: Parameters<Client$1["claimEvmWithSigner"]>): ReturnType<Client$1["claimEvmWithSigner"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     claimViaGasless(...args: Parameters<Client$1["claimViaGasless"]>): ReturnType<Client$1["claimViaGasless"]>;
@@ -689,6 +767,16 @@ declare class Client {
     /** Delegated to the legacy client (migration checkpoint). */
     buildCollabRefundEvmTypedData(...args: Parameters<Client$1["buildCollabRefundEvmTypedData"]>): ReturnType<Client$1["buildCollabRefundEvmTypedData"]>;
     /** Delegated to the legacy client (migration checkpoint). */
+    getCollabRefundEvmSignature(...args: Parameters<Client$1["getCollabRefundEvmSignature"]>): ReturnType<Client$1["getCollabRefundEvmSignature"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
+    getRehashEvmParams(...args: Parameters<Client$1["getRehashEvmParams"]>): ReturnType<Client$1["getRehashEvmParams"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
+    signRehashEvm(...args: Parameters<Client$1["signRehashEvm"]>): ReturnType<Client$1["signRehashEvm"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
+    retrySwapWithInvoice(...args: Parameters<Client$1["retrySwapWithInvoice"]>): ReturnType<Client$1["retrySwapWithInvoice"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
+    retrySwapWithInvoiceWithSigner(...args: Parameters<Client$1["retrySwapWithInvoiceWithSigner"]>): ReturnType<Client$1["retrySwapWithInvoiceWithSigner"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
     collabRefundEvmSwap(...args: Parameters<Client$1["collabRefundEvmSwap"]>): ReturnType<Client$1["collabRefundEvmSwap"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     submitCollabRefundEvm(...args: Parameters<Client$1["submitCollabRefundEvm"]>): ReturnType<Client$1["submitCollabRefundEvm"]>;
@@ -718,7 +806,10 @@ declare class Client {
     getCoordinatorFundingCallDataPermit2(...args: Parameters<Client$1["getCoordinatorFundingCallDataPermit2"]>): ReturnType<Client$1["getCoordinatorFundingCallDataPermit2"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     getPermit2FundingParamsUnsigned(...args: Parameters<Client$1["getPermit2FundingParamsUnsigned"]>): ReturnType<Client$1["getPermit2FundingParamsUnsigned"]>;
-    /** Delegated to the legacy client (migration checkpoint). */
+    /**
+     * Fund the swap, then re-verify it against the chain so the lock shows up
+     * in the derived actions without waiting on a server hint.
+     */
     fundSwap(...args: Parameters<Client$1["fundSwap"]>): ReturnType<Client$1["fundSwap"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     fundSwapFromSolana(...args: Parameters<Client$1["fundSwapFromSolana"]>): ReturnType<Client$1["fundSwapFromSolana"]>;
@@ -733,6 +824,8 @@ declare class Client {
     /** Delegated to the legacy client (migration checkpoint). */
     fundSwapGasless(...args: Parameters<Client$1["fundSwapGasless"]>): ReturnType<Client$1["fundSwapGasless"]>;
     /** Delegated to the legacy client (migration checkpoint). */
+    getEvmFundingExpectation(...args: Parameters<Client$1["getEvmFundingExpectation"]>): ReturnType<Client$1["getEvmFundingExpectation"]>;
+    /** Delegated to the legacy client (migration checkpoint). */
     getSwapDepositorKey(...args: Parameters<Client$1["getSwapDepositorKey"]>): ReturnType<Client$1["getSwapDepositorKey"]>;
     /** Delegated to the legacy client (migration checkpoint). */
     getEvmDepositorKey(...args: Parameters<Client$1["getEvmDepositorKey"]>): ReturnType<Client$1["getEvmDepositorKey"]>;
@@ -1538,7 +1631,7 @@ type SwapWorkerOptions = {
      * Resolve once submitted. OMIT for observe-only mode: hints still trigger
      * chain re-verifies (fast, cheap derivations), but nothing is ever run.
      */
-    execute?: (swapId: string, actionId: SwapActionId) => Promise<void>;
+    execute?: (swapId: string, actionId: SwapActionId, actions: SwapActions) => Promise<void>;
     /**
      * Surface an action that needs the user rather than being auto-run — a manual
      * `fund`, a refund the user must confirm, or a claim whose retries are spent.
@@ -1553,83 +1646,16 @@ declare class SwapWorker {
     constructor(options: SwapWorkerOptions);
     /** Watch tracked swaps on the hint feed, wire hints → verify, react to actions. */
     start(): void;
-    /** Stop reacting, cancel pending retries, and close the hint feed. */
-    stop(): void;
-}
-
-/**
- * A standalone subscriber to the server's swap-status WebSocket (`GET /ws`).
- *
- * Holds a single reconnecting connection, tracks a live set of subscribed swap
- * ids, and emits `{ swapId, status }` on every status transition the server
- * pushes — including the snapshot the server sends right after a subscribe. This
- * is a *hint* feed only: it neither trusts nor acts on the status. A consumer is
- * expected to verify against the chain (the contract managers) before doing
- * anything with it.
- *
- * Protocol (see `swap/src/api/ws.rs`):
- *   → {"op":"subscribe","channel":"swap_status","args":[<uuid>,...]}   (≤64 ids/frame)
- *   ← {"channel":"swap_status","data":{"<uuid>":"<status>",...}}
- *   ← {"op":"subscribed",...} (ack)     ← {"op":...,"message":...} (error)
- * A single connection carries up to 256 subscriptions; that cap is enforced
- * client-side (see {@link WsStatusSource.subscribe}) because the server silently
- * drops the overflow.
- */
-
-/** A status update pushed by the server for one swap. */
-type SwapStatusUpdate = {
-    swapId: string;
-    status: SwapStatus;
-};
-/** The minimal WebSocket surface the source needs (the global `WebSocket` satisfies it). */
-interface WebSocketLike {
-    send(data: string): void;
-    close(): void;
-    onopen: (() => void) | null;
-    onmessage: ((event: {
-        data: unknown;
-    }) => void) | null;
-    onclose: (() => void) | null;
-    onerror: ((event: unknown) => void) | null;
-}
-type WsStatusSourceOptions = {
-    /** Server base URL (http/https); the `ws(s)://…/ws` endpoint is derived from it. */
-    serverUrl: string;
-    /** WebSocket factory — defaults to the global `WebSocket` (browsers, Node ≥ 22). */
-    webSocketFactory?: (url: string) => WebSocketLike;
-    /** Reconnect backoff floor/ceiling (ms). Defaults: 1_000 / 30_000. */
-    reconnectMinMs?: number;
-    reconnectMaxMs?: number;
-};
-declare class WsStatusSource {
-    #private;
-    constructor(options: WsStatusSourceOptions);
-    /** Open the connection and begin (re)subscribing. Idempotent. */
-    start(): void;
-    /** Close the connection and stop reconnecting. */
-    stop(): void;
-    /** Emit for each pushed status update. Returns an unsubscribe fn. */
-    onStatus(cb: (update: SwapStatusUpdate) => void): () => void;
-    /**
-     * Emit whenever the socket comes (back) up after a disruption — a drop, or a
-     * first connect that had to be retried. NOT emitted on a pristine first open:
-     * hints were never live before it, so there is no gap to recover from. While
-     * the socket was down, pushed transitions were lost for good (the server only
-     * snapshots on subscribe), so a consumer should re-verify its world against
-     * the chain on this signal.
-     */
-    onReconnect(cb: () => void): () => void;
     /**
-     * Track these swap ids — subscribe on the socket now if open, else on next open.
-     *
-     * Enforces the server's per-connection cap locally. The server silently stops
-     * adding once it is full (it breaks out of the loop but still acks every id),
-     * so sending more would leave us believing ids are subscribed that will never
-     * receive an update. Overflow is queued instead and promoted as slots free.
+     * Put swaps on the hint feed as soon as they are tracked. {@link #onActions}
+     * subscribes a swap when its first action is emitted, but a swap whose leg
+     * cannot be classified yet (an unfunded lock on a chain without `eth_getLogs`)
+     * emits nothing, and without this it would never receive the server hint
+     * that its funding landed.
      */
     subscribe(swapIds: string[]): void;
-    /** Stop tracking these swap ids, promoting queued ones into the freed slots. */
-    unsubscribe(swapIds: string[]): void;
+    /** Stop reacting, cancel pending retries, and close the hint feed. */
+    stop(): void;
 }
 
 /**

package/dist/index.js

@@ -419,13 +419,10 @@ async function fetchArkadeSpend(source, spentByTxid, paymentHash) {
 
 // src/contracts/arkade-manager.ts
 function isFunded(vtxo) {
-  const { state } = vtxo.virtualStatus;
-  return state === "preconfirmed" || state === "settled";
+  return !vtxo.isSpent && !vtxo.isSwept;
 }
 function spendTxid(vtxos) {
-  const spent = vtxos.find(
-    (v) => v.arkTxId || v.spentBy || v.isSpent || v.virtualStatus.state === "spent"
-  );
+  const spent = vtxos.find((v) => v.arkTxId || v.spentBy || v.isSpent);
   return spent?.arkTxId ?? spent?.spentBy;
 }
 var ArkadeContractManager = class _ArkadeContractManager {
@@ -1478,6 +1475,17 @@ var SwapWorker = class {
       )
     );
   }
+  /**
+   * Put swaps on the hint feed as soon as they are tracked. {@link #onActions}
+   * subscribes a swap when its first action is emitted, but a swap whose leg
+   * cannot be classified yet (an unfunded lock on a chain without `eth_getLogs`)
+   * emits nothing, and without this it would never receive the server hint
+   * that its funding landed.
+   */
+  subscribe(swapIds) {
+    if (swapIds.length === 0) return;
+    this.#hintSource.subscribe(swapIds);
+  }
   /** Stop reacting, cancel pending retries, and close the hint feed. */
   stop() {
     this.#started = false;
@@ -1529,7 +1537,7 @@ var SwapWorker = class {
     const actionId = actions.recommended;
     if (!actionId) return;
     this.#executing.add(swapId);
-    void execute(swapId, actionId).then(() => this.#cancelRetry(swapId)).catch((error) => {
+    void execute(swapId, actionId, actions).then(() => this.#cancelRetry(swapId)).catch((error) => {
       if (needsWallet(error)) {
         this.#cancelRetry(swapId);
         this.#needsUser.add(swapId);
@@ -1947,7 +1955,7 @@ function swapToTracked(stored) {
           token: r.evm_htlc_kind === "native" ? 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,
+          sender: r.evm_htlc_kind === "native" && r.evm_coordinator_address.toLowerCase() === NATIVE_TOKEN_ADDRESS ? r.client_evm_address ?? void 0 : r.evm_coordinator_address,
           timelockSec: r.evm_refund_locktime,
           createdAt: r.created_at
         }),
@@ -1997,7 +2005,7 @@ function swapToTracked(stored) {
           token: r.wbtc_address,
           // The coordinator created the HTLC on the client's behalf, so it
           // is the lock's sender (refund address).
-          sender: r.evm_coordinator_address,
+          sender: r.evm_htlc_kind === "native" && r.evm_coordinator_address.toLowerCase() === NATIVE_TOKEN_ADDRESS ? r.client_evm_address ?? void 0 : r.evm_coordinator_address,
           timelockSec: r.evm_refund_locktime,
           createdAt: r.created_at
         }),
@@ -2092,7 +2100,7 @@ function swapToTracked(stored) {
           // the server claims the client's EVM HTLC
           expectedSats: r.evm_expected_sats,
           token: r.wbtc_address,
-          sender: r.evm_coordinator_address,
+          sender: r.evm_htlc_kind === "native" && r.evm_coordinator_address.toLowerCase() === NATIVE_TOKEN_ADDRESS ? r.client_evm_address ?? void 0 : r.evm_coordinator_address,
           // the coordinator locks on the client's behalf
           timelockSec: r.evm_refund_locktime,
           createdAt: r.created_at
@@ -2714,6 +2722,9 @@ var Client = class {
     return this.#legacy.claim(...args);
   }
   /** Delegated to the legacy client (migration checkpoint). */
+  canSponsorClaim(...args) {
+    return this.#legacy.canSponsorClaim(...args);
+  }
   claimEvmWithSigner(...args) {
     return this.#legacy.claimEvmWithSigner(...args);
   }
@@ -2742,6 +2753,26 @@ var Client = class {
     return this.#legacy.buildCollabRefundEvmTypedData(...args);
   }
   /** Delegated to the legacy client (migration checkpoint). */
+  getCollabRefundEvmSignature(...args) {
+    return this.#legacy.getCollabRefundEvmSignature(...args);
+  }
+  /** Delegated to the legacy client (migration checkpoint). */
+  getRehashEvmParams(...args) {
+    return this.#legacy.getRehashEvmParams(...args);
+  }
+  /** Delegated to the legacy client (migration checkpoint). */
+  signRehashEvm(...args) {
+    return this.#legacy.signRehashEvm(...args);
+  }
+  /** Delegated to the legacy client (migration checkpoint). */
+  retrySwapWithInvoice(...args) {
+    return this.#legacy.retrySwapWithInvoice(...args);
+  }
+  /** Delegated to the legacy client (migration checkpoint). */
+  retrySwapWithInvoiceWithSigner(...args) {
+    return this.#legacy.retrySwapWithInvoiceWithSigner(...args);
+  }
+  /** Delegated to the legacy client (migration checkpoint). */
   collabRefundEvmSwap(...args) {
     return this.#legacy.collabRefundEvmSwap(...args);
   }
@@ -2817,9 +2848,14 @@ var Client = class {
   getPermit2FundingParamsUnsigned(...args) {
     return this.#legacy.getPermit2FundingParamsUnsigned(...args);
   }
-  /** Delegated to the legacy client (migration checkpoint). */
-  fundSwap(...args) {
-    return this.#legacy.fundSwap(...args);
+  /**
+   * Fund the swap, then re-verify it against the chain so the lock shows up
+   * in the derived actions without waiting on a server hint.
+   */
+  async fundSwap(...args) {
+    const result = await this.#legacy.fundSwap(...args);
+    this.#reverifyAfterFunding(args[0]);
+    return result;
   }
   /** Delegated to the legacy client (migration checkpoint). */
   fundSwapFromSolana(...args) {
@@ -2846,6 +2882,10 @@ var Client = class {
     return this.#legacy.fundSwapGasless(...args);
   }
   /** Delegated to the legacy client (migration checkpoint). */
+  getEvmFundingExpectation(...args) {
+    return this.#legacy.getEvmFundingExpectation(...args);
+  }
+  /** Delegated to the legacy client (migration checkpoint). */
   getSwapDepositorKey(...args) {
     return this.#legacy.getSwapDepositorKey(...args);
   }
@@ -3046,11 +3086,37 @@ var Client = class {
     for (const swap of swaps) {
       try {
         await tracker.track(swap);
+        if (tracker.trackedSwapIds().includes(swap.swapId))
+          this.#worker?.subscribe([swap.swapId]);
       } catch (error) {
         console.warn(`Client: tracking swap ${swap.swapId} failed:`, error);
       }
     }
   }
+  /**
+   * Re-verify a swap against the chain right after this client funded it.
+   * The funding is mined when `fundSwap` resolves, but nothing else tells the
+   * tracker so: a server hint arrives only after the server's own monitor
+   * sees the lock (on Rootstock, a 30 s poll plus confirmations), and the
+   * tracker's at-risk poll does not re-read an `absent` client leg. One
+   * targeted read moves the swap to `clientfunded` at once. Fire-and-forget:
+   * the funding succeeded whatever the re-verify does, and a swap that is not
+   * tracked is a no-op.
+   *
+   * Chain-verified tracking only: a hints-only tracker has no chain to read,
+   * its `applyHint` re-fetches the server's stored status, which lags the
+   * lock by the same server-side delay this works around.
+   */
+  #reverifyAfterFunding(swapId) {
+    if (typeof swapId !== "string" || !(this.#tracker instanceof SwapTracker))
+      return;
+    void this.#tracker.applyHint(swapId).catch((error) => {
+      console.warn(
+        `Client: re-verify after funding ${swapId} failed (the tracker's next read catches up):`,
+        error
+      );
+    });
+  }
   /**
    * Wire the server status WebSocket into a {@link SwapWorker} whenever a server
    * URL is configured: pushed status transitions trigger a targeted chain
@@ -3063,7 +3129,10 @@ var Client = class {
     const serverUrl = this.#tracking.serverUrl ?? legacyBaseUrl(this.#legacy);
     if (!serverUrl) return;
     const autoClaim = this.#tracking.autoClaim;
-    const hintSource = new WsStatusSource({ serverUrl });
+    const hintSource = new WsStatusSource({
+      serverUrl,
+      webSocketFactory: this.#tracking.webSocketFactory
+    });
     const worker = new SwapWorker({
       tracker,
       hintSource,