@silentswap/react 0.0.41

package/dist/contexts/OrdersContext.js

@@ -0,0 +1,240 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { bytes_to_base58, DepositStatus, hex_to_bytes } from '@silentswap/sdk';
+import { useLocalStorage } from 'usehooks-ts';
+import { useSilentSwap } from './SilentSwapContext.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
+    // This ensures orders can be fetched even after page refresh, since wallet data is in sessionStorage
+    // The wallet entropy is persisted in sessionStorage, and groups are recreated from it
+    useEffect(() => {
+        if (wallet?.accounts && wallet.accounts.length > 0) {
+            // Replace facilitator groups with wallet accounts (matches Svelte assignment behavior)
+            // This prevents duplication and ensures groups match the current wallet state
+            setFacilitatorGroups(wallet.accounts.map((account) => account.group));
+        }
+        else if (!wallet) {
+            // Clear groups when wallet is null (matches Svelte reset behavior)
+            setFacilitatorGroups([]);
+        }
+    }, [wallet, setFacilitatorGroups]);
+};
+const OrdersContext = createContext(undefined);
+export const OrdersProvider = ({ children }) => {
+    const [orders, setOrders] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [facilitatorGroups, setFacilitatorGroupsState] = useState([]);
+    const [orderIdToViewingAuth, setOrderIdToViewingAuth] = useLocalStorage('orderIdToViewingAuth', {}, { initializeWithValue: true });
+    const [orderIdToDefaultPublicKey, setOrderIdToDefaultPublicKey] = useLocalStorage('orderIdToDefaultPublicKey', {}, { initializeWithValue: true });
+    // Generate viewing auth token from facilitator group
+    const facilitator_group_authorize_order_view = useCallback(async (groupGetter) => {
+        try {
+            const k_group = await groupGetter();
+            const k_viewer = await k_group.viewer();
+            const y_signer_viewer = await k_viewer.evmSigner();
+            // Reformat its 20-byte address to base58 for compactness
+            return bytes_to_base58(hex_to_bytes(y_signer_viewer.address.replace(/^0x/, '')));
+        }
+        catch (error) {
+            console.warn('Failed to authorize order view:', error);
+            return '';
+        }
+    }, []);
+    // Get baseUrl from environment
+    const { config } = useSilentSwap();
+    const baseUrl = config.baseUrl;
+    // Fetch recent orders from API (matches Svelte implementation)
+    const request_recent_orders = useCallback(async (sb58_auth_view) => {
+        try {
+            // Request current orders from backend using facilitator auth
+            const d_res = await fetch(`${baseUrl}/recent?${new URLSearchParams({
+                auth: sb58_auth_view,
+            })}`);
+            // Parse response body
+            const sx_res = await d_res.text();
+            // Attempt to parse JSON (with safe parsing like Svelte)
+            let a_orders;
+            try {
+                const parsed = JSON.parse(sx_res);
+                if (Array.isArray(parsed)) {
+                    a_orders = parsed.filter((order) => order !== null && typeof order === 'object' && 'orderId' in order);
+                }
+                else {
+                    throw new Error('Response is not an array');
+                }
+            }
+            catch (parseError) {
+                throw new Error('Unable to retrieve recent orders');
+            }
+            // Add order ID to viewing auth map (same as Svelte)
+            // Use functional update to avoid dependency on orderIdToViewingAuth
+            setOrderIdToViewingAuth((prevMapping) => {
+                const newMapping = { ...prevMapping };
+                for (const g_order of a_orders) {
+                    newMapping[g_order.orderId] = sb58_auth_view;
+                }
+                return newMapping;
+            });
+            return a_orders;
+        }
+        catch (error) {
+            console.warn('Failed to fetch recent orders:', error);
+            throw error;
+        }
+    }, [baseUrl, setOrderIdToViewingAuth]);
+    // Store facilitatorGroups in a ref for use in loadOrders
+    const facilitatorGroupsRef = useRef(facilitatorGroups);
+    useEffect(() => {
+        facilitatorGroupsRef.current = facilitatorGroups;
+    }, [facilitatorGroups]);
+    const loadOrders = useCallback(async () => {
+        // Get fresh facilitatorGroups from ref to avoid stale closures
+        const currentGroups = facilitatorGroupsRef.current;
+        if (currentGroups.length === 0)
+            return;
+        setLoading(true);
+        try {
+            const a_all_orders = [];
+            // Fetch orders for each facilitator group
+            await Promise.all(currentGroups.map(async (f_group) => {
+                try {
+                    const sb58_auth_view = await facilitator_group_authorize_order_view(f_group);
+                    const a_recents = await request_recent_orders(sb58_auth_view);
+                    // At least one is complete - convert all others in INIT state to REPLACED
+                    const b_complete = !!a_recents?.find((g) => 'COMPLETE' === g.status);
+                    if (b_complete) {
+                        for (const g of a_recents) {
+                            if ('INIT' === g.status)
+                                g.status = 'REPLACED';
+                        }
+                    }
+                    // Update orders; augmenting with auth
+                    a_all_orders.push(...a_recents.map((g) => ({ ...g, auth: sb58_auth_view })));
+                }
+                catch (error) {
+                    console.warn('Failed to load orders for facilitator group:', error);
+                }
+            }));
+            // Sort by modification time (newest first)
+            a_all_orders.sort((g_a, g_b) => (g_b.modified ?? 0) - (g_a.modified ?? 0));
+            setOrders(a_all_orders);
+        }
+        catch (error) {
+            console.error('Failed to load orders:', error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [facilitator_group_authorize_order_view, request_recent_orders]);
+    // Store loadOrders in a ref to avoid dependency issues
+    const loadOrdersRef = useRef(loadOrders);
+    useEffect(() => {
+        loadOrdersRef.current = loadOrders;
+    }, [loadOrders]);
+    // Poll for recent orders when facilitator groups change (matching Svelte $effect behavior)
+    // In Svelte: $effect(() => { ... }) watches UserState.facilitatorGroups array reference
+    useEffect(() => {
+        if (facilitatorGroups.length === 0)
+            return;
+        // Initial load when groups change (matches Svelte $effect behavior)
+        loadOrdersRef.current();
+    }, [facilitatorGroups]); // Depend on array reference to trigger when groups are replaced
+    const addFacilitatorGroup = useCallback((group) => {
+        // Add a single facilitator group (for manual additions, e.g., after swap)
+        setFacilitatorGroupsState((prev) => {
+            // Check if group already exists to prevent duplicates
+            // Since groups are functions, we can't easily compare them, so we'll just append
+            // The main use case is setFacilitatorGroups which replaces the array
+            return [...prev, group];
+        });
+    }, []);
+    const setFacilitatorGroups = useCallback((groups) => {
+        // Replace facilitator groups (matches Svelte UserState.facilitatorGroups = ... behavior)
+        setFacilitatorGroupsState(groups);
+    }, []);
+    const setOrderDefaultPublicKey = useCallback((orderId, publicKey) => {
+        setOrderIdToDefaultPublicKey((prev) => ({
+            ...prev,
+            [orderId]: publicKey,
+        }));
+    }, [setOrderIdToDefaultPublicKey]);
+    const clearFacilitatorGroups = useCallback(() => {
+        setFacilitatorGroupsState([]);
+        setOrders([]);
+        setOrderIdToViewingAuth({});
+        setOrderIdToDefaultPublicKey({});
+    }, [setOrderIdToViewingAuth, setOrderIdToDefaultPublicKey]);
+    const refreshOrders = useCallback(() => {
+        loadOrders();
+    }, [loadOrders]);
+    // Helper function to get order age text
+    const getOrderAgeText = useCallback((modified) => {
+        if (!modified)
+            return 'Unknown';
+        const xt_age = Date.now() - modified;
+        const xt_minutes = Math.round(xt_age / 60000);
+        const xt_hours = Math.min(999, Math.round(xt_age / 3600000));
+        if (xt_age < 90 * 60 * 1000) {
+            // Less than 90 minutes
+            return xt_minutes <= 1 ? '1 min ago' : `${xt_minutes} min ago`;
+        }
+        else {
+            return xt_hours <= 1 ? '1 hr ago' : `${xt_hours} hr ago`;
+        }
+    }, []);
+    // Helper function to get status display info
+    const getStatusInfo = useCallback((status, refundEligibility) => {
+        if (!refundEligibility?.refundable && refundEligibility?.code === DepositStatus.ABORTED) {
+            return { text: 'Aborted', pulsing: false, color: 'text-gray-400' };
+        }
+        switch (status) {
+            case 'INIT':
+                return { text: 'Waiting for deposit', pulsing: true, color: 'text-white' };
+            case 'REPLACED':
+                return { text: 'Replaced', pulsing: false, color: 'text-gray-400' };
+            case 'IN_PROGRESS':
+                return { text: 'In progress', pulsing: true, color: 'text-white' };
+            case 'COMPLETE':
+                return { text: 'Completed', pulsing: false, color: 'text-green-400' };
+            default:
+                return { text: status, pulsing: false, color: 'text-white' };
+        }
+    }, []);
+    const value = useMemo(() => ({
+        orders,
+        loading,
+        facilitatorGroups,
+        orderIdToViewingAuth,
+        orderIdToDefaultPublicKey,
+        addFacilitatorGroup,
+        setFacilitatorGroups,
+        clearFacilitatorGroups,
+        setOrderDefaultPublicKey,
+        refreshOrders,
+        getOrderAgeText,
+        getStatusInfo,
+    }), [
+        orders,
+        loading,
+        facilitatorGroups,
+        orderIdToViewingAuth,
+        orderIdToDefaultPublicKey,
+        addFacilitatorGroup,
+        setFacilitatorGroups,
+        clearFacilitatorGroups,
+        setOrderDefaultPublicKey,
+        refreshOrders,
+        getOrderAgeText,
+        getStatusInfo,
+    ]);
+    return _jsx(OrdersContext.Provider, { value: value, children: children });
+};
+export const useOrdersContext = () => {
+    const context = useContext(OrdersContext);
+    if (context === undefined) {
+        throw new Error('useOrdersContext must be used within an OrdersProvider');
+    }
+    return context;
+};

package/dist/contexts/PricesContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { AssetInfo } from '@silentswap/sdk';
+export type PricesContextType = {
+    prices: Record<string, number | undefined>;
+    getPrice: (asset: AssetInfo | null) => number | undefined;
+    isLoading: (caip19: string) => boolean;
+    refetchPrice: (asset: AssetInfo) => Promise<void>;
+};
+export declare const PricesProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const usePricesContext: () => PricesContextType;

package/dist/contexts/PricesContext.js

@@ -0,0 +1,109 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useCallback, useMemo } from 'react';
+import { usePrices } from '../hooks/usePrices.js';
+const PRICE_STALE_AGE = 10 * 1000; // 10 seconds in milliseconds
+const PricesContext = createContext(undefined);
+export const PricesProvider = ({ children }) => {
+    const { getPrice: fetchPrice } = usePrices();
+    const [priceData, setPriceData] = useState({});
+    const [loadingAssets, setLoadingAssets] = useState(new Set());
+    // Fetch price for an asset and cache it with timestamp
+    const fetchAndCachePrice = useCallback(async (asset) => {
+        const caip19 = asset.caip19;
+        // Skip if already loading
+        if (loadingAssets.has(caip19)) {
+            return;
+        }
+        setLoadingAssets((prev) => new Set(prev).add(caip19));
+        try {
+            const price = await fetchPrice(asset);
+            const now = Date.now();
+            setPriceData((prev) => ({
+                ...prev,
+                [caip19]: {
+                    price,
+                    timestamp: now,
+                },
+            }));
+        }
+        catch (error) {
+            console.warn(`Failed to fetch price for ${caip19}:`, error);
+            const now = Date.now();
+            setPriceData((prev) => ({
+                ...prev,
+                [caip19]: {
+                    price: undefined,
+                    timestamp: now,
+                },
+            }));
+        }
+        finally {
+            setLoadingAssets((prev) => {
+                const next = new Set(prev);
+                next.delete(caip19);
+                return next;
+            });
+        }
+    }, [fetchPrice, loadingAssets]);
+    // Check if price is stale (older than 10 seconds)
+    const isPriceStale = useCallback((caip19) => {
+        const data = priceData[caip19];
+        if (!data)
+            return true;
+        const age = Date.now() - data.timestamp;
+        return age > PRICE_STALE_AGE;
+    }, [priceData]);
+    // Get price from cache or trigger fetch
+    const getPrice = useCallback((asset) => {
+        if (!asset)
+            return undefined;
+        const caip19 = asset.caip19;
+        const data = priceData[caip19];
+        // If no cached data, trigger fetch
+        if (!data) {
+            if (!loadingAssets.has(caip19)) {
+                fetchAndCachePrice(asset);
+            }
+            return undefined;
+        }
+        // If price is stale, trigger refetch in background
+        if (isPriceStale(caip19)) {
+            if (!loadingAssets.has(caip19)) {
+                fetchAndCachePrice(asset);
+            }
+        }
+        // Return cached price (even if stale, to avoid flickering)
+        return data.price;
+    }, [priceData, loadingAssets, fetchAndCachePrice, isPriceStale]);
+    // Check if price is loading
+    const isLoading = useCallback((caip19) => {
+        return loadingAssets.has(caip19);
+    }, [loadingAssets]);
+    // Refetch price for an asset
+    const refetchPrice = useCallback(async (asset) => {
+        await fetchAndCachePrice(asset);
+    }, [fetchAndCachePrice]);
+    // Convert priceData to prices record for backward compatibility
+    const prices = useMemo(() => {
+        const result = {};
+        Object.entries(priceData).forEach(([caip19, data]) => {
+            result[caip19] = data.price;
+        });
+        return result;
+    }, [priceData]);
+    const value = useMemo(() => ({
+        prices,
+        getPrice,
+        isLoading,
+        refetchPrice,
+    }), [prices, getPrice, isLoading, refetchPrice]);
+    return _jsx(PricesContext.Provider, { value: value, children: children });
+};
+export const usePricesContext = () => {
+    const context = useContext(PricesContext);
+    if (context === undefined) {
+        throw new Error('usePricesContext must be used within a PricesProvider');
+    }
+    return context;
+};

package/dist/contexts/SilentSwapContext.d.ts

@@ -0,0 +1,58 @@
+import React from 'react';
+import { type Connector } from 'wagmi';
+import { type WalletClient } from 'viem';
+import { ENVIRONMENT, type SilentSwapClient, type SilentSwapClientConfig, type AuthResponse, type QuoteResponse } from '@silentswap/sdk';
+import { type ExecuteSwapParams, type SwapResult } from '../hooks/silent/useSilentQuote.js';
+import { type OutputStatus } from '../hooks/silent/useOrderTracking.js';
+import { type SolanaWalletConnector, type SolanaConnection } from '../hooks/silent/solana-transaction.js';
+import { type SilentSwapWallet } from '../hooks/silent/useWallet.js';
+export interface SilentSwapContextType {
+    client: SilentSwapClient;
+    environment: ENVIRONMENT;
+    config: SilentSwapClientConfig;
+    wallet: SilentSwapWallet | null;
+    walletLoading: boolean;
+    auth: AuthResponse | null;
+    authLoading: boolean;
+    executeSwap: (params: ExecuteSwapParams) => Promise<SwapResult | null>;
+    swapLoading: boolean;
+    isSwapping: boolean;
+    currentStep?: string;
+    swapError: Error | null;
+    quote: QuoteResponse | null;
+    orderId: string | null;
+    viewingAuth: string | null;
+    clearQuote: () => void;
+    depositAmountUsdc: number;
+    loadingAmounts: boolean;
+    orderProgresses: (number | undefined)[];
+    orderStatusTexts: string[];
+    orderComplete: boolean;
+    orderTrackingError: Error | null;
+    orderOutputs: OutputStatus[];
+    serviceFeeUsd: number;
+    bridgeFeeIngressUsd: number;
+    bridgeFeeEgressUsd: number;
+    slippageUsd: number;
+    serviceFeeRate: number;
+    overheadUsd: number;
+    egressEstimatesLoading: boolean;
+    fetchEstimates: (direction?: 'input-to-output' | 'output-to-input') => Promise<void>;
+    handleNewSwap: () => void;
+    solanaRpcUrl?: string;
+}
+export declare function useSilentSwap(): SilentSwapContextType;
+export declare function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, environment, baseUrl, solanaRpcUrl, walletClient, }: {
+    children: React.ReactNode;
+    client: SilentSwapClient;
+    evmAddress?: string;
+    solAddress?: string;
+    connector?: Connector;
+    isConnected?: boolean;
+    walletClient?: WalletClient;
+    solanaConnector?: SolanaWalletConnector;
+    solanaConnection?: SolanaConnection;
+    environment?: ENVIRONMENT;
+    baseUrl?: string;
+    solanaRpcUrl?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/contexts/SilentSwapContext.js

@@ -0,0 +1,205 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo } from 'react';
+import { useAuth } from '../hooks/silent/useAuth.js';
+import { useWallet } from '../hooks/silent/useWallet.js';
+import { useSilentQuote } from '../hooks/silent/useSilentQuote.js';
+import { useOrderTracking } from '../hooks/silent/useOrderTracking.js';
+import { usePrices } from '../hooks/usePrices.js';
+import { useSwap } from '../hooks/useSwap.js';
+import { useEgressEstimates } from '../hooks/useEgressEstimates.js';
+import { useStatus } from '../hooks/useStatus.js';
+import { useHiddenSwapFees } from '../hooks/useHiddenSwapFees.js';
+import { useSlippageUsd } from '../hooks/useSlippageUsd.js';
+import { useResetSwapForm } from '../hooks/useResetSwapForm.js';
+import { useTransactionAddress } from '../hooks/useTransactionAddress.js';
+import { PricesProvider } from './PricesContext.js';
+import { AssetsProvider } from './AssetsContext.js';
+import { BalancesProvider } from './BalancesContext.js';
+import { OrdersProvider, useOrdersContext, useWalletFacilitatorGroups } from './OrdersContext.js';
+import { ENVIRONMENT, ENVIRONMENT_CONFIGS, } from '@silentswap/sdk';
+const DEFAULT_CONTEXT = {
+    client: {}, // Placeholder
+    environment: ENVIRONMENT.STAGING,
+    config: {
+        environment: ENVIRONMENT.STAGING,
+        baseUrl: ENVIRONMENT_CONFIGS[ENVIRONMENT.STAGING].baseUrl,
+    },
+    wallet: null,
+    walletLoading: false,
+    auth: null,
+    authLoading: false,
+    executeSwap: async () => null,
+    swapLoading: false,
+    isSwapping: false,
+    currentStep: '',
+    swapError: null,
+    quote: null,
+    orderId: null,
+    viewingAuth: null,
+    clearQuote: () => { },
+    depositAmountUsdc: 0,
+    loadingAmounts: false,
+    orderProgresses: [],
+    orderStatusTexts: [],
+    orderComplete: false,
+    orderTrackingError: null,
+    orderOutputs: [],
+    serviceFeeUsd: 0,
+    bridgeFeeIngressUsd: 0,
+    bridgeFeeEgressUsd: 0,
+    slippageUsd: 0,
+    serviceFeeRate: 0,
+    overheadUsd: 0,
+    egressEstimatesLoading: false,
+    fetchEstimates: async (_direction) => { },
+    handleNewSwap: () => { },
+};
+const SilentSwapContext = createContext(DEFAULT_CONTEXT);
+export function useSilentSwap() {
+    const context = useContext(SilentSwapContext);
+    if (!context) {
+        throw new Error('useSilentSwap must be used within a SilentSwapProvider');
+    }
+    return context;
+}
+function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, solanaConnector, solanaConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, }) {
+    // Authentication hook - only for EVM
+    const { auth, isLoading: authLoading } = useAuth({
+        client,
+        address: evmAddress,
+        walletClient: walletClient,
+        autoAuthenticate: true,
+    });
+    // Wallet management hook
+    const { wallet, generateWallet, refreshWallet, isLoading: walletLoading, } = useWallet({
+        client,
+        address: evmAddress,
+        auth: auth || undefined,
+        walletClient: walletClient,
+        connector: connector,
+        allDeposits: true,
+    });
+    const { setFacilitatorGroups } = useOrdersContext();
+    useWalletFacilitatorGroups(wallet, setFacilitatorGroups);
+    const tokenIn = useSwap((state) => state.tokenIn);
+    const inputAmount = useSwap((state) => state.inputAmount);
+    const setInputAmount = useSwap((state) => state.setInputAmount);
+    const destinations = useSwap((state) => state.destinations);
+    const slippage = useSwap((state) => state.slippage);
+    const setDestinations = useSwap((state) => state.setDestinations);
+    const updateDestinationAmount = useSwap((state) => state.updateDestinationAmount);
+    const splits = useSwap((state) => state.splits);
+    const transactionAddress = useTransactionAddress(tokenIn, evmAddress, solAddress);
+    const effectiveQuoteAddress = transactionAddress;
+    const { getPrice } = usePrices();
+    const { serviceFeeRate, overheadUsd } = useStatus();
+    const { fetchEstimates, isLoading: egressEstimatesLoading, egressQuotes: egressQuotesFromEstimates, ingressQuote: ingressQuoteFromEstimates, depositAmountUsd: depositAmountUsdFromEstimates, bridgeProviderFromQuote, usdcPrice: usdcPriceFromEstimates, } = useEgressEstimates({
+        evmAddress,
+        solAddress,
+        quoteAddress: effectiveQuoteAddress,
+        tokenIn,
+        inputAmount,
+        destinations,
+        splits,
+        updateDestinationAmount,
+        serviceFeeRate,
+        overheadUsd,
+        setInputAmount, // Pass setInputAmount for reverse calculation
+    });
+    useEffect(() => {
+        if (auth && walletClient && connector && !wallet && !walletLoading) {
+            generateWallet().catch((err) => {
+                console.error('Failed to generate wallet:', err);
+            });
+        }
+    }, [auth, walletClient, connector, wallet, walletLoading, generateWallet]);
+    const { executeSwap, isLoading: swapLoading, isSwapping, currentStep, error: swapError, quote, orderId, viewingAuth, clearQuote, depositAmountUsdc, loadingAmounts, } = useSilentQuote({
+        client,
+        address: effectiveQuoteAddress,
+        evmAddress: evmAddress,
+        solAddress: solAddress,
+        setDestinations,
+        wallet,
+        walletLoading,
+        walletClient,
+        connector,
+        solanaConnector,
+        solanaConnection,
+        getPrice,
+    });
+    const { handleNewSwap } = useResetSwapForm({
+        clearQuote,
+        isConnected,
+        wallet,
+        setFacilitatorGroups,
+        refreshWallet,
+    });
+    const effectiveDepositAmountUsd = useMemo(() => {
+        return depositAmountUsdFromEstimates > 0 ? depositAmountUsdFromEstimates : depositAmountUsdc;
+    }, [depositAmountUsdFromEstimates, depositAmountUsdc]);
+    const usdcPrice = usdcPriceFromEstimates || 1;
+    const { serviceFeeUsd, bridgeFeeIngressUsd, bridgeFeeEgressUsd } = useHiddenSwapFees({
+        depositAmountUsdc: effectiveDepositAmountUsd,
+        bridgeProvider: bridgeProviderFromQuote,
+        serviceFeeRate,
+        overheadUsd,
+        usdcPrice,
+        bridgeFeeRate: 0.001,
+        ingressQuote: ingressQuoteFromEstimates,
+        egressQuotes: egressQuotesFromEstimates,
+    });
+    const slippageUsd = useSlippageUsd({
+        inputUsdValue: effectiveDepositAmountUsd,
+        slippage,
+        inputAmount,
+        token: tokenIn,
+    });
+    const { progresses: orderProgresses, statusTexts: orderStatusTexts, isComplete: orderComplete, error: orderTrackingError, outputs: orderOutputs, } = useOrderTracking({
+        client,
+        orderId: orderId || undefined,
+        viewingAuth: viewingAuth || undefined,
+    });
+    return _jsx(SilentSwapContext.Provider, { value: {
+            client,
+            environment,
+            config,
+            wallet,
+            walletLoading,
+            auth,
+            authLoading,
+            executeSwap,
+            swapLoading,
+            isSwapping,
+            currentStep,
+            swapError,
+            quote,
+            orderId,
+            viewingAuth,
+            clearQuote,
+            depositAmountUsdc,
+            loadingAmounts,
+            orderProgresses,
+            orderStatusTexts,
+            orderComplete,
+            orderTrackingError,
+            orderOutputs,
+            serviceFeeUsd,
+            bridgeFeeIngressUsd,
+            bridgeFeeEgressUsd,
+            slippageUsd,
+            serviceFeeRate,
+            overheadUsd,
+            egressEstimatesLoading,
+            fetchEstimates,
+            handleNewSwap,
+            solanaRpcUrl,
+        }, children: children });
+}
+export function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, environment = ENVIRONMENT.STAGING, baseUrl, solanaRpcUrl, walletClient, }) {
+    const config = useMemo(() => ({
+        environment,
+        baseUrl: baseUrl ?? ENVIRONMENT_CONFIGS[environment].baseUrl,
+    }), [environment, baseUrl]);
+    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, children: _jsx(OrdersProvider, { children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, children: children }) }) }) }) }));
+}

package/dist/hooks/silent/orderTrackingWebSocketManager.d.ts

@@ -0,0 +1,48 @@
+import type { SilentSwapClient } from '@silentswap/sdk';
+import type { OrderStatus, StatusUpdate } from './useOrderTracking.js';
+/**
+ * Shared WebSocket connection manager for order tracking
+ * Maintains one connection per client/baseUrl and handles multiple order subscriptions
+ */
+declare class OrderTrackingWebSocketManager {
+    private connections;
+    /**
+     * Get connection key from client
+     */
+    private getConnectionKey;
+    /**
+     * Get WebSocket URL from client
+     */
+    private getWebSocketUrl;
+    /**
+     * Get or create connection state
+     */
+    private getConnectionState;
+    /**
+     * Connect WebSocket if not already connected
+     */
+    private connectWebSocket;
+    /**
+     * Schedule reconnection with exponential backoff
+     */
+    private scheduleReconnect;
+    /**
+     * Subscribe to an order
+     */
+    private subscribeOrder;
+    /**
+     * Subscribe to order tracking
+     */
+    subscribe(client: SilentSwapClient | undefined, orderId: string, auth: string, handlers: {
+        onStatusUpdate: (status: OrderStatus) => void;
+        onStatusChange: (update: StatusUpdate) => void;
+        onError: (error: Error) => void;
+        onComplete: () => void;
+    }): () => void;
+    /**
+     * Get connection status
+     */
+    isConnected(client?: SilentSwapClient): boolean;
+}
+export declare const orderTrackingWebSocketManager: OrderTrackingWebSocketManager;
+export {};