@silentswap/react 0.0.79 → 0.0.80

package/dist/contexts/OrdersContext.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import type { NaiveBase58, RefundEligibility } from '@silentswap/sdk';
 import type { SilentSwapWallet } from '../hooks/silent/useWallet.js';
+import { type OrderTrackingState, type OrderTrackingOptions } from './orderTrackingTypes.js';
 export type OrdersContextOrderMetadata = {
     sourceAsset?: {
         caip19: string;
@@ -53,6 +54,10 @@ export type OrdersContextType = {
         pulsing: boolean;
         color: string;
     };
+    orderTrackingByKey: Record<string, OrderTrackingState>;
+    connectOrderTracking: (orderId: string, auth: string, options: OrderTrackingOptions) => void;
+    disconnectOrderTracking: (orderId: string, auth: string) => void;
+    getOrderTrackingState: (orderId: string, auth: string) => OrderTrackingState;
 };
 export declare const OrdersProvider: React.FC<{
     children: React.ReactNode;

package/dist/contexts/OrdersContext.js

@@ -4,6 +4,8 @@ import { createContext, useContext, useState, useEffect, useCallback, useMemo, u
 import { bytes_to_base58, DepositStatus, hex_to_bytes } from '@silentswap/sdk';
 import { useLocalStorage } from 'usehooks-ts';
 import { useSilentSwap } from './SilentSwapContext.js';
+import { createOrderTrackingManager } from './orderTrackingConnection.js';
+import { getOrderTrackingCacheKey, DEFAULT_ORDER_TRACKING_STATE, } from './orderTrackingTypes.js';
 export const useWalletFacilitatorGroups = (wallet, setFacilitatorGroups) => {
     // Automatically set facilitator groups from wallet (matches Svelte behavior)
     // In Svelte: UserState.facilitatorGroups = a_accounts.map(g => g.group) when wallet loads
@@ -29,6 +31,48 @@ export const OrdersProvider = ({ children, baseUrl: baseUrlProp }) => {
     const [orderIdToViewingAuth, setOrderIdToViewingAuth] = useLocalStorage('orderIdToViewingAuth', {}, { initializeWithValue: true });
     const [orderIdToDefaultPublicKey, setOrderIdToDefaultPublicKey] = useLocalStorage('orderIdToDefaultPublicKey', {}, { initializeWithValue: true });
     const [orderIdToDestinations, setOrderIdToDestinationsState] = useLocalStorage('orderIdToDestinations', {}, { initializeWithValue: true });
+    // Order tracking: WebSocket connections and status cache live in context
+    const [orderTrackingByKey, setOrderTrackingByKey] = useState({});
+    const orderTrackingStateRef = useRef(new Map());
+    const activeTrackingKeysRef = useRef(new Set());
+    const optionsByKeyRef = useRef(new Map());
+    // Stable API object: only setStateForKey needs a ref so it always sees latest setOrderTrackingByKey
+    const setStateForKeyRef = useRef(null);
+    setStateForKeyRef.current = (key, state) => {
+        orderTrackingStateRef.current.set(key, state);
+        setOrderTrackingByKey((prev) => ({ ...prev, [key]: state }));
+    };
+    const orderTrackingApiRef = useRef({
+        setStateForKey(key, state) {
+            setStateForKeyRef.current(key, state);
+        },
+        getStateForKey(key) {
+            return orderTrackingStateRef.current.get(key);
+        },
+        isKeyActive(key) {
+            return activeTrackingKeysRef.current.has(key);
+        },
+        getOptionsForKey(key) {
+            return optionsByKeyRef.current.get(key);
+        },
+    });
+    const orderTrackingManager = useMemo(() => createOrderTrackingManager(orderTrackingApiRef), []);
+    const connectOrderTracking = useCallback((orderId, auth, options) => {
+        const key = getOrderTrackingCacheKey(orderId, auth);
+        activeTrackingKeysRef.current.add(key);
+        optionsByKeyRef.current.set(key, options);
+        orderTrackingManager.connect(orderId, auth, key, options);
+    }, [orderTrackingManager]);
+    const disconnectOrderTracking = useCallback((orderId, auth) => {
+        const key = getOrderTrackingCacheKey(orderId, auth);
+        activeTrackingKeysRef.current.delete(key);
+        optionsByKeyRef.current.delete(key);
+        orderTrackingManager.disconnect(orderId, auth);
+    }, [orderTrackingManager]);
+    const getOrderTrackingState = useCallback((orderId, auth) => {
+        const key = getOrderTrackingCacheKey(orderId, auth);
+        return orderTrackingByKey[key] ?? DEFAULT_ORDER_TRACKING_STATE;
+    }, [orderTrackingByKey]);
     // Generate viewing auth token from facilitator group
     const facilitator_group_authorize_order_view = useCallback(async (groupGetter) => {
         try {
@@ -254,6 +298,10 @@ export const OrdersProvider = ({ children, baseUrl: baseUrlProp }) => {
         refreshOrders,
         getOrderAgeText,
         getStatusInfo,
+        orderTrackingByKey,
+        connectOrderTracking,
+        disconnectOrderTracking,
+        getOrderTrackingState,
     }), [
         orders,
         loading,
@@ -269,6 +317,10 @@ export const OrdersProvider = ({ children, baseUrl: baseUrlProp }) => {
         refreshOrders,
         getOrderAgeText,
         getStatusInfo,
+        orderTrackingByKey,
+        connectOrderTracking,
+        disconnectOrderTracking,
+        getOrderTrackingState,
     ]);
     return _jsx(OrdersContext.Provider, { value: value, children: children });
 };

package/dist/contexts/orderTrackingConnection.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Order tracking WebSocket and cache logic.
+ * Lives in context via createOrderTrackingManager(); state updates go through setStateForKey.
+ */
+import type { OrderTrackingState, OrderTrackingOptions } from './orderTrackingTypes.js';
+export type OrderTrackingManagerApi = {
+    setStateForKey: (key: string, state: OrderTrackingState) => void;
+    getStateForKey: (key: string) => OrderTrackingState | undefined;
+    isKeyActive: (key: string) => boolean;
+    getOptionsForKey: (key: string) => OrderTrackingOptions | undefined;
+};
+/** Ref-like object so the manager always reads the current API (avoids storing manager in a ref). */
+export type OrderTrackingManagerApiRef = {
+    current: OrderTrackingManagerApi;
+};
+export declare function createOrderTrackingManager(apiRef: OrderTrackingManagerApiRef): {
+    connect: (orderId: string, auth: string, key: string, options: OrderTrackingOptions) => void;
+    disconnect: (orderId: string, auth: string) => void;
+};

package/dist/contexts/orderTrackingConnection.js

@@ -0,0 +1,327 @@
+/**
+ * Order tracking WebSocket and cache logic.
+ * Lives in context via createOrderTrackingManager(); state updates go through setStateForKey.
+ */
+import { OutputStage, DEFAULT_ORDER_TRACKING_STATE, getStatusTextFromStage, getProgressFromStage, hasFinalizedOutput, isFullOrderStatus, getOrderTrackingCacheKey, buildOrderTrackingWsUrl, } from './orderTrackingTypes.js';
+const wsCache = new Map();
+const pendingCleanups = new Map();
+const statusCache = new Map();
+function buildFullState(key, status, isConnected, isLoading, error) {
+    const outputsList = status.outputs ?? [];
+    const numOutputs = outputsList.length || 1;
+    const newOutputs = [];
+    const newProgresses = [];
+    const newStatusTexts = [];
+    for (let index = 0; index < outputsList.length; index++) {
+        const output = outputsList[index];
+        const outputAsset = output.output ??
+            (output.asset
+                ? { caip19: output.asset, amount: output.value || '0', decimals: 0 }
+                : undefined);
+        newOutputs.push({
+            index,
+            stage: output.stage,
+            timestamp: output.timestamp,
+            recipient: output.recipient,
+            asset: outputAsset,
+            txs: output.txs,
+        });
+        newProgresses.push(getProgressFromStage(output.stage));
+        newStatusTexts.push(getStatusTextFromStage(output.stage));
+    }
+    const allFinalized = newOutputs.length > 0 && newOutputs.every((o) => o.stage === OutputStage.FINALIZED);
+    const completedTimestamp = outputsList.length > 0
+        ? outputsList.reduce((min, o) => (min == null || o.timestamp < min ? o.timestamp : min), null)
+        : null;
+    return {
+        isConnected,
+        isLoading,
+        error,
+        orderStatus: status,
+        deposit: status.deposit
+            ? {
+                amount: status.deposit.amount,
+                timestamp: status.deposit.timestamp,
+                duration: status.deposit.duration,
+                orderId: status.deposit.orderId,
+                tx: status.deposit.tx,
+            }
+            : null,
+        outputs: newOutputs.length ? newOutputs : [],
+        progresses: newProgresses.length ? newProgresses : new Array(numOutputs).fill(undefined),
+        statusTexts: newStatusTexts.length ? newStatusTexts : new Array(numOutputs).fill('Connecting'),
+        completedTimestamp: allFinalized ? completedTimestamp : null,
+        isComplete: allFinalized,
+    };
+}
+function applyFullStatus(getApi, key, status, cacheConn, isConnected, isLoading, error) {
+    const api = getApi();
+    const current = api.getStateForKey(key)?.orderStatus;
+    const currentFinalized = current && hasFinalizedOutput(current);
+    const incomingFinalized = hasFinalizedOutput(status);
+    if (currentFinalized && !incomingFinalized)
+        return;
+    if (cacheConn) {
+        cacheConn.initialStatus = status;
+        statusCache.set(getOrderTrackingCacheKey(cacheConn.orderId, cacheConn.auth), status);
+    }
+    const state = buildFullState(key, status, isConnected, isLoading, error);
+    api.setStateForKey(key, state);
+    api.getOptionsForKey(key)?.onStatusUpdate?.(status);
+}
+function submitRequest(conn, method, params, handler) {
+    if (conn.ws.readyState !== WebSocket.OPEN)
+        return -1;
+    const requestId = conn.requestCounter++;
+    const request = { jsonrpc: '2.0', id: requestId, method, params };
+    if (handler)
+        conn.responseHandlers.set(requestId, handler);
+    conn.ws.send(JSON.stringify(request));
+    return requestId;
+}
+export function createOrderTrackingManager(apiRef) {
+    const getApi = () => apiRef.current;
+    const reconnectTimeoutRef = { current: null };
+    function handleStatusUpdate(key, update, conn, getCurrentState) {
+        conn.statusUpdates.push(update);
+        const prev = getCurrentState() ?? DEFAULT_ORDER_TRACKING_STATE;
+        let next = { ...prev };
+        switch (update.type) {
+            case 'deposit':
+                next = {
+                    ...next,
+                    deposit: {
+                        amount: update.data.amount,
+                        timestamp: update.data.timestamp,
+                        duration: update.data.duration,
+                        orderId: update.data.orderId,
+                        tx: update.data.tx,
+                    },
+                };
+                break;
+            case 'stage': {
+                const idx = update.data.index;
+                const progress = getProgressFromStage(update.data.stage);
+                const statusText = getStatusTextFromStage(update.data.stage);
+                const newOutputs = [...(next.outputs || [])];
+                newOutputs[idx] = {
+                    ...newOutputs[idx],
+                    index: idx,
+                    stage: update.data.stage,
+                    timestamp: update.data.timestamp,
+                    ...(update.data.asset ? { asset: update.data.asset } : {}),
+                };
+                const newProgresses = [...(next.progresses || [])];
+                newProgresses[idx] = progress;
+                const newStatusTexts = [...(next.statusTexts || [])];
+                newStatusTexts[idx] = statusText;
+                next = {
+                    ...next,
+                    outputs: newOutputs,
+                    progresses: newProgresses,
+                    statusTexts: newStatusTexts,
+                };
+                const allOne = newProgresses.every((p) => (p ?? 0) >= 1);
+                if (allOne) {
+                    next = {
+                        ...next,
+                        isComplete: true,
+                        completedTimestamp: next.completedTimestamp ?? update.data.timestamp,
+                    };
+                    getApi().getOptionsForKey(key)?.onComplete?.();
+                }
+                break;
+            }
+            case 'transaction': {
+                const newOutputs = [...(next.outputs || [])];
+                if (newOutputs[update.data.index]) {
+                    const existingTxs = newOutputs[update.data.index].txs || {};
+                    newOutputs[update.data.index] = {
+                        ...newOutputs[update.data.index],
+                        txs: {
+                            ...existingTxs,
+                            [update.data.kind]: {
+                                txId: update.data.txId,
+                                chain: update.data.chain,
+                            },
+                        },
+                    };
+                }
+                next = { ...next, outputs: newOutputs };
+                break;
+            }
+            case 'error': {
+                const err = new Error(update.data.message || 'Order tracking error');
+                next = { ...next, error: err };
+                getApi().getOptionsForKey(key)?.onError?.(err);
+                break;
+            }
+        }
+        getApi().setStateForKey(key, next);
+    }
+    function connect(orderId, auth, key, options) {
+        const client = options.client;
+        const pendingCleanup = pendingCleanups.get(key);
+        if (pendingCleanup) {
+            clearTimeout(pendingCleanup);
+            pendingCleanups.delete(key);
+        }
+        if (reconnectTimeoutRef.current) {
+            clearTimeout(reconnectTimeoutRef.current);
+            reconnectTimeoutRef.current = null;
+        }
+        const cached = wsCache.get(key);
+        if (cached &&
+            (cached.ws.readyState === WebSocket.OPEN || cached.ws.readyState === WebSocket.CONNECTING)) {
+            if (cached.initialStatus) {
+                const status = cached.initialStatus;
+                applyFullStatus(getApi, key, status, cached, true, false, null);
+            }
+            return;
+        }
+        wsCache.delete(key);
+        const cachedStatus = statusCache.get(key);
+        if (cachedStatus) {
+            applyFullStatus(getApi, key, cachedStatus, null, false, false, null);
+        }
+        else {
+            getApi().setStateForKey(key, {
+                ...DEFAULT_ORDER_TRACKING_STATE,
+                isLoading: true,
+            });
+        }
+        const wsUrl = buildOrderTrackingWsUrl(client);
+        let ws;
+        try {
+            ws = new WebSocket(wsUrl);
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error('Failed to connect to order tracking');
+            getApi().setStateForKey(key, {
+                ...DEFAULT_ORDER_TRACKING_STATE,
+                error: e,
+                isLoading: false,
+            });
+            options.onError?.(e);
+            return;
+        }
+        const conn = {
+            ws,
+            orderId,
+            auth,
+            requestCounter: 0,
+            responseHandlers: new Map(),
+            lastReceived: 0,
+            reconnectTimeout: null,
+            initialStatus: null,
+            statusUpdates: [],
+        };
+        wsCache.set(key, conn);
+        ws.onopen = () => {
+            conn.lastReceived = Date.now();
+            const connectRequestId = submitRequest(conn, 'connect', { auth: { orderId, viewingAuth: auth } }, (rpcError, result) => {
+                if (rpcError) {
+                    const err = new Error(rpcError.message || 'Connection error');
+                    if (!getApi().isKeyActive(key))
+                        return;
+                    getApi().setStateForKey(key, {
+                        ...DEFAULT_ORDER_TRACKING_STATE,
+                        error: err,
+                        isLoading: false,
+                    });
+                    getApi().getOptionsForKey(key)?.onError?.(err);
+                    return;
+                }
+                if (!getApi().isKeyActive(key))
+                    return;
+                const status = result;
+                conn.statusUpdates = [];
+                applyFullStatus(getApi, key, status, conn, true, false, null);
+                if (connectRequestId >= 0) {
+                    conn.responseHandlers.set(connectRequestId, (statusError, statusResult) => {
+                        if (statusError) {
+                            const err = new Error(statusError.message || 'Status error');
+                            if (!getApi().isKeyActive(key))
+                                return;
+                            const prev = getApi().getStateForKey(key) ?? DEFAULT_ORDER_TRACKING_STATE;
+                            getApi().setStateForKey(key, { ...prev, error: err });
+                            getApi().getOptionsForKey(key)?.onError?.(err);
+                            return;
+                        }
+                        if (!getApi().isKeyActive(key))
+                            return;
+                        if (isFullOrderStatus(statusResult)) {
+                            applyFullStatus(getApi, key, statusResult, conn, true, false, null);
+                            return;
+                        }
+                        handleStatusUpdate(key, statusResult, conn, () => getApi().getStateForKey(key));
+                    });
+                }
+                getApi().getOptionsForKey(key)?.onStatusUpdate?.(status);
+            });
+        };
+        ws.onmessage = (event) => {
+            conn.lastReceived = Date.now();
+            try {
+                const response = JSON.parse(event.data);
+                if (response.jsonrpc !== '2.0' || typeof response.id !== 'number')
+                    return;
+                const handler = conn.responseHandlers.get(response.id);
+                if (handler)
+                    handler(response.error, response.result);
+            }
+            catch {
+                // ignore
+            }
+        };
+        ws.onerror = () => {
+            if (!getApi().isKeyActive(key))
+                return;
+            const prev = getApi().getStateForKey(key) ?? DEFAULT_ORDER_TRACKING_STATE;
+            getApi().setStateForKey(key, {
+                ...prev,
+                error: new Error('WebSocket connection error'),
+                isLoading: false,
+            });
+        };
+        ws.onclose = () => {
+            if (wsCache.get(key)?.ws === ws)
+                wsCache.delete(key);
+            conn.responseHandlers.clear();
+            conn.initialStatus = null;
+            conn.statusUpdates = [];
+            if (getApi().isKeyActive(key)) {
+                const prev = getApi().getStateForKey(key) ?? DEFAULT_ORDER_TRACKING_STATE;
+                getApi().setStateForKey(key, { ...prev, isConnected: false });
+                const idle = Date.now() - conn.lastReceived > 90_000;
+                if (idle) {
+                    reconnectTimeoutRef.current = setTimeout(() => {
+                        if (getApi().isKeyActive(key))
+                            connect(orderId, auth, key, getApi().getOptionsForKey(key) ?? {});
+                    }, 5000);
+                }
+                else {
+                    connect(orderId, auth, key, getApi().getOptionsForKey(key) ?? {});
+                }
+            }
+        };
+    }
+    function disconnect(orderId, auth) {
+        if (reconnectTimeoutRef.current) {
+            clearTimeout(reconnectTimeoutRef.current);
+            reconnectTimeoutRef.current = null;
+        }
+        const key = getOrderTrackingCacheKey(orderId, auth);
+        const ws = wsCache.get(key)?.ws;
+        if (ws) {
+            pendingCleanups.set(key, setTimeout(() => {
+                pendingCleanups.delete(key);
+                if (wsCache.get(key)?.ws === ws) {
+                    wsCache.delete(key);
+                    ws.close();
+                }
+            }, 500));
+        }
+    }
+    return { connect, disconnect };
+}

package/dist/contexts/orderTrackingTypes.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Shared types and helpers for order tracking (WebSocket + context).
+ * Used by orderTrackingConnection.ts and useOrderTracking.ts.
+ */
+import type { SilentSwapClient } from '@silentswap/sdk';
+export declare enum OutputStage {
+    NONE = "NONE",
+    INIT = "INIT",
+    FUNDED = "FUNDED",
+    REDEEMED = "REDEEMED",
+    IBC_SENT = "IBC_SENT",
+    IBC_RCVD = "IBC_RCVD",
+    BRIDGE_SENT = "BRIDGE_SENT",
+    BRIDGE_CFRM = "BRIDGE_CFRM",
+    BRIDGE_RCVD = "BRIDGE_RCVD",
+    SWAP_USDC_GAS = "SWAP_USDC_GAS",
+    SWAP_USDC_TRG = "SWAP_USDC_TRG",
+    LTRL_TRG_SENT = "LTRL_TRG_SENT",
+    LTRL_TRG_RCVD = "LTRL_TRG_RCVD",
+    SWAP_TRG_DST = "SWAP_TRG_DST",
+    XFER_TRG_DST = "XFER_TRG_DST",
+    REFUND_NATIVE = "REFUND_NATIVE",
+    FINALIZED = "FINALIZED"
+}
+export type OrderDeposit = {
+    amount: string;
+    timestamp: number;
+    duration: number;
+    orderId?: string;
+    tx?: string;
+};
+export type OrderTransactions = {
+    RECEIPT?: {
+        chain: string;
+        txId: string;
+    };
+    REFUND?: {
+        chain: string;
+        txId: string;
+    };
+};
+export type OutputStatus = {
+    index: number;
+    stage: OutputStage;
+    timestamp: number;
+    recipient?: string;
+    asset?: {
+        caip19: string;
+        amount: string;
+        decimals: number;
+        priceUsd?: number;
+    };
+    txs?: OrderTransactions;
+};
+export type IOutput = {
+    caip19: string;
+    amount: string;
+    decimals: number;
+    priceUsd?: number;
+};
+export type Outputs = Array<{
+    stage: OutputStage;
+    timestamp: number;
+    asset: string;
+    value: string;
+    recipient: string;
+    txs?: OrderTransactions;
+    output?: IOutput;
+}>;
+export type OrderStatus = {
+    priority?: string;
+    signer: string;
+    deposit?: OrderDeposit;
+    outputs: Outputs;
+    metadata?: {
+        sourceAsset?: {
+            caip19: string;
+            amount: string;
+        };
+        sourceSender?: {
+            contactId: string;
+        };
+    };
+};
+export type StatusUpdate = {
+    type: 'deposit';
+    data: OrderDeposit;
+} | {
+    type: 'stage';
+    data: {
+        orderId: string;
+        index: number;
+        stage: OutputStage;
+        timestamp: number;
+        asset?: {
+            caip19: string;
+            amount: string;
+            decimals: number;
+            priceUsd?: number;
+        };
+    };
+} | {
+    type: 'transaction';
+    data: {
+        orderId: string;
+        index: number;
+        chain: string;
+        txId: string;
+        kind: keyof OrderTransactions;
+    };
+} | {
+    type: 'error';
+    data: {
+        orderId: string;
+        message: string;
+        index?: number;
+    };
+};
+export type JsonRpcError = {
+    code: number;
+    message: string;
+    data?: unknown;
+};
+export type OrderTrackingState = {
+    isConnected: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    orderStatus: OrderStatus | null;
+    deposit: OrderDeposit | null;
+    outputs: OutputStatus[];
+    progresses: (number | undefined)[];
+    statusTexts: string[];
+    completedTimestamp: number | null;
+    isComplete: boolean;
+};
+export type OrderTrackingOptions = {
+    client?: SilentSwapClient;
+    onStatusUpdate?: (status: OrderStatus) => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+    fetchAssetPrice?: (caip19: string) => Promise<number>;
+};
+export declare const DEFAULT_ORDER_TRACKING_STATE: OrderTrackingState;
+export declare function getStatusTextFromStage(stage: OutputStage): string;
+export declare function getProgressFromStage(stage: OutputStage): number;
+export declare function getOrderTrackingCacheKey(orderId: string, auth: string): string;
+export declare function hasFinalizedOutput(status: OrderStatus): boolean;
+export declare function isFullOrderStatus(result: unknown): result is OrderStatus;
+export declare function buildOrderTrackingWsUrl(client?: SilentSwapClient): string;