@silentswap/react 0.0.78 → 0.0.80

package/dist/hooks/silent/useOrderTracking.js

@@ -1,523 +1,47 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
 /**
- * Output stage enum matching Svelte's OutputStage (string values)
+ * Order tracking via WebSocket — state and connections live in OrdersContext.
+ * This hook subscribes to tracking for (orderId, auth) and returns the state from context.
  */
-export var OutputStage;
-(function (OutputStage) {
-    OutputStage["NONE"] = "NONE";
-    OutputStage["INIT"] = "INIT";
-    OutputStage["FUNDED"] = "FUNDED";
-    OutputStage["REDEEMED"] = "REDEEMED";
-    OutputStage["IBC_SENT"] = "IBC_SENT";
-    OutputStage["IBC_RCVD"] = "IBC_RCVD";
-    OutputStage["BRIDGE_SENT"] = "BRIDGE_SENT";
-    OutputStage["BRIDGE_CFRM"] = "BRIDGE_CFRM";
-    OutputStage["BRIDGE_RCVD"] = "BRIDGE_RCVD";
-    OutputStage["SWAP_USDC_GAS"] = "SWAP_USDC_GAS";
-    OutputStage["SWAP_USDC_TRG"] = "SWAP_USDC_TRG";
-    OutputStage["LTRL_TRG_SENT"] = "LTRL_TRG_SENT";
-    OutputStage["LTRL_TRG_RCVD"] = "LTRL_TRG_RCVD";
-    OutputStage["SWAP_TRG_DST"] = "SWAP_TRG_DST";
-    OutputStage["XFER_TRG_DST"] = "XFER_TRG_DST";
-    OutputStage["REFUND_NATIVE"] = "REFUND_NATIVE";
-    OutputStage["FINALIZED"] = "FINALIZED";
-})(OutputStage || (OutputStage = {}));
-/**
- * Get human-readable status text from output stage
- */
-export function getStatusTextFromStage(stage) {
-    switch (stage) {
-        case OutputStage.NONE:
-            return 'Uncertain state';
-        case OutputStage.INIT:
-            return 'Verifying deposit';
-        case OutputStage.FUNDED:
-            return 'Initializing';
-        case OutputStage.REDEEMED:
-            return 'Anonymizing';
-        case OutputStage.IBC_SENT:
-            return 'Moving';
-        case OutputStage.IBC_RCVD:
-            return 'Staging';
-        case OutputStage.BRIDGE_SENT:
-        case OutputStage.BRIDGE_CFRM:
-        case OutputStage.BRIDGE_RCVD:
-            return 'Bridging';
-        case OutputStage.SWAP_USDC_GAS:
-            return 'Fueling';
-        case OutputStage.SWAP_USDC_TRG:
-            return 'Swapping';
-        case OutputStage.LTRL_TRG_SENT:
-        case OutputStage.LTRL_TRG_RCVD:
-        case OutputStage.SWAP_TRG_DST:
-            return 'Finalizing';
-        case OutputStage.XFER_TRG_DST:
-        case OutputStage.REFUND_NATIVE:
-        case OutputStage.FINALIZED:
-            return 'Complete';
-        default:
-            return 'Processing';
-    }
-}
-/**
- * Get progress value (0-1) from output stage
- */
-export function getProgressFromStage(stage) {
-    switch (stage) {
-        case OutputStage.NONE:
-            return 0;
-        case OutputStage.INIT:
-            return 0;
-        case OutputStage.FUNDED:
-            return 0.1;
-        case OutputStage.REDEEMED:
-            return 0.15;
-        case OutputStage.IBC_SENT:
-            return 0.25;
-        case OutputStage.IBC_RCVD:
-            return 0.35;
-        case OutputStage.BRIDGE_SENT:
-            return 0.5;
-        case OutputStage.BRIDGE_CFRM:
-            return 0.6;
-        case OutputStage.BRIDGE_RCVD:
-            return 0.7;
-        case OutputStage.SWAP_USDC_GAS:
-            return 0.8;
-        case OutputStage.SWAP_USDC_TRG:
-            return 0.9;
-        case OutputStage.LTRL_TRG_SENT:
-        case OutputStage.LTRL_TRG_RCVD:
-        case OutputStage.SWAP_TRG_DST:
-            return 0.95;
-        case OutputStage.XFER_TRG_DST:
-        case OutputStage.REFUND_NATIVE:
-        case OutputStage.FINALIZED:
-            return 1;
-        default:
-            return 0;
-    }
-}
-/**
- * React hook for tracking SilentSwap orders via WebSocket
- */
-export function useOrderTracking({ client, orderId: initialOrderId, viewingAuth: initialAuth, onStatusUpdate, onError, onComplete, } = {}) {
-    const [isConnected, setIsConnected] = useState(false);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [orderStatus, setOrderStatus] = useState(null);
-    const [deposit, setDeposit] = useState(null);
-    const [outputs, setOutputs] = useState([]);
-    const [progresses, setProgresses] = useState([undefined]);
-    const [statusTexts, setStatusTexts] = useState(['Connecting']);
-    const [completedTimestamp, setCompletedTimestamp] = useState(null);
-    const [isComplete, setIsComplete] = useState(false);
-    const wsRef = useRef(null);
-    const orderIdRef = useRef(initialOrderId);
-    const authRef = useRef(initialAuth);
-    const requestCounterRef = useRef(0);
-    const responseHandlersRef = useRef(new Map());
-    const reconnectTimeoutRef = useRef(null);
-    const lastReceivedRef = useRef(0);
-    const isReconnectingRef = useRef(false);
-    const reconnectAttemptsRef = useRef(0);
-    const maxReconnectAttempts = 5; // Maximum number of reconnection attempts
-    const reconnectDelayRef = useRef(1000); // Initial delay in ms, will increase exponentially
-    // Track the last connected orderId/auth to prevent unnecessary reconnections
-    // These are used in both the auto-connect useEffect and the onclose handler
-    const lastConnectedOrderIdRef = useRef(undefined);
-    const lastConnectedAuthRef = useRef(undefined);
-    // Update output state when status changes
-    const updateOutput = useCallback((index, stage, timestamp = Date.now(), asset) => {
-        const progress = getProgressFromStage(stage);
-        const status = getStatusTextFromStage(stage);
-        setProgresses((prev) => {
-            const newProgresses = [...prev];
-            newProgresses[index] = progress;
-            return newProgresses;
-        });
-        setStatusTexts((prev) => {
-            const newTexts = [...prev];
-            newTexts[index] = status;
-            return newTexts;
-        });
-        setOutputs((prev) => {
-            const newOutputs = [...prev];
-            newOutputs[index] = {
-                ...newOutputs[index],
-                index,
-                stage,
-                timestamp,
-                ...(asset ? { asset } : {}),
-                // Preserve recipient if it exists
-                ...(prev[index]?.recipient ? { recipient: prev[index].recipient } : {}),
-            };
-            return newOutputs;
-        });
-        // Check if all outputs are complete
-        setProgresses((currentProgresses) => {
-            if (currentProgresses.every((p) => (p ?? 0) >= 1)) {
-                setIsComplete(true);
-                setCompletedTimestamp(timestamp);
-                onComplete?.();
-            }
-            return currentProgresses;
-        });
-    }, [onComplete]);
-    // Submit JSON-RPC request
-    const submitRequest = useCallback((method, params, handler) => {
-        const ws = wsRef.current;
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
-            console.warn('WebSocket not connected, cannot send request');
-            return -1;
-        }
-        const requestId = requestCounterRef.current++;
-        const request = {
-            jsonrpc: '2.0',
-            id: requestId,
-            method,
-            params,
-        };
-        if (handler) {
-            responseHandlersRef.current.set(requestId, handler);
-        }
-        ws.send(JSON.stringify(request));
-        return requestId;
-    }, []);
-    // Connect to WebSocket using JSON-RPC protocol (matching Svelte implementation)
-    const connect = useCallback((orderId, auth) => {
-        orderIdRef.current = orderId;
-        authRef.current = auth;
-        setIsLoading(true);
-        setError(null);
-        isReconnectingRef.current = false;
-        // Clear any existing reconnection timeout
-        if (reconnectTimeoutRef.current) {
-            clearTimeout(reconnectTimeoutRef.current);
-            reconnectTimeoutRef.current = null;
-        }
-        // Close existing connection
-        if (wsRef.current) {
-            wsRef.current.close();
-            wsRef.current = null;
-        }
-        // Clear response handlers
-        responseHandlersRef.current.clear();
-        requestCounterRef.current = 0;
-        // Reset reconnection attempts and delay for new connection
-        reconnectAttemptsRef.current = 0;
-        reconnectDelayRef.current = 1000;
-        // Get WebSocket URL (matching Svelte implementation)
-        // Use env var if available, otherwise use client baseUrl, otherwise construct from location
-        // IMPORTANT: URL should be just /websocket with NO path or query params
-        // Auth is sent via JSON-RPC connect method, not in URL
-        let wsUrl;
-        if (typeof window !== 'undefined' && window.__WEBSOCKET_URL__) {
-            // WebSocket URL from window (for runtime override)
-            wsUrl = window.__WEBSOCKET_URL__;
-        }
-        else if (client) {
-            // Use client baseUrl (convert http/https to ws/wss)
-            const baseUrl = client.baseUrl;
-            try {
-                const url = new URL(baseUrl);
-                const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-                wsUrl = `${protocol}//${url.host}/websocket`;
-            }
-            catch {
-                // If URL parsing fails, try simple string replacement
-                wsUrl = baseUrl.replace(/^https?:\/\//, 'wss://').replace(/^http:\/\//, 'ws://') + '/websocket';
-            }
-        }
-        else if (typeof window !== 'undefined') {
-            // Construct from current location
-            wsUrl = `${window.location.protocol === 'https:' ? 'wss' : 'ws'}://${window.location.host}/websocket`;
-        }
-        else {
-            wsUrl = 'ws://localhost/websocket';
-        }
-        // Ensure URL doesn't have any path or query params (just /websocket)
-        // This is critical: the WebSocket URL must be exactly: wss://domain/websocket (no params)
-        try {
-            const url = new URL(wsUrl);
-            // Force protocol to ws/wss (remove any existing path/query)
-            const protocol = url.protocol === 'https:' || url.protocol === 'wss:' ? 'wss:' : 'ws:';
-            // Reconstruct URL with only host and /websocket path
-            wsUrl = `${protocol}//${url.host}/websocket`;
-        }
-        catch {
-            // If URL parsing fails, try to clean it manually
-            // Remove any query params, hash, or extra paths
-            wsUrl = wsUrl.split('?')[0].split('#')[0].replace(/\/+$/, '') + '/websocket';
-        }
-        try {
-            const ws = new WebSocket(wsUrl);
-            wsRef.current = ws;
-            ws.onopen = () => {
-                lastReceivedRef.current = Date.now();
-                setIsConnected(true);
-                setIsLoading(false);
-                isReconnectingRef.current = false;
-                // Reset reconnection attempts on successful connection
-                reconnectAttemptsRef.current = 0;
-                reconnectDelayRef.current = 1000;
-                // Send connect JSON-RPC request (matching Svelte)
-                const connectRequestId = submitRequest('connect', {
-                    auth: {
-                        orderId,
-                        viewingAuth: auth,
-                    },
-                }, (error, result) => {
-                    if (error) {
-                        const err = new Error(error.message || 'Connection error');
-                        setError(err);
-                        setIsLoading(false);
-                        onError?.(err);
-                        return;
-                    }
-                    // Handle connected response
-                    const status = result;
-                    setOrderStatus(status);
-                    if (status.deposit) {
-                        setDeposit({
-                            amount: status.deposit.amount,
-                            timestamp: status.deposit.timestamp,
-                            duration: status.deposit.duration,
-                            orderId: status.deposit.orderId,
-                            tx: status.deposit.tx,
-                        });
-                    }
-                    // Initialize outputs
-                    const numOutputs = status.outputs?.length ?? 1;
-                    setProgresses(new Array(numOutputs).fill(undefined));
-                    setStatusTexts(new Array(numOutputs).fill('Connecting'));
-                    // Process initial output statuses
-                    status.outputs?.forEach((output, index) => {
-                        // Set output with recipient information (matching Svelte)
-                        setOutputs((prev) => {
-                            const newOutputs = [...prev];
-                            newOutputs[index] = {
-                                index,
-                                stage: output.stage,
-                                timestamp: output.timestamp,
-                                recipient: output.recipient,
-                                asset: output.output,
-                                txs: output.txs,
-                            };
-                            return newOutputs;
-                        });
-                        // Update progress and status
-                        updateOutput(index, output.stage, output.timestamp, output.output);
-                    });
-                    // Register status handler for subsequent updates (matching Svelte pattern)
-                    // Status updates come as responses to the same request ID
-                    if (connectRequestId >= 0) {
-                        responseHandlersRef.current.set(connectRequestId, (statusError, statusResult) => {
-                            if (statusError) {
-                                const err = new Error(statusError.message || 'Status error');
-                                setError(err);
-                                onError?.(err);
-                                return;
-                            }
-                            // Handle status update
-                            const update = statusResult;
-                            handleStatusUpdate(update);
-                        });
-                    }
-                    onStatusUpdate?.(status);
-                });
-            };
-            ws.onmessage = (event) => {
-                lastReceivedRef.current = Date.now();
-                try {
-                    const response = JSON.parse(event.data);
-                    // Validate JSON-RPC response
-                    if (response.jsonrpc !== '2.0' || typeof response.id !== 'number') {
-                        return;
-                    }
-                    // Get handler(s) for this request ID (matching Svelte pattern)
-                    // Status updates come as multiple responses to the same request ID
-                    // So we DON'T delete the handler - it stays registered for subsequent updates
-                    const handler = responseHandlersRef.current.get(response.id);
-                    if (handler) {
-                        // Call handler but DON'T delete it - status updates reuse the same request ID
-                        handler(response.error, response.result);
-                    }
-                }
-                catch (parseError) {
-                    console.warn('Failed to parse WebSocket message:', parseError);
-                }
-            };
-            ws.onerror = (event) => {
-                const err = new Error('WebSocket connection error');
-                setError(err);
-                setIsLoading(false);
-                // Don't call onError here to prevent infinite error logging
-                // The error will be handled by onclose reconnection logic
-            };
-            ws.onclose = async () => {
-                setIsConnected(false);
-                responseHandlersRef.current.clear();
-                // Automatic reconnection with retry limit and exponential backoff
-                // Only reconnect if we still have valid orderId/auth and we're not already reconnecting
-                // Also check that the orderId/auth matches what we're supposed to be tracking
-                if (orderIdRef.current &&
-                    authRef.current &&
-                    !isReconnectingRef.current &&
-                    orderIdRef.current === lastConnectedOrderIdRef.current &&
-                    authRef.current === lastConnectedAuthRef.current) {
-                    // Check if we've exceeded max reconnection attempts
-                    if (reconnectAttemptsRef.current >= maxReconnectAttempts) {
-                        const err = new Error(`WebSocket connection failed after ${maxReconnectAttempts} attempts`);
-                        setError(err);
-                        setIsLoading(false);
-                        onError?.(err);
-                        // Reset attempts after a longer delay (30 seconds) to allow retry later
-                        reconnectTimeoutRef.current = setTimeout(() => {
-                            reconnectAttemptsRef.current = 0;
-                            reconnectDelayRef.current = 1000;
-                        }, 30000);
-                        return;
-                    }
-                    isReconnectingRef.current = true;
-                    reconnectAttemptsRef.current += 1;
-                    // Exponential backoff: delay increases with each attempt (1s, 2s, 4s, 8s, 16s)
-                    const currentDelay = reconnectDelayRef.current;
-                    reconnectDelayRef.current = Math.min(currentDelay * 2, 30000); // Cap at 30 seconds
-                    // If last received was a while ago, add extra delay
-                    const timeSinceLastReceived = Date.now() - lastReceivedRef.current;
-                    const extraDelay = timeSinceLastReceived > 90000 ? 5000 : 0;
-                    const totalDelay = currentDelay + extraDelay;
-                    reconnectTimeoutRef.current = setTimeout(() => {
-                        // Double-check that orderId/auth still match before reconnecting
-                        if (orderIdRef.current &&
-                            authRef.current &&
-                            orderIdRef.current === lastConnectedOrderIdRef.current &&
-                            authRef.current === lastConnectedAuthRef.current) {
-                            isReconnectingRef.current = false; // Reset before connecting
-                            connect(orderIdRef.current, authRef.current);
-                        }
-                        else {
-                            // Order changed, don't reconnect
-                            isReconnectingRef.current = false;
-                            reconnectAttemptsRef.current = 0;
-                            reconnectDelayRef.current = 1000;
-                        }
-                    }, totalDelay);
-                }
-            };
-        }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error('Failed to connect to order tracking');
-            setError(error);
-            setIsLoading(false);
-            onError?.(error);
-        }
-    }, [submitRequest, updateOutput, onStatusUpdate, onError]);
-    // Handle status updates
-    const handleStatusUpdate = useCallback((update) => {
-        switch (update.type) {
-            case 'deposit': {
-                setDeposit({
-                    amount: update.data.amount,
-                    timestamp: update.data.timestamp,
-                    duration: update.data.duration,
-                    orderId: update.data.orderId,
-                    tx: update.data.tx,
-                });
-                break;
-            }
-            case 'stage': {
-                updateOutput(update.data.index, update.data.stage, update.data.timestamp, update.data.asset);
-                break;
-            }
-            case 'transaction': {
-                setOutputs((prev) => {
-                    const newOutputs = [...prev];
-                    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,
-                                },
-                            },
-                        };
-                    }
-                    return newOutputs;
-                });
-                break;
-            }
-            case 'error': {
-                const err = new Error(update.data.message || 'Order tracking error');
-                setError(err);
-                onError?.(err);
-                break;
-            }
-        }
-    }, [updateOutput, onError]);
-    // Disconnect from WebSocket
-    const disconnect = useCallback(() => {
-        // Clear reconnection timeout
-        if (reconnectTimeoutRef.current) {
-            clearTimeout(reconnectTimeoutRef.current);
-            reconnectTimeoutRef.current = null;
-        }
-        isReconnectingRef.current = true; // Prevent reconnection
-        orderIdRef.current = undefined;
-        authRef.current = undefined;
-        if (wsRef.current) {
-            wsRef.current.close();
-            wsRef.current = null;
-        }
-        responseHandlersRef.current.clear();
-        setIsConnected(false);
-    }, []);
-    // Auto-connect if orderId and auth are provided
+import { useEffect, useMemo } from 'react';
+import { useOrdersContext } from '../../contexts/OrdersContext.js';
+import { getOrderTrackingCacheKey, getStatusTextFromStage, getProgressFromStage, DEFAULT_ORDER_TRACKING_STATE, } from '../../contexts/orderTrackingTypes.js';
+// Re-export types and helpers for consumers
+export { OutputStage, getStatusTextFromStage, getProgressFromStage, getOrderTrackingCacheKey, } from '../../contexts/orderTrackingTypes.js';
+export function useOrderTracking({ client, orderId: initialOrderId, viewingAuth: initialAuth, onStatusUpdate, onError, onComplete, fetchAssetPrice, } = {}) {
+    const ctx = useOrdersContext();
+    const stableState = useMemo(() => {
+        const key = initialOrderId && initialAuth
+            ? getOrderTrackingCacheKey(initialOrderId, initialAuth)
+            : '';
+        const state = key ? ctx.getOrderTrackingState(initialOrderId, initialAuth) : null;
+        return state ?? DEFAULT_ORDER_TRACKING_STATE;
+    }, [initialOrderId, initialAuth, ctx]);
+    const options = useMemo(() => ({
+        client,
+        onStatusUpdate,
+        onError,
+        onComplete,
+        fetchAssetPrice,
+    }), [client, onStatusUpdate, onError, onComplete, fetchAssetPrice]);
+    const { connectOrderTracking, disconnectOrderTracking } = ctx;
     useEffect(() => {
-        // Only connect if orderId/auth changed or if not yet connected
-        // Also check if we're already connected to the same orderId/auth to prevent reconnection
-        const shouldConnect = initialOrderId &&
-            initialAuth &&
-            client &&
-            (lastConnectedOrderIdRef.current !== initialOrderId || lastConnectedAuthRef.current !== initialAuth) &&
-            !isReconnectingRef.current &&
-            (!wsRef.current || wsRef.current.readyState === WebSocket.CLOSED);
-        if (shouldConnect) {
-            lastConnectedOrderIdRef.current = initialOrderId;
-            lastConnectedAuthRef.current = initialAuth;
-            connect(initialOrderId, initialAuth);
-        }
+        if (!initialOrderId || !initialAuth || !client)
+            return;
+        connectOrderTracking(initialOrderId, initialAuth, options);
         return () => {
-            // Only disconnect if we're actually disconnecting (orderId/auth cleared)
-            if (!initialOrderId || !initialAuth) {
-                lastConnectedOrderIdRef.current = undefined;
-                lastConnectedAuthRef.current = undefined;
-                disconnect();
-            }
+            disconnectOrderTracking(initialOrderId, initialAuth);
         };
-        // Only depend on initialOrderId, initialAuth, and client
-        // Don't include connect/disconnect to prevent infinite loops
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [initialOrderId, initialAuth, client]);
+    }, [initialOrderId, initialAuth, client, options, connectOrderTracking, disconnectOrderTracking]);
     return {
-        // State
-        isConnected,
-        isLoading,
-        error,
-        orderStatus,
-        deposit,
-        outputs,
-        progresses,
-        statusTexts,
-        completedTimestamp,
-        isComplete,
-        // Methods
-        connect,
-        disconnect,
+        ...stableState,
+        connect: (orderId, auth) => {
+            ctx.connectOrderTracking(orderId, auth, options);
+        },
+        disconnect: () => {
+            if (initialOrderId && initialAuth) {
+                ctx.disconnectOrderTracking(initialOrderId, initialAuth);
+            }
+        },
         getStatusText: getStatusTextFromStage,
         getProgress: getProgressFromStage,
     };

package/dist/hooks/silent/useSilentQuote.js

@@ -290,7 +290,8 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
                 const result = await executeEvmSwap(sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, // Use amount from solveOptimalUsdcAmount (matches Svelte)
                 providerForSwap, orderResponse, evmSignerAddress, // Use EVM signer address, not normalizedAddress
                 viewingAuth, executeEvmBridge, senderContactId, // Pass sender contact ID to extract sender address
-                integratorId);
+                integratorId, // Pass integratorId
+                effectiveAllowanceTarget);
                 setOrderId(result.orderId);
                 setViewingAuth(result.viewingAuth);
                 return result;
@@ -504,7 +505,8 @@ viewingAuth, createOrder, executeBitcoinBridge, facilitatorGroup, integratorId)
  */
 async function executeEvmSwap(sourceAsset, sourceAmount, usdcAmount, provider, orderResponse, evmSignerAddress, // EVM signer address (matches Svelte's s0x_signer)
 viewingAuth, executeEvmBridge, senderContactId, // Sender contact ID to extract sender address
-integratorId) {
+integratorId, // Optional integrator ID
+allowanceTarget) {
     // Parse source asset to get chain ID and token address
     const sourceEvmParsed = parseEvmCaip19(sourceAsset);
     if (!sourceEvmParsed) {
@@ -531,7 +533,7 @@ integratorId) {
     const bridgeResult = await executeEvmBridge(sourceChainId, sourceTokenAddress, sourceAmount, usdcAmount, // Use amount from solveOptimalUsdcAmount (matches Svelte)
     depositParams, evmSignerAddress, // Use EVM signer address for deposit calldata
     evmSenderAddress, // Use EVM sender address for bridge quotes
-    provider);
+    provider, allowanceTarget);
     const resultOrderId = orderResponse.response.orderId;
     // Note: setOrderId is not available in this function scope,
     // but the orderId will be set by the calling executeSwap function

package/dist/hooks/usePlatformHealth.js

@@ -3,6 +3,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React, { createContext, useContext, useEffect, useMemo, useCallback } from 'react';
 import { useStatus } from '../hooks/useStatus.js';
 import { BigNumber } from 'bignumber.js';
+const MAX_DEPOSIT_USD = 25000;
 const PlatformHealthContext = createContext(undefined);
 /**
  * Provider that monitors platform health from status API and provides validation functions
@@ -103,12 +104,12 @@ export function PlatformHealthProvider({ children, proId, onFormDisabledChange,
             return { valid: false, error: 'Amount must be greater than zero' };
         }
         const minUsd = getMinimumDepositUsd();
-        const maxUsd = getMaximumDepositUsd();
+        const maxUsd = Math.min(MAX_DEPOSIT_USD, getMaximumDepositUsd() ?? MAX_DEPOSIT_USD);
         if (minUsd !== null && amount < minUsd) {
-            return { valid: false, error: `Minimum deposit is $${minUsd.toFixed(2)}` };
+            return { valid: false, error: `Minimum value is $${minUsd.toFixed(2)}` };
         }
         if (maxUsd !== null && amount > maxUsd) {
-            return { valid: false, error: `Maximum deposit is $${maxUsd.toFixed(2)}` };
+            return { valid: false, error: `Maximum value is $${maxUsd.toFixed(2)}` };
         }
         return { valid: true };
     }, [getMinimumDepositUsd, getMaximumDepositUsd]);

package/dist/index.d.ts

@@ -1,19 +1,21 @@
 export { useSilentClient } from './hooks/silent/useSilentClient.js';
 export { PricesProvider, usePricesContext } from './contexts/PricesContext.js';
 export type { PricesContextType } from './contexts/PricesContext.js';
+export { SwapFormEstimatesProvider, useSwapFormEstimatesContext, } from './contexts/SwapFormEstimatesContext.js';
+export type { SwapFormEstimatesContextType, SwapFormEstimatesProviderProps, } from './contexts/SwapFormEstimatesContext.js';
 export { AssetsProvider, useAssetsContext } from './contexts/AssetsContext.js';
 export type { AssetsContextType, Chain, ChainInfo } from './contexts/AssetsContext.js';
 export { BalancesProvider, useBalancesContext } from './contexts/BalancesContext.js';
 export type { BalancesContextType, UserBalance } from './contexts/BalancesContext.js';
 export { OrdersProvider, useOrdersContext, useWalletFacilitatorGroups } from './contexts/OrdersContext.js';
-export type { OrdersContextOrderMetadata, OrdersContextOrder, FacilitatorGroup, OrdersContextType } from './contexts/OrdersContext.js';
+export type { OrdersContextOrderMetadata, OrdersContextOrder, OrderDestination, FacilitatorGroup, OrdersContextType } from './contexts/OrdersContext.js';
 export { SilentSwapProvider, useSilentSwap } from './contexts/SilentSwapContext.js';
 export type { SilentSwapContextType } from './contexts/SilentSwapContext.js';
 export { useSilentOrders } from './hooks/silent/useSilentOrders.js';
 export { useAuth } from './hooks/silent/useAuth.js';
 export { useWallet } from './hooks/silent/useWallet.js';
 export { useSilentQuote } from './hooks/silent/useSilentQuote.js';
-export { useOrderTracking, OutputStage, getStatusTextFromStage, getProgressFromStage, } from './hooks/silent/useOrderTracking.js';
+export { useOrderTracking, OutputStage, getStatusTextFromStage, getProgressFromStage, getOrderTrackingCacheKey, } from './hooks/silent/useOrderTracking.js';
 export { useRefund } from './hooks/silent/useRefund.js';
 export { useTransaction } from './hooks/useTransaction.js';
 export { useQuote } from './hooks/useQuote.js';
@@ -52,9 +54,10 @@ export type { useTransactionOptions, useTransactionReturn } from './hooks/useTra
 export type { useQuoteOptions, useQuoteReturn } from './hooks/useQuote.js';
 export type { OrderEstimateResult, UseOrderEstimatesOptions } from './hooks/useOrderEstimates.js';
 export type { usePricesOptions, usePricesReturn, CachedPrice } from './hooks/usePrices.js';
-export type { UseOrderTrackingOptions, UseOrderTrackingReturn, OrderDeposit, OutputStatus, OrderStatus, StatusUpdate, } from './hooks/silent/useOrderTracking.js';
+export type { UseOrderTrackingOptions, UseOrderTrackingReturn, OrderDeposit, OutputStatus, OrderStatus, StatusUpdate, OrderTrackingState, OrderTrackingOptions, } from './hooks/silent/useOrderTracking.js';
 export type { UseRefundOptions, UseRefundReturn } from './hooks/silent/useRefund.js';
 export { createSolanaTransactionExecutor, convertRelaySolanaStepToTransaction, } from './hooks/silent/solana-transaction.js';
 export type { SolanaWalletConnector, SolanaConnection } from './hooks/silent/solana-transaction.js';
 export { createBitcoinTransactionExecutor, convertRelayBitcoinStepToTransaction, } from './hooks/silent/bitcoin-transaction.js';
 export type { BitcoinWalletConnector, BitcoinConnection } from './hooks/silent/bitcoin-transaction.js';
+export type { Outputs, IOutput } from './contexts/orderTrackingTypes.js';