@silentswap/react 0.0.86 → 0.0.87

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/react",
   "type": "module",
-  "version": "0.0.86",
+  "version": "0.0.87",
   "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.87",
+    "@silentswap/ui-kit": "0.0.87",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",