@silentswap/react 0.1.57 → 0.1.58

package/dist/contexts/BalancesContext.js

@@ -10,9 +10,18 @@ import { useAssetsContext } from './AssetsContext.js';
 import { usePrices } from '../hooks/usePrices.js';
 import { isSolanaAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, isEvmNativeToken, isBitcoinAsset, isBitcoinMainnetAsset, SB58_CHAIN_ID_SOLANA_MAINNET, A_VIEM_CHAINS, BITCOIN_CHAIN_ID, TRON_CHAIN_ID, H_RPCS, } from '@silentswap/sdk';
 const BalancesContext = createContext(undefined);
+// Cache for viem public clients keyed by chain id. Clients are immutable for
+// a given chain/rpc and are safe to share across refetches — recreating one
+// costs 10-50ms (transport init + viem setup) which adds up across 5-20 chains
+// on every refetch trigger. Stored as `unknown` to avoid polluting the call
+// site's narrow generic types inferred from createPublicClient.
+const _viemClientCache = new Map();
 // Utility: Create viem client with custom RPC endpoints where available
 // Uses H_RPCS from @silentswap/sdk (rpc.ts) as the single source of truth
 const createViemClient = (chain) => {
+    const cached = _viemClientCache.get(chain.id);
+    if (cached)
+        return cached;
     const customRpc = H_RPCS[chain.id];
     const chainWithCustomRpc = customRpc
         ? {
@@ -25,10 +34,12 @@ const createViemClient = (chain) => {
             },
         }
         : chain;
-    return createPublicClient({
+    const client = createPublicClient({
         chain: chainWithCustomRpc,
         transport: http(), // viem http transport with default timeout
     });
+    _viemClientCache.set(chain.id, client);
+    return client;
 };
 // Utility: Separate EVM assets into ERC-20 and native
 const separateEvmAssets = (chainAssets) => {

package/dist/contexts/OrdersContext.js

@@ -24,6 +24,35 @@ export const useWalletFacilitatorGroups = (wallet, setFacilitatorGroups) => {
     }, [wallet, setFacilitatorGroups]);
 };
 const OrdersContext = createContext(undefined);
+// Tuning for /recent fetch batching + retry. Rate limits are observed on accounts
+// with many facilitator groups; keep concurrency low and retry 429/5xx with backoff.
+const RECENT_ORDER_CONCURRENCY = 3;
+const MAX_RECENT_ORDER_RETRIES = 4;
+const RECENT_ORDER_BACKOFF_BASE_MS = 500;
+const RECENT_ORDER_BACKOFF_MAX_MS = 8_000;
+const RECENT_ORDER_BACKOFF_JITTER_MS = 250;
+const parseRetryAfterHeader = (header) => {
+    if (!header)
+        return null;
+    const asSeconds = Number(header);
+    if (Number.isFinite(asSeconds))
+        return Math.max(0, asSeconds * 1000);
+    const asDate = Date.parse(header);
+    if (Number.isFinite(asDate))
+        return Math.max(0, asDate - Date.now());
+    return null;
+};
+const runWithConcurrency = async (items, limit, worker) => {
+    let cursor = 0;
+    const size = Math.max(1, Math.min(limit, items.length));
+    const runners = Array.from({ length: size }, async () => {
+        while (cursor < items.length) {
+            const index = cursor++;
+            await worker(items[index], index);
+        }
+    });
+    await Promise.all(runners);
+};
 export const OrdersProvider = ({ children, baseUrl: baseUrlProp }) => {
     const [orders, setOrders] = useState([]);
     const [loading, setLoading] = useState(false);
@@ -107,12 +136,30 @@ export const OrdersProvider = ({ children, baseUrl: baseUrlProp }) => {
             return [];
         }
         try {
-            // Request current orders from backend using facilitator auth
-            const d_res = await fetch(`${baseUrl}/recent?${new URLSearchParams({
+            const url = `${baseUrl}/recent?${new URLSearchParams({
                 auth: sb58_auth_view,
-            })}`);
-            // Parse response body
-            const sx_res = await d_res.text();
+            })}`;
+            // Retry on rate-limits (429) and transient server errors (5xx) with
+            // Retry-After / exponential backoff so accounts with many facilitator
+            // groups don't silently lose order data under burst throttling.
+            let d_res;
+            let sx_res = '';
+            for (let attempt = 0; attempt <= MAX_RECENT_ORDER_RETRIES; attempt++) {
+                d_res = await fetch(url);
+                if (d_res.status !== 429 && d_res.status < 500) {
+                    sx_res = await d_res.text();
+                    break;
+                }
+                if (attempt === MAX_RECENT_ORDER_RETRIES) {
+                    throw new Error(`Recent orders request failed with status ${d_res.status}`);
+                }
+                const retryAfterMs = parseRetryAfterHeader(d_res.headers.get('Retry-After'));
+                const backoffMs = retryAfterMs ?? Math.min(RECENT_ORDER_BACKOFF_BASE_MS * 2 ** attempt + Math.random() * RECENT_ORDER_BACKOFF_JITTER_MS, RECENT_ORDER_BACKOFF_MAX_MS);
+                await new Promise((resolve) => setTimeout(resolve, backoffMs));
+            }
+            if (!d_res || !d_res.ok) {
+                throw new Error(`Recent orders request failed with status ${d_res?.status ?? 'unknown'}`);
+            }
             // Attempt to parse JSON (with safe parsing like Svelte)
             let a_orders;
             try {
@@ -165,8 +212,11 @@ export const OrdersProvider = ({ children, baseUrl: baseUrlProp }) => {
         }
         try {
             const a_all_orders = [];
-            // Fetch orders for each facilitator group
-            await Promise.all(currentGroups.map(async (f_group) => {
+            // Fetch orders for each facilitator group, capped at RECENT_ORDER_CONCURRENCY
+            // to avoid bursting /recent with many parallel requests (which trips 429s for
+            // accounts with many facilitator groups). Per-request retry is handled inside
+            // request_recent_orders.
+            await runWithConcurrency(currentGroups, RECENT_ORDER_CONCURRENCY, 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);
@@ -184,7 +234,7 @@ export const OrdersProvider = ({ children, baseUrl: baseUrlProp }) => {
                 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);

package/dist/contexts/PricesContext.js

@@ -1,30 +1,110 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useState, useCallback, useMemo } from 'react';
+import { createContext, useContext, useState, useCallback, useMemo, useRef } from 'react';
 import { usePrices } from '../hooks/usePrices.js';
 const PRICE_STALE_AGE = 10 * 1000; // 10 seconds in milliseconds
+const FAILURE_RETRY_MS = 30_000; // 30 seconds throttle for assets that failed to resolve a price
+const FAILED_ASSETS_MAX = 1000; // cap on tracked failures to avoid unbounded growth
 const PricesContext = createContext(undefined);
 export const PricesProvider = ({ children }) => {
-    const { getPrice: fetchPrice } = usePrices();
+    const { getPrice: fetchPrice, getPrices: fetchPrices } = usePrices();
     const [priceData, setPriceData] = useState({});
     const [loadingAssets, setLoadingAssets] = useState(new Set());
-    // Fetch price for an asset and cache it with timestamp
+    // Batch queue: collects assets from multiple getPrice() calls and flushes
+    // them in a single API call. Uses a short timer window (not queueMicrotask)
+    // so calls made from components that mount on subsequent ticks still
+    // coalesce into one CoinGecko request instead of producing one per mount.
+    const batchQueueRef = useRef(new Map());
+    const batchScheduledRef = useRef(false);
+    const BATCH_WINDOW_MS = 50;
+    // Synchronous in-flight guard for fetchAndCachePrice. React state (loadingAssets)
+    // is not updated synchronously, so repeated calls within the same render pass would
+    // otherwise all see a stale `has()` === false and proceed concurrently.
+    const inFlightRef = useRef(new Set());
+    // Tracks the timestamp of the last failed fetch (unresolved price or thrown error)
+    // per caip19, so we can throttle re-enqueueing of assets that CoinGecko does not list.
+    // Bounded via FAILED_ASSETS_MAX with LRU-style eviction (Map iterates insertion order,
+    // so deleting+re-setting moves an entry to the end).
+    const failedAssetsRef = useRef(new Map());
+    const recordFailure = useCallback((caip19, now) => {
+        const map = failedAssetsRef.current;
+        if (map.has(caip19))
+            map.delete(caip19); // refresh insertion order
+        map.set(caip19, now);
+        if (map.size > FAILED_ASSETS_MAX) {
+            const oldest = map.keys().next().value;
+            if (oldest !== undefined)
+                map.delete(oldest);
+        }
+    }, []);
+    // Flush all queued assets in a single batch API call
+    const flushBatch = useCallback(async () => {
+        batchScheduledRef.current = false;
+        const batch = Array.from(batchQueueRef.current.values());
+        batchQueueRef.current.clear();
+        if (batch.length === 0)
+            return;
+        // Mark all as loading
+        setLoadingAssets((prev) => {
+            const next = new Set(prev);
+            batch.forEach((asset) => next.add(asset.caip19));
+            return next;
+        });
+        try {
+            const prices = await fetchPrices(batch);
+            const now = Date.now();
+            batch.forEach((asset, i) => {
+                const price = prices[i];
+                if (typeof price === 'number' && price > 0) {
+                    failedAssetsRef.current.delete(asset.caip19);
+                }
+                else {
+                    recordFailure(asset.caip19, now);
+                }
+            });
+            setPriceData((prev) => {
+                const next = { ...prev };
+                batch.forEach((asset, i) => {
+                    const price = prices[i];
+                    // Only mark fresh when we have a valid resolved price; leave unresolved
+                    // entries untouched so they remain stale and get re-enqueued.
+                    if (typeof price === 'number' && price > 0) {
+                        next[asset.caip19] = { price, timestamp: now };
+                    }
+                });
+                return next;
+            });
+        }
+        catch (error) {
+            console.warn('Failed to batch fetch prices:', error);
+            // Do not write timestamps on transient failure — entries stay stale so the
+            // next getPrice() call will re-enqueue them. Throttle retries via failedAssetsRef.
+            const now = Date.now();
+            batch.forEach((asset) => {
+                recordFailure(asset.caip19, now);
+            });
+        }
+        finally {
+            setLoadingAssets((prev) => {
+                const next = new Set(prev);
+                batch.forEach((asset) => next.delete(asset.caip19));
+                return next;
+            });
+        }
+    }, [fetchPrices, recordFailure]);
+    // Fetch a single asset price (used by refetchPrice only)
     const fetchAndCachePrice = useCallback(async (asset) => {
         const caip19 = asset.caip19;
-        // Skip if already loading
-        if (loadingAssets.has(caip19)) {
+        if (inFlightRef.current.has(caip19))
             return;
-        }
+        inFlightRef.current.add(caip19);
         setLoadingAssets((prev) => new Set(prev).add(caip19));
         try {
             const price = await fetchPrice(asset);
             const now = Date.now();
             setPriceData((prev) => ({
                 ...prev,
-                [caip19]: {
-                    price,
-                    timestamp: now,
-                },
+                [caip19]: { price, timestamp: now },
             }));
         }
         catch (error) {
@@ -32,20 +112,18 @@ export const PricesProvider = ({ children }) => {
             const now = Date.now();
             setPriceData((prev) => ({
                 ...prev,
-                [caip19]: {
-                    price: undefined,
-                    timestamp: now,
-                },
+                [caip19]: { price: undefined, timestamp: now },
             }));
         }
         finally {
+            inFlightRef.current.delete(caip19);
             setLoadingAssets((prev) => {
                 const next = new Set(prev);
                 next.delete(caip19);
                 return next;
             });
         }
-    }, [fetchPrice, loadingAssets]);
+    }, [fetchPrice]);
     // Check if price is stale (older than 10 seconds)
     const isPriceStale = useCallback((caip19) => {
         const data = priceData[caip19];
@@ -54,33 +132,34 @@ export const PricesProvider = ({ children }) => {
         const age = Date.now() - data.timestamp;
         return age > PRICE_STALE_AGE;
     }, [priceData]);
-    // Get price from cache or trigger fetch
+    // Get price from cache or queue for batch 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);
+        // If no cached data or stale, queue for batch fetch
+        if (!data || isPriceStale(caip19)) {
+            const lastFailure = failedAssetsRef.current.get(caip19);
+            const isFailureThrottled = lastFailure !== undefined && Date.now() - lastFailure < FAILURE_RETRY_MS;
+            if (!isFailureThrottled &&
+                !loadingAssets.has(caip19) &&
+                !batchQueueRef.current.has(caip19)) {
+                batchQueueRef.current.set(caip19, asset);
+                if (!batchScheduledRef.current) {
+                    batchScheduledRef.current = true;
+                    setTimeout(() => flushBatch(), BATCH_WINDOW_MS);
+                }
             }
         }
         // Return cached price (even if stale, to avoid flickering)
-        return data.price;
-    }, [priceData, loadingAssets, fetchAndCachePrice, isPriceStale]);
+        return data?.price;
+    }, [priceData, loadingAssets, isPriceStale, flushBatch]);
     // Check if price is loading
     const isLoading = useCallback((caip19) => {
         return loadingAssets.has(caip19);
     }, [loadingAssets]);
-    // Refetch price for an asset
+    // Refetch price for a specific asset (explicit, not batched)
     const refetchPrice = useCallback(async (asset) => {
         await fetchAndCachePrice(asset);
     }, [fetchAndCachePrice]);

package/dist/hooks/silent/useAuth.js

@@ -298,22 +298,29 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
         }
         prevAddressRef.current = normalizedAddress;
     }, [normalizedAddress]);
-    // Reset error and retry flag when walletClient changes (e.g. user reconnects
-    // with a different wallet, or WalletConnect session is re-established).
-    // Without this, a failed auto-auth permanently blocks retries.
+    // Reset auto-auth tracking when walletClient transitions to a new non-null
+    // reference. A new walletClient means a new wallet session (first connect,
+    // reconnect after disconnect, or wallet switch) — the auto-auth effect must
+    // re-evaluate. Without this, the hasAutoAuthenticatedRef flag from a prior
+    // session survives disconnect/reconnect (wagmi keeps the hook mounted) and
+    // silently blocks the sign-in prompt on the new session.
+    //
+    // Note we also reset in the happy path (previous auth succeeded), not only
+    // when `error` was set — cached auth may have been cleared externally
+    // (localStorage wipe, incognito, user script) so we must not assume the
+    // previous success is still valid for the new session.
     const prevWalletClientRef = useRef(walletClient);
     useEffect(() => {
         if (prevWalletClientRef.current !== walletClient && walletClient) {
-            if (error) {
-                console.log('[useAuth] walletClient changed, clearing error to allow retry');
+            console.log('[useAuth] walletClient changed, resetting auto-auth flags');
+            hasAutoAuthenticatedRef.current = false;
+            autoAuthRetryCountRef.current = 0;
+            setAuthExhausted(false);
+            if (error)
                 setError(null);
-                hasAutoAuthenticatedRef.current = false;
-                autoAuthRetryCountRef.current = 0;
-                setAuthExhausted(false);
-                if (retryTimerRef.current) {
-                    clearTimeout(retryTimerRef.current);
-                    retryTimerRef.current = null;
-                }
+            if (retryTimerRef.current) {
+                clearTimeout(retryTimerRef.current);
+                retryTimerRef.current = null;
             }
         }
         prevWalletClientRef.current = walletClient;

package/dist/hooks/useSwap.d.ts

@@ -65,3 +65,16 @@ export declare const useSwap: import("zustand").UseBoundStore<Omit<import("zusta
         getOptions: () => Partial<import("zustand/middleware").PersistOptions<SwapState, unknown, unknown>>;
     };
 }>;
+/**
+ * Triggers a one-time rehydration of the swap store from localStorage and
+ * returns whether it has finished.
+ *
+ * Pair with `skipHydration: true` in the persist config: consumers gate their
+ * first render on `useSwapStoreHydration()` so they read the persisted values
+ * on the very first render, avoiding the classic defaults-then-persisted
+ * re-render flash.
+ *
+ * Safe during SSR — returns `true` so server-rendered markup doesn't wait on
+ * localStorage access that can't happen there.
+ */
+export declare const useSwapStoreHydration: () => boolean;

package/dist/hooks/useSwap.js

@@ -1,3 +1,4 @@
+import { useEffect, useState } from 'react';
 import { create } from 'zustand';
 import { persist, createJSONStorage } from 'zustand/middleware';
 import { getAssetByCaip19 } from '@silentswap/sdk';
@@ -263,6 +264,10 @@ const useSwapStore = create()(persist((set, get) => ({
 }), {
     name: 'swap-store',
     storage: createJSONStorage(() => localStorage),
+    // Hydrate manually via useSwapStoreHydration() so the first
+    // render of consumers already sees the persisted state, instead
+    // of flipping from defaults → persisted in a second render.
+    skipHydration: true,
     // Persist privacy mode, tokenIn, and inputAmount
     partialize: (state) => ({
         privacyEnabled: state.privacyEnabled,
@@ -295,3 +300,33 @@ if (typeof window === 'undefined') {
     useSwapStore.getState(); // Cache the snapshot on server
 }
 export const useSwap = useSwapStore;
+/**
+ * Triggers a one-time rehydration of the swap store from localStorage and
+ * returns whether it has finished.
+ *
+ * Pair with `skipHydration: true` in the persist config: consumers gate their
+ * first render on `useSwapStoreHydration()` so they read the persisted values
+ * on the very first render, avoiding the classic defaults-then-persisted
+ * re-render flash.
+ *
+ * Safe during SSR — returns `true` so server-rendered markup doesn't wait on
+ * localStorage access that can't happen there.
+ */
+export const useSwapStoreHydration = () => {
+    const [hydrated, setHydrated] = useState(() => {
+        if (typeof window === 'undefined')
+            return true;
+        return useSwapStore.persist.hasHydrated();
+    });
+    useEffect(() => {
+        if (useSwapStore.persist.hasHydrated()) {
+            setHydrated(true);
+            return;
+        }
+        const unsub = useSwapStore.persist.onFinishHydration(() => setHydrated(true));
+        // Kick off rehydration once on mount.
+        void useSwapStore.persist.rehydrate();
+        return unsub;
+    }, []);
+    return hydrated;
+};

package/dist/index.d.ts

@@ -25,7 +25,7 @@ export { useTransaction } from './hooks/useTransaction.js';
 export { useQuote } from './hooks/useQuote.js';
 export { useOrderEstimates } from './hooks/useOrderEstimates.js';
 export { usePrices } from './hooks/usePrices.js';
-export { useSwap, getSourceAssetCaip19, X_RANGE_SLIDER_MIN_GAP, OUTPUT_LIMIT, DEFAULT_SOURCE_ASSET, DEFAULT_DEST_ASSET, } from './hooks/useSwap.js';
+export { useSwap, useSwapStoreHydration, getSourceAssetCaip19, X_RANGE_SLIDER_MIN_GAP, OUTPUT_LIMIT, DEFAULT_SOURCE_ASSET, DEFAULT_DEST_ASSET, } from './hooks/useSwap.js';
 export type { Destination, SwapState } from './hooks/useSwap.js';
 export { useEgressEstimates } from './hooks/useEgressEstimates.js';
 export type { UseEgressEstimatesOptions } from './hooks/useEgressEstimates.js';

package/dist/index.js

@@ -17,7 +17,7 @@ export { useTransaction } from './hooks/useTransaction.js';
 export { useQuote } from './hooks/useQuote.js';
 export { useOrderEstimates } from './hooks/useOrderEstimates.js';
 export { usePrices } from './hooks/usePrices.js';
-export { useSwap, getSourceAssetCaip19, X_RANGE_SLIDER_MIN_GAP, OUTPUT_LIMIT, DEFAULT_SOURCE_ASSET, DEFAULT_DEST_ASSET, } from './hooks/useSwap.js';
+export { useSwap, useSwapStoreHydration, getSourceAssetCaip19, X_RANGE_SLIDER_MIN_GAP, OUTPUT_LIMIT, DEFAULT_SOURCE_ASSET, DEFAULT_DEST_ASSET, } from './hooks/useSwap.js';
 export { useEgressEstimates } from './hooks/useEgressEstimates.js';
 export { useStatus } from './hooks/useStatus.js';
 export { PlatformHealthProvider, usePlatformHealthContext } from './hooks/usePlatformHealth.js';

package/package.json

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