@silentswap/react 0.0.86 → 0.0.88

package/dist/contexts/SilentSwapContext.d.ts

@@ -1,12 +1,43 @@
 import React from 'react';
 import { type Connector } from 'wagmi';
 import { type WalletClient } from 'viem';
+import type { PlatformHealthStatus } from '../hooks/usePlatformHealth.js';
 import { ENVIRONMENT, type SilentSwapClient, type SilentSwapClientConfig, type AuthResponse, type QuoteResponse, type CalculationDirection } 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 BitcoinWalletConnector, type BitcoinConnection } from '../hooks/silent/bitcoin-transaction.js';
 import { type SilentSwapWallet } from '../hooks/silent/useWallet.js';
+export interface SilentSwapStatusData {
+    platformHealth: PlatformHealthStatus | undefined;
+    serviceFeeRate: number;
+    overheadUsd: number;
+    minimumDepositUusdc: string | undefined;
+    maximumDepositUusdc: string | undefined;
+    outputLimit: number | undefined;
+    identity: string | undefined;
+    volume: number | undefined;
+    liquidity: number | undefined;
+    storage: Record<string, string> | undefined;
+    isLoading: boolean;
+}
+export interface SilentSwapFees {
+    serviceFeeUsd: number;
+    bridgeFeeIngressUsd: number;
+    bridgeFeeEgressUsd: number;
+    slippageUsd: number;
+}
+export interface SilentSwapOrderTracking {
+    progresses: (number | undefined)[];
+    statusTexts: string[];
+    isComplete: boolean;
+    error: Error | null;
+    outputs: OutputStatus[];
+}
+export interface SilentSwapEstimates {
+    isLoading: boolean;
+    fetchEstimates: (direction?: CalculationDirection) => Promise<void>;
+}
 export interface SilentSwapContextType {
     client: SilentSwapClient;
     environment: ENVIRONMENT;
@@ -26,19 +57,10 @@ export interface SilentSwapContextType {
     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?: CalculationDirection) => Promise<void>;
+    status: SilentSwapStatusData;
+    fees: SilentSwapFees;
+    order: SilentSwapOrderTracking;
+    estimates: SilentSwapEstimates;
     handleNewSwap: () => void;
     solanaRpcUrl?: string;
 }

package/dist/contexts/SilentSwapContext.js

@@ -40,19 +40,36 @@ const DEFAULT_CONTEXT = {
     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) => { },
+    status: {
+        platformHealth: undefined,
+        serviceFeeRate: 0,
+        overheadUsd: 0,
+        minimumDepositUusdc: undefined,
+        maximumDepositUusdc: undefined,
+        outputLimit: undefined,
+        identity: undefined,
+        volume: undefined,
+        liquidity: undefined,
+        storage: undefined,
+        isLoading: true,
+    },
+    fees: {
+        serviceFeeUsd: 0,
+        bridgeFeeIngressUsd: 0,
+        bridgeFeeEgressUsd: 0,
+        slippageUsd: 0,
+    },
+    order: {
+        progresses: [],
+        statusTexts: [],
+        isComplete: false,
+        error: null,
+        outputs: [],
+    },
+    estimates: {
+        isLoading: false,
+        fetchEstimates: async (_direction) => { },
+    },
     handleNewSwap: () => { },
 };
 const SilentSwapContext = createContext(DEFAULT_CONTEXT);
@@ -93,7 +110,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
     const transactionAddress = useTransactionAddress(tokenIn, evmAddress, solAddress, bitcoinAddress);
     const effectiveQuoteAddress = transactionAddress;
     const { getPrice } = usePrices();
-    const { serviceFeeRate, overheadUsd } = useStatus();
+    const { serviceFeeRate, overheadUsd, platformHealth: statusPlatformHealth, minimumDepositUusdc, maximumDepositUusdc, outputLimit, identity, volume, liquidity, storage, isLoading: statusLoading, } = useStatus(proId ? { proId } : undefined);
     const { fetchEstimates, isLoading: egressEstimatesLoading, egressQuotes: egressQuotesFromEstimates, ingressQuote: ingressQuoteFromEstimates, depositAmountUsd: depositAmountUsdFromEstimates, bridgeProviderFromQuote, usdcPrice: usdcPriceFromEstimates, } = useEgressEstimates({
         evmAddress,
         solAddress,
@@ -206,19 +223,36 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
             clearQuote,
             depositAmountUsdc,
             loadingAmounts,
-            orderProgresses,
-            orderStatusTexts,
-            orderComplete,
-            orderTrackingError,
-            orderOutputs,
-            serviceFeeUsd: effectiveServiceFeeUsd,
-            bridgeFeeIngressUsd: effectiveBridgeFeeIngressUsd,
-            bridgeFeeEgressUsd: effectiveBridgeFeeEgressUsd,
-            slippageUsd,
-            serviceFeeRate,
-            overheadUsd,
-            egressEstimatesLoading,
-            fetchEstimates,
+            status: {
+                platformHealth: statusPlatformHealth,
+                serviceFeeRate,
+                overheadUsd,
+                minimumDepositUusdc,
+                maximumDepositUusdc,
+                outputLimit,
+                identity,
+                volume,
+                liquidity,
+                storage,
+                isLoading: statusLoading,
+            },
+            fees: {
+                serviceFeeUsd: effectiveServiceFeeUsd,
+                bridgeFeeIngressUsd: effectiveBridgeFeeIngressUsd,
+                bridgeFeeEgressUsd: effectiveBridgeFeeEgressUsd,
+                slippageUsd,
+            },
+            order: {
+                progresses: orderProgresses,
+                statusTexts: orderStatusTexts,
+                isComplete: orderComplete,
+                error: orderTrackingError,
+                outputs: orderOutputs,
+            },
+            estimates: {
+                isLoading: egressEstimatesLoading,
+                fetchEstimates,
+            },
             handleNewSwap,
             solanaRpcUrl,
         }, children: children });

package/dist/contexts/SwapFormEstimatesContext.js

@@ -6,6 +6,10 @@ import { usePlatformHealthContext } from '../hooks/usePlatformHealth.js';
 import { usePricesContext } from './PricesContext.js';
 import { getAssetByCaip19, CALCULATION_DIRECTION_INPUT_TO_OUTPUT, CALCULATION_DIRECTION_OUTPUT_TO_INPUT, } from '@silentswap/sdk';
 const XT_DELAY_DEBOUNCE_QUOTE = 550;
+// After a reverse (output-to-input) calculation completes, ignore re-trigger attempts
+// for this duration. Bridge quotes aren't perfectly deterministic, so the calculated
+// input oscillates slightly each cycle — the cooldown prevents infinite loops.
+const REVERSE_CALC_SETTLE_MS = 2000;
 const SwapFormEstimatesContext = createContext(undefined);
 export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, serviceFeeRate: serviceFeeRateOverride, }) {
     const setSplits = useSwap((state) => state.setSplits);
@@ -24,6 +28,7 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
     const programmaticInputChangeRef = useRef(false);
     const shouldFetchAfterInputRecalcRef = useRef(false);
     const isFetchingEstimatesRef = useRef(false);
+    const reverseCalcTimestampRef = useRef(0);
     const [calculationDirection, setCalculationDirection] = React.useState(CALCULATION_DIRECTION_INPUT_TO_OUTPUT);
     const calculationDirectionRef = useRef(CALCULATION_DIRECTION_INPUT_TO_OUTPUT);
     // Refs for destination amount calculation (from useDestinationAmountCalculation)
@@ -37,6 +42,14 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
         if (isDraggingSlider) {
             return;
         }
+        console.log('[SwapFormEstimates] scheduleFetchEstimates called', {
+            immediate,
+            direction,
+            effectiveDirection: direction || calculationDirectionRef.current || CALCULATION_DIRECTION_INPUT_TO_OUTPUT,
+            isFetching: isFetchingEstimatesRef.current,
+            cooldownMs: Date.now() - reverseCalcTimestampRef.current,
+            caller: new Error().stack?.split('\n')[2]?.trim(),
+        });
         if (debounceTimerRef.current) {
             clearTimeout(debounceTimerRef.current);
             debounceTimerRef.current = null;
@@ -47,6 +60,12 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
             calculationDirectionRef.current = effectiveDirection;
             setCalculationDirection(effectiveDirection);
         }
+        // Set the cooldown timestamp at the START of a reverse calc (not just in .finally())
+        // so that effects firing DURING the fetch (e.g. ref-change effect triggered by
+        // SilentSwapAppProvider re-renders) are already within the cooldown window.
+        if (effectiveDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT) {
+            reverseCalcTimestampRef.current = Date.now();
+        }
         isFetchingEstimatesRef.current = true;
         const fetchPromise = immediate
             ? fetchEstimatesRef.current(effectiveDirection)
@@ -67,6 +86,13 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
             console.error('Failed to fetch estimates:', err);
         })
             .finally(() => {
+            // When a reverse (output-to-input) calculation completes, it updates inputAmount
+            // programmatically. Record the timestamp so ALL re-trigger paths (initial-fetch
+            // effect AND ref-change effect) will skip during the cooldown window. This prevents
+            // infinite loops caused by non-deterministic bridge quotes oscillating slightly.
+            if (effectiveDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT) {
+                reverseCalcTimestampRef.current = Date.now();
+            }
             isFetchingEstimatesRef.current = false;
         });
     }, [isDraggingSlider]);
@@ -77,8 +103,25 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
     React.useEffect(() => {
         const prev = fetchEstimatesRef.current;
         fetchEstimatesRef.current = fetchEstimates;
-        // When fetchEstimates changes and we had already fetched, re-trigger
+        // When fetchEstimates changes and we had already fetched, re-trigger —
+        // but NOT if we're currently fetching (avoids scheduling a duplicate) or
+        // if a reverse calc is in progress / recently completed (SilentSwapAppProvider
+        // re-renders frequently during fetches, giving fetchEstimates a new identity).
         if (prev !== fetchEstimates && lastFetchedKeyRef.current) {
+            const cooldownMs = Date.now() - reverseCalcTimestampRef.current;
+            if (isFetchingEstimatesRef.current ||
+                cooldownMs < REVERSE_CALC_SETTLE_MS) {
+                console.log('[SwapFormEstimates] ref-change effect SKIPPED (loop guard)', {
+                    isFetching: isFetchingEstimatesRef.current,
+                    cooldownMs,
+                    direction: calculationDirectionRef.current,
+                });
+                return;
+            }
+            console.log('[SwapFormEstimates] ref-change effect TRIGGERING fetch', {
+                cooldownMs,
+                direction: calculationDirectionRef.current,
+            });
             lastFetchedKeyRef.current = null;
             scheduleFetchEstimates(true);
         }
@@ -220,10 +263,12 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
     }, [tokenIn, setSplits, setInputAmount, getPrice, getServiceFeeRate]);
     // Handle slider change (splits changed)
     const handleSliderChange = useCallback(() => {
+        reverseCalcTimestampRef.current = 0;
         scheduleFetchEstimates();
     }, [scheduleFetchEstimates]);
     // Handle destination amount change (user manually edited)
     const handleDestinationAmountChange = useCallback(() => {
+        reverseCalcTimestampRef.current = 0;
         // Mark that this is a manual destination change
         // This prevents performDestinationAmountCalculation from overwriting user's changes
         isManualDestinationChangeRef.current = true;
@@ -240,6 +285,7 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
     }, [recalculateSplitsFromAmounts, scheduleFetchEstimates]);
     // Handle input amount change (user manually edited)
     const handleInputAmountChange = useCallback(() => {
+        reverseCalcTimestampRef.current = 0;
         // Mark as user-initiated change (not programmatic)
         programmaticInputChangeRef.current = false;
         shouldFetchAfterInputRecalcRef.current = false;
@@ -345,6 +391,14 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
         if (programmaticInputChangeRef.current) {
             return;
         }
+        // Skip recalculation during the reverse-calc cooldown window.
+        // A reverse calc just set inputAmount programmatically — recalculating
+        // destination amounts from this input would overwrite the user's desired
+        // output values and could feed back into another reverse cycle.
+        if (Date.now() - reverseCalcTimestampRef.current < REVERSE_CALC_SETTLE_MS) {
+            console.log('[SwapFormEstimates] dest-calc effect SKIPPED (reverse calc cooldown)');
+            return;
+        }
         const splitsKey = splits.join(',');
         const hasSplitsChanged = prevSplitsRef.current !== splitsKey;
         const hasInputAmountChanged = prevInputAmountForCalcRef.current !== inputAmount;
@@ -414,14 +468,28 @@ export function SwapFormEstimatesProvider({ children, tokenIn, fetchEstimates, s
     useEffect(() => {
         // Skip if we're already fetching to prevent loops
         if (isFetchingEstimatesRef.current) {
+            console.log('[SwapFormEstimates] initial-fetch effect SKIPPED (already fetching)', { estimateKey });
             // Update lastFetchedKeyRef to the new key to prevent re-triggering when fetch completes
             if (estimateKey) {
                 lastFetchedKeyRef.current = estimateKey;
             }
             return;
         }
+        // After a reverse calculation (output-to-input) completes, it programmatically
+        // updates inputAmount which changes estimateKey. Skip re-fetching during the
+        // cooldown window to avoid an infinite loop (bridge quotes aren't perfectly
+        // deterministic, so the calculated input oscillates slightly each cycle).
+        const cooldownMs = Date.now() - reverseCalcTimestampRef.current;
+        if (cooldownMs < REVERSE_CALC_SETTLE_MS) {
+            console.log('[SwapFormEstimates] initial-fetch effect SKIPPED (reverse calc cooldown)', { cooldownMs, estimateKey });
+            if (estimateKey) {
+                lastFetchedKeyRef.current = estimateKey;
+            }
+            return;
+        }
         // Only fetch if we have a valid estimate key and it's different from the last one we fetched
         if (estimateKey && estimateKey !== lastFetchedKeyRef.current) {
+            console.log('[SwapFormEstimates] initial-fetch effect TRIGGERING fetch', { estimateKey, lastKey: lastFetchedKeyRef.current });
             // Mark this key as fetched to prevent duplicate calls
             lastFetchedKeyRef.current = estimateKey;
             // Use the debounced fetch function to avoid rapid duplicate calls

package/dist/hooks/silent/useSilentQuote.js

@@ -280,10 +280,13 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
                 if (sourceAssetMatch) {
                     const sourceChainId = parseInt(sourceAssetMatch[1]);
                     const tokenAddress = sourceAssetMatch[2];
-                    await approveTokenSpending(sourceChainId, tokenAddress, effectiveAllowanceTarget, sourceAmountInUnits, evmSignerAddress);
-                    // Delay after approve so RPC/nodes confirm approval before next tx (avoids MetaMask RPC errors)
-                    setCurrentStep('Waiting for network...');
-                    await new Promise((resolve) => setTimeout(resolve, APPROVE_POST_DELAY_MS));
+                    const approvalHash = await approveTokenSpending(sourceChainId, tokenAddress, effectiveAllowanceTarget, sourceAmountInUnits, evmSignerAddress);
+                    // Only delay if an approval tx was actually sent (null means allowance was already sufficient)
+                    if (approvalHash) {
+                        // Delay after approve so RPC/nodes confirm approval before next tx (avoids MetaMask RPC errors)
+                        setCurrentStep('Waiting for network...');
+                        await new Promise((resolve) => setTimeout(resolve, APPROVE_POST_DELAY_MS));
+                    }
                 }
             }
             // Handle EVM bridge swaps

package/dist/hooks/usePlatformHealth.d.ts

@@ -28,8 +28,8 @@ export type PlatformHealthContextType = {
 export type PlatformHealthProviderProps = {
     children: React.ReactNode;
     /**
-     * Pro user ID for volume tracking (from ?pro= URL or localStorage silentswap:pro).
-     * When set, status is fetched with ?pro= and identity/volume/liquidity are returned.
+     * @deprecated proId is now read from the parent SilentSwapContext (passed via SilentSwapProvider).
+     * This prop is ignored.
      */
     proId?: string;
     /**
@@ -44,10 +44,11 @@ export type PlatformHealthProviderProps = {
     onTrackingDisabledChange?: (disabled: boolean) => void;
 };
 /**
- * Provider that monitors platform health from status API and provides validation functions
- * for deposit amounts, output limits, and service fee rates
+ * Provider that monitors platform health from SilentSwapContext (which calls useStatus
+ * once with proId) and provides validation functions for deposit amounts, output limits,
+ * and service fee rates.
  */
-export declare function PlatformHealthProvider({ children, proId, onFormDisabledChange, onTrackingDisabledChange, }: PlatformHealthProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function PlatformHealthProvider({ children, onFormDisabledChange, onTrackingDisabledChange, }: PlatformHealthProviderProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Hook to access platform health context
  */

package/dist/hooks/usePlatformHealth.js

@@ -1,16 +1,19 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import React, { createContext, useContext, useEffect, useMemo, useCallback } from 'react';
-import { useStatus } from '../hooks/useStatus.js';
+import { useSilentSwap } from '../contexts/SilentSwapContext.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
- * for deposit amounts, output limits, and service fee rates
+ * Provider that monitors platform health from SilentSwapContext (which calls useStatus
+ * once with proId) and provides validation functions for deposit amounts, output limits,
+ * and service fee rates.
  */
-export function PlatformHealthProvider({ children, proId, onFormDisabledChange, onTrackingDisabledChange, }) {
-    const { platformHealth: statusPlatformHealth, maximumDepositUusdc, minimumDepositUusdc, outputLimit, serviceFeeRate, overheadUsd, identity, volume, liquidity, storage, } = useStatus(proId != null ? { proId } : undefined);
+export function PlatformHealthProvider({ children, onFormDisabledChange, onTrackingDisabledChange, }) {
+    // Consume status data from parent SilentSwapContext instead of calling useStatus again
+    const { status } = useSilentSwap();
+    const { platformHealth: statusPlatformHealth, maximumDepositUusdc, minimumDepositUusdc, outputLimit, serviceFeeRate, overheadUsd, identity, volume, liquidity, storage, } = status;
     // Normalize platform health status
     const platformHealth = useMemo(() => {
         if (!statusPlatformHealth)
@@ -88,14 +91,12 @@ export function PlatformHealthProvider({ children, proId, onFormDisabledChange,
         }
     }, [maximumDepositUusdc]);
     const getServiceFeeRate = useCallback(() => {
-        if (!serviceFeeRate)
+        if (serviceFeeRate == null)
             return 0.01;
-        try {
-            return +serviceFeeRate || 0.01;
-        }
-        catch {
+        const rate = +serviceFeeRate;
+        if (isNaN(rate))
             return 0.01;
-        }
+        return rate;
     }, [serviceFeeRate]);
     // Validate deposit amount against min/max limits
     const validateDepositAmount = useCallback((usdAmount) => {

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export type { BalancesContextType, UserBalance } from './contexts/BalancesContex
 export { OrdersProvider, useOrdersContext, useWalletFacilitatorGroups } 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 type { SilentSwapContextType, SilentSwapStatusData, SilentSwapFees, SilentSwapOrderTracking, SilentSwapEstimates, } 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';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/react",
   "type": "module",
-  "version": "0.0.86",
+  "version": "0.0.88",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,8 +24,8 @@
   "dependencies": {
     "@bigmi/core": "^0.6.5",
     "@ensdomains/ensjs": "^4.2.0",
-    "@silentswap/sdk": "0.0.86",
-    "@silentswap/ui-kit": "0.0.86",
+    "@silentswap/sdk": "0.0.88",
+    "@silentswap/ui-kit": "0.0.88",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",