@silentswap/react 0.1.52 → 0.1.53

package/dist/contexts/AuthContext.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import type { Connector } from 'wagmi';
+import type { WalletClient } from 'viem';
+import type { AuthResponse, SilentSwapClient } from '@silentswap/sdk';
+/**
+ * Shape of the auth context exposed to consumers. Mirrors the subset of
+ * `useAuth` that callers actually need — keeping the surface narrow so
+ * the context doesn't have to track internal SDK changes.
+ */
+export interface AuthContextValue {
+    /** Current auth response (null when not signed in). */
+    auth: AuthResponse | null;
+    /** True while a sign-in (including auto-auth retries) is in flight. */
+    isLoading: boolean;
+    /** Last sign-in error. */
+    error: Error | null;
+    /** True when SIWE auto-authentication exhausted all retries. */
+    authExhausted: boolean;
+    /** Imperatively start / retry SIWE sign-in. */
+    signIn: () => Promise<AuthResponse | null>;
+    /** Alias of {@link signIn} kept for callers that prefer the full name. */
+    authenticate: () => Promise<AuthResponse | null>;
+    /** Clear auth state for the current address. */
+    signOut: () => void;
+    /** True iff auth is present and not yet expired. */
+    isAuthenticated: () => boolean;
+}
+export declare function useAuthContext(): AuthContextValue;
+export interface AuthProviderProps {
+    children: React.ReactNode;
+    client?: SilentSwapClient;
+    address?: `0x${string}`;
+    walletClient?: WalletClient;
+    connector?: Connector;
+    /** Whether to auto-authenticate as soon as the prerequisites are available. */
+    autoAuthenticate?: boolean;
+    /** Status callback for sign-in progress (e.g. to show toasts). */
+    onStatus?: (status: string) => void;
+}
+/**
+ * Wraps {@link useAuth} in a React context so multiple components can read
+ * the same auth state without each remounting its own hook instance.
+ *
+ * Two independent `useAuth()` callers race each other on mount — they each
+ * try to fire the same signMessage prompt, which is the origin of the
+ * "double sign-in dialog" bug on the hidden swap + order recovery pages.
+ * Centralising the hook behind this provider guarantees a single in-flight
+ * auth attempt per address.
+ */
+export declare function AuthProvider({ children, client, address, walletClient, connector, autoAuthenticate, onStatus, }: AuthProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/contexts/AuthContext.js

@@ -0,0 +1,49 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { useAuth } from '../hooks/silent/useAuth.js';
+const DEFAULT_AUTH_VALUE = {
+    auth: null,
+    isLoading: false,
+    error: null,
+    authExhausted: false,
+    signIn: async () => null,
+    authenticate: async () => null,
+    signOut: () => { },
+    isAuthenticated: () => false,
+};
+const AuthContext = createContext(DEFAULT_AUTH_VALUE);
+export function useAuthContext() {
+    return useContext(AuthContext);
+}
+/**
+ * Wraps {@link useAuth} in a React context so multiple components can read
+ * the same auth state without each remounting its own hook instance.
+ *
+ * Two independent `useAuth()` callers race each other on mount — they each
+ * try to fire the same signMessage prompt, which is the origin of the
+ * "double sign-in dialog" bug on the hidden swap + order recovery pages.
+ * Centralising the hook behind this provider guarantees a single in-flight
+ * auth attempt per address.
+ */
+export function AuthProvider({ children, client, address, walletClient, connector, autoAuthenticate = true, onStatus, }) {
+    const { auth, isLoading, error, authExhausted, signIn, authenticate, signOut, isAuthenticated, } = useAuth({
+        client,
+        address,
+        walletClient,
+        connector,
+        autoAuthenticate,
+        onStatus,
+    });
+    const value = {
+        auth,
+        isLoading,
+        error,
+        authExhausted,
+        signIn,
+        authenticate,
+        signOut,
+        isAuthenticated,
+    };
+    return _jsx(AuthContext.Provider, { value: value, children: children });
+}

package/dist/contexts/PrivateWalletContext.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { type SilentSwapWallet } from '../hooks/silent/useWallet.js';
+import type { Connector } from 'wagmi';
+import type { WalletClient } from 'viem';
+import type { SilentSwapClient } from '@silentswap/sdk';
+/**
+ * Shape of the private-wallet context exposed to consumers. Intentionally
+ * narrow — anything beyond this (entropy, facilitator groups, cache
+ * management) stays an implementation detail of {@link useWallet}.
+ */
+export interface PrivateWalletContextValue {
+    /** Generated SilentSwap facilitator wallet (null until ready). */
+    wallet: SilentSwapWallet | null;
+    /** True while entropy generation / signTypedData is in flight. */
+    isLoading: boolean;
+    /** Last generation error (null when healthy). */
+    error: Error | null;
+    /** Imperatively (re)generate the private wallet. */
+    generateWallet: () => Promise<void>;
+    /** User-initiated retry: clears cache + regenerates, bypassing the in-flight guard. */
+    retryWallet: () => Promise<void>;
+    /** Drop the cached wallet for the current address. */
+    clearWallet: () => void;
+}
+export declare function usePrivateWalletContext(): PrivateWalletContextValue;
+export interface PrivateWalletProviderProps {
+    children: React.ReactNode;
+    client: SilentSwapClient;
+    address?: `0x${string}`;
+    walletClient?: WalletClient;
+    connector?: Connector;
+    /** If true, includes all historical deposit nonces when regenerating. */
+    allDeposits?: boolean;
+    /** If true (default), auto-generates the wallet once auth is available. */
+    autoGenerate?: boolean;
+    /** Status callback for generation progress (e.g. to show toasts). */
+    onStatus?: (status: string) => void;
+}
+/**
+ * Wraps {@link useWallet} in a React context and auto-triggers generation
+ * once the upstream {@link AuthContext} reports a valid auth. Using a
+ * provider here (instead of re-calling the hook in every consumer) keeps
+ * exactly one in-flight signTypedData prompt per session — mirrors the
+ * rationale behind {@link AuthProvider}.
+ */
+export declare function PrivateWalletProvider({ children, client, address, walletClient, connector, allDeposits, autoGenerate, onStatus, }: PrivateWalletProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/contexts/PrivateWalletContext.js

@@ -0,0 +1,63 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useRef } from 'react';
+import { useWallet } from '../hooks/silent/useWallet.js';
+import { useAuthContext } from './AuthContext.js';
+const DEFAULT_WALLET_VALUE = {
+    wallet: null,
+    isLoading: false,
+    error: null,
+    generateWallet: async () => { },
+    retryWallet: async () => { },
+    clearWallet: () => { },
+};
+const PrivateWalletContext = createContext(DEFAULT_WALLET_VALUE);
+export function usePrivateWalletContext() {
+    return useContext(PrivateWalletContext);
+}
+/**
+ * Wraps {@link useWallet} in a React context and auto-triggers generation
+ * once the upstream {@link AuthContext} reports a valid auth. Using a
+ * provider here (instead of re-calling the hook in every consumer) keeps
+ * exactly one in-flight signTypedData prompt per session — mirrors the
+ * rationale behind {@link AuthProvider}.
+ */
+export function PrivateWalletProvider({ children, client, address, walletClient, connector, allDeposits = true, autoGenerate = true, onStatus, }) {
+    const { auth } = useAuthContext();
+    const { wallet, isLoading, error, generateWallet, clearWallet, refreshWallet, } = useWallet({
+        client,
+        address: address,
+        auth: auth || undefined,
+        walletClient,
+        connector,
+        allDeposits,
+        onStatus,
+    });
+    // Keep generateWallet in a ref so the auto-trigger effect below doesn't
+    // re-fire when useWallet rebuilds the callback (e.g. after ensureChain
+    // swaps the walletClient identity). Re-firing would race the in-flight
+    // signTypedData prompt — exactly the bug we fixed in the old inner
+    // provider that used to live in SilentSwapContext.
+    const generateWalletRef = useRef(generateWallet);
+    useEffect(() => {
+        generateWalletRef.current = generateWallet;
+    }, [generateWallet]);
+    useEffect(() => {
+        if (!autoGenerate)
+            return;
+        if (auth && walletClient && connector && !wallet && !isLoading && !error) {
+            generateWalletRef.current().catch((err) => {
+                console.error('Failed to generate private wallet:', err);
+            });
+        }
+    }, [autoGenerate, auth, walletClient, connector, wallet, isLoading, error]);
+    const value = {
+        wallet,
+        isLoading,
+        error,
+        generateWallet,
+        retryWallet: refreshWallet,
+        clearWallet,
+    };
+    return _jsx(PrivateWalletContext.Provider, { value: value, children: children });
+}

package/dist/contexts/SilentSwapContext.d.ts

@@ -45,10 +45,16 @@ export interface SilentSwapContextType {
     config: SilentSwapClientConfig;
     wallet: SilentSwapWallet | null;
     walletLoading: boolean;
+    /** Last error from private wallet generation (null when healthy) */
+    walletError: Error | null;
+    /** Manual trigger to retry wallet generation (e.g. after silent failure) */
+    retryWallet: () => Promise<void>;
     auth: AuthResponse | null;
     authLoading: boolean;
     /** True when SIWE auto-authentication exhausted all retries (WalletConnect connection lost) */
     authExhausted: boolean;
+    /** Manual trigger to start / retry SIWE sign-in */
+    signIn: () => Promise<AuthResponse | null>;
     executeSwap: (params: ExecuteSwapParams) => Promise<SwapResult | null>;
     swapLoading: boolean;
     isSwapping: boolean;

package/dist/contexts/SilentSwapContext.js

@@ -1,8 +1,8 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useEffect, useMemo, useState, useCallback } from 'react';
-import { useAuth } from '../hooks/silent/useAuth.js';
-import { useWallet } from '../hooks/silent/useWallet.js';
+import { AuthProvider, useAuthContext } from './AuthContext.js';
+import { PrivateWalletProvider, usePrivateWalletContext } from './PrivateWalletContext.js';
 import { useSilentQuote } from '../hooks/silent/useSilentQuote.js';
 import { useOrderTracking } from '../hooks/silent/useOrderTracking.js';
 import { usePrices } from '../hooks/usePrices.js';
@@ -27,9 +27,12 @@ const DEFAULT_CONTEXT = {
     },
     wallet: null,
     walletLoading: false,
+    walletError: null,
+    retryWallet: async () => { },
     auth: null,
     authLoading: false,
     authExhausted: false,
+    signIn: async () => null,
     executeSwap: async () => null,
     swapLoading: false,
     isSwapping: false,
@@ -81,26 +84,14 @@ export function useSilentSwap() {
     }
     return context;
 }
-function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bitcoinAddress, tronAddress, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, proId, requestWalletConnect, forceBridgeProvider, onAuthStatus, onWalletStatus, }) {
-    // Authentication hook - only for EVM
-    const { auth, isLoading: authLoading, authenticate, authExhausted } = useAuth({
-        client,
-        address: evmAddress,
-        walletClient: walletClient,
-        connector: connector,
-        autoAuthenticate: true,
-        onStatus: onAuthStatus,
-    });
-    // Wallet management hook
-    const { wallet, generateWallet, refreshWallet, isLoading: walletLoading, error: walletError, } = useWallet({
-        client,
-        address: evmAddress,
-        auth: auth || undefined,
-        walletClient: walletClient,
-        connector: connector,
-        allDeposits: true,
-        onStatus: onWalletStatus,
-    });
+function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bitcoinAddress, tronAddress, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, proId, requestWalletConnect, forceBridgeProvider, }) {
+    // Auth + private-wallet state now come from their own dedicated contexts
+    // (see AuthProvider / PrivateWalletProvider wrapping this inner provider
+    // in SilentSwapProvider below). This keeps exactly one useAuth + one
+    // useWallet instance per session, so two consumers on the same page can
+    // never race each other into duplicate signMessage / signTypedData prompts.
+    const { auth, isLoading: authLoading, authenticate, signIn, authExhausted, } = useAuthContext();
+    const { wallet, generateWallet, retryWallet: refreshWallet, isLoading: walletLoading, error: walletError, } = usePrivateWalletContext();
     const { setFacilitatorGroups } = useOrdersContext();
     useWalletFacilitatorGroups(wallet, setFacilitatorGroups);
     const tokenIn = useSwap((state) => state.tokenIn);
@@ -128,14 +119,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
         overheadUsd,
         setInputAmount, // Pass setInputAmount for reverse calculation
     });
-    useEffect(() => {
-        console.log('[SilentSwapInnerProvider] useEffect', { auth, walletClient, connector, wallet, walletLoading });
-        if (auth && walletClient && connector && !wallet && !walletLoading) {
-            generateWallet().catch((err) => {
-                console.error('Failed to generate wallet:', err);
-            });
-        }
-    }, [auth, walletClient, connector, wallet, walletLoading, generateWallet]);
+    // (Auto-trigger for generateWallet now lives inside PrivateWalletProvider.)
     const { executeSwap, isLoading: swapLoading, isSwapping, currentStep, error: swapError, quote, orderId, viewingAuth, clearQuote, depositAmountUsdc, loadingAmounts, } = useSilentQuote({
         client,
         address: effectiveQuoteAddress,
@@ -222,9 +206,12 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
             config,
             wallet,
             walletLoading,
+            walletError,
+            retryWallet: refreshWallet,
             auth,
             authLoading,
             authExhausted,
+            signIn,
             executeSwap,
             swapLoading,
             isSwapping,
@@ -278,5 +265,5 @@ export function SilentSwapProvider({ children, client, evmAddress, solAddress, c
             baseUrl: computedBaseUrl,
         };
     }, [environment, baseUrl]);
-    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, bitcoinAddress: bitcoinAddress, bitcoinRpcUrl: bitcoinRpcUrl, tronAddress: tronAddress, tronRpcUrl: tronRpcUrl, children: _jsx(OrdersProvider, { baseUrl: config.baseUrl, children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, bitcoinAddress: bitcoinAddress, tronAddress: tronAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, bitcoinConnector: bitcoinConnector, bitcoinConnection: bitcoinConnection, tronConnector: tronConnector, tronConnection: tronConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, proId: proId, requestWalletConnect: requestWalletConnect, forceBridgeProvider: forceBridgeProvider, onAuthStatus: onAuthStatus, onWalletStatus: onWalletStatus, children: children }) }) }) }) }));
+    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, bitcoinAddress: bitcoinAddress, bitcoinRpcUrl: bitcoinRpcUrl, tronAddress: tronAddress, tronRpcUrl: tronRpcUrl, children: _jsx(OrdersProvider, { baseUrl: config.baseUrl, children: _jsx(AuthProvider, { client: client, address: evmAddress, walletClient: walletClient, connector: connector, autoAuthenticate: true, onStatus: onAuthStatus, children: _jsx(PrivateWalletProvider, { client: client, address: evmAddress, walletClient: walletClient, connector: connector, allDeposits: true, autoGenerate: true, onStatus: onWalletStatus, children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, bitcoinAddress: bitcoinAddress, tronAddress: tronAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, bitcoinConnector: bitcoinConnector, bitcoinConnection: bitcoinConnection, tronConnector: tronConnector, tronConnection: tronConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, proId: proId, requestWalletConnect: requestWalletConnect, forceBridgeProvider: forceBridgeProvider, children: children }) }) }) }) }) }) }));
 }

package/dist/hooks/silent/useAuth.js

@@ -68,6 +68,12 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
     const hasAutoAuthenticatedRef = useRef(false);
     // Track retry count for auto-authentication (WalletConnect relay can drop requests)
     const autoAuthRetryCountRef = useRef(0);
+    // Track the pending retry timer so we can clear it on unmount / signOut
+    const retryTimerRef = useRef(null);
+    // Synchronous guard to prevent concurrent authenticate calls.
+    // React state (isLoading) is async/batched, so Strict Mode double-fire or
+    // rapid effect re-runs can trigger multiple signMessage prompts.
+    const inFlightRef = useRef(false);
     const AUTO_AUTH_MAX_RETRIES = 6;
     const AUTO_AUTH_RETRY_DELAY_MS = 5000;
     // Normalize address
@@ -136,6 +142,12 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
      * Perform SIWE authentication
      */
     const authenticate = useCallback(async () => {
+        // Synchronous guard — blocks concurrent callers in the same tick.
+        // Must be checked and set before any `await` to beat React's state batching.
+        if (inFlightRef.current) {
+            console.log('[useAuth:authenticate] skipped, already in flight');
+            return null;
+        }
         if (!client) {
             throw new Error('Client required for authentication');
         }
@@ -145,6 +157,7 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
         if (!walletClient) {
             throw new Error('Wallet client required for authentication');
         }
+        inFlightRef.current = true;
         setIsLoading(true);
         setError(null);
         try {
@@ -169,34 +182,51 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
             // the ping above tests relay connectivity, but a real RPC round-trip catches
             // cases where the relay is alive but the peer wallet is unresponsive.
             const LIVENESS_TIMEOUT_MS = 5_000;
+            let livenessTimeout;
             try {
                 await Promise.race([
                     walletClient.request({ method: 'eth_chainId' }),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error('Wallet liveness check timed out')), LIVENESS_TIMEOUT_MS)),
+                    new Promise((_, reject) => {
+                        livenessTimeout = setTimeout(() => reject(new Error('Wallet liveness check timed out')), LIVENESS_TIMEOUT_MS);
+                    }),
                 ]);
             }
             catch (livenessErr) {
                 throw new Error(`Wallet not responding to requests: ${livenessErr.message}`);
             }
+            finally {
+                if (livenessTimeout)
+                    clearTimeout(livenessTimeout);
+            }
             // Create SIWE message
             const siweMessage = createSignInMessageCallback(normalizedAddress, nonceValue, domain);
             // Notify consumer that a wallet signature is about to be requested
             onStatus?.('Please check your wallet and approve the sign-in request. This uses to load orders your orders from blockchain.');
             // Sign the message with timeout — WalletConnect relay can silently drop requests.
             const SIGN_TIMEOUT_MS = 30_000;
-            const signature = await Promise.race([
-                walletClient.signMessage({
-                    account: normalizedAddress,
-                    message: siweMessage.message,
-                }),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Wallet did not respond to sign-in request. The request may not have reached your wallet.')), SIGN_TIMEOUT_MS)),
-            ]);
+            let signTimeout;
+            let signature;
+            try {
+                signature = (await Promise.race([
+                    walletClient.signMessage({
+                        account: normalizedAddress,
+                        message: siweMessage.message,
+                    }),
+                    new Promise((_, reject) => {
+                        signTimeout = setTimeout(() => reject(new Error('Wallet did not respond to sign-in request. The request may not have reached your wallet.')), SIGN_TIMEOUT_MS);
+                    }),
+                ]));
+            }
+            finally {
+                if (signTimeout)
+                    clearTimeout(signTimeout);
+            }
             onStatus?.('Sign-in approved. Authenticating...');
             // Authenticate with server
             const [authError, authResponse] = await client.authenticate({
                 siwe: {
                     message: siweMessage.message,
-                    signature: signature,
+                    signature,
                 },
             });
             if (authError || !authResponse) {
@@ -214,9 +244,10 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
             return null;
         }
         finally {
+            inFlightRef.current = false;
             setIsLoading(false);
         }
-    }, [client, normalizedAddress, walletClient, nonce, getNonce, createSignInMessageCallback, domain, saveAuthCallback]);
+    }, [client, normalizedAddress, walletClient, connector, nonce, getNonce, createSignInMessageCallback, domain, saveAuthCallback, onStatus]);
     /**
      * Sign in (alias for authenticate for convenience)
      */
@@ -234,8 +265,14 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
         setNonce(null);
         setError(null);
         setIsAutoAuthenticating(false);
-        // Reset auto-authentication flag
+        setAuthExhausted(false);
+        // Reset auto-authentication flags + pending retry
         hasAutoAuthenticatedRef.current = false;
+        autoAuthRetryCountRef.current = 0;
+        if (retryTimerRef.current) {
+            clearTimeout(retryTimerRef.current);
+            retryTimerRef.current = null;
+        }
     }, [normalizedAddress]);
     /**
      * Check if user is authenticated
@@ -254,6 +291,10 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
             hasAutoAuthenticatedRef.current = false;
             autoAuthRetryCountRef.current = 0;
             setAuthExhausted(false);
+            if (retryTimerRef.current) {
+                clearTimeout(retryTimerRef.current);
+                retryTimerRef.current = null;
+            }
         }
         prevAddressRef.current = normalizedAddress;
     }, [normalizedAddress]);
@@ -269,6 +310,10 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
                 hasAutoAuthenticatedRef.current = false;
                 autoAuthRetryCountRef.current = 0;
                 setAuthExhausted(false);
+                if (retryTimerRef.current) {
+                    clearTimeout(retryTimerRef.current);
+                    retryTimerRef.current = null;
+                }
             }
         }
         prevWalletClientRef.current = walletClient;
@@ -317,8 +362,11 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
         const attemptNumber = autoAuthRetryCountRef.current + 1;
         console.log(`[useAuth] auto-authenticate attempt ${attemptNumber}/${AUTO_AUTH_MAX_RETRIES}`);
         setIsAutoAuthenticating(true);
+        let cancelled = false;
         authenticate()
             .then((result) => {
+            if (cancelled)
+                return;
             // authenticate() swallows errors and returns null on failure,
             // so only mark as completed if it actually succeeded.
             if (result) {
@@ -330,7 +378,10 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
                 // Retry after a delay by clearing error to re-trigger the effect.
                 autoAuthRetryCountRef.current += 1;
                 console.log(`[useAuth] auto-auth failed, scheduling retry ${autoAuthRetryCountRef.current + 1}/${AUTO_AUTH_MAX_RETRIES} in ${AUTO_AUTH_RETRY_DELAY_MS}ms`);
-                setTimeout(() => {
+                if (retryTimerRef.current)
+                    clearTimeout(retryTimerRef.current);
+                retryTimerRef.current = setTimeout(() => {
+                    retryTimerRef.current = null;
                     setError(null);
                 }, AUTO_AUTH_RETRY_DELAY_MS);
             }
@@ -344,9 +395,22 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
             console.error('Auto-authentication failed:', err);
         })
             .finally(() => {
-            setIsAutoAuthenticating(false);
+            if (!cancelled)
+                setIsAutoAuthenticating(false);
         });
+        return () => {
+            cancelled = true;
+        };
     }, [autoAuthenticate, normalizedAddress, walletClient, auth, isLoading, isAutoAuthenticating, error, authenticate, loadCachedAuthCallback]);
+    // Clear pending retry timer on unmount
+    useEffect(() => {
+        return () => {
+            if (retryTimerRef.current) {
+                clearTimeout(retryTimerRef.current);
+                retryTimerRef.current = null;
+            }
+        };
+    }, []);
     return {
         // State
         auth,

package/dist/hooks/silent/useWallet.js

@@ -47,8 +47,10 @@ export function useWallet({ client, address, auth, walletClient, connector, allD
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     // Synchronous guard to prevent concurrent generateWallet calls.
-    // React state (isLoading) is async/batched, so multiple callers can see
+    // React state (isLoading) is async/batched, so multiple callers (Strict Mode
+    // double-fire, effect re-runs from callback identity changes) can see
     // isLoading=false in the same tick and both trigger signTypedData prompts.
+    const inFlightRef = useRef(false);
     // Normalize address
     const normalizedAddress = address ? getAddress(address) : null;
     /**
@@ -158,31 +160,41 @@ export function useWallet({ client, address, auth, walletClient, connector, allD
         // the closure's walletClient which may be scoped to the pre-switch chain.
         // Race against a timeout: WalletConnect can silently drop signTypedData requests
         // (e.g. TrustWallet when the chain scope doesn't match), leaving users stuck forever.
-        console.log('[useWallet:generateEntropy] calling signTypedData ...', {
-            account: signingClient.account?.address,
-            domainChainId: String(eip712Doc.domain?.chainId),
-        });
         const SIGN_TIMEOUT_MS = 60_000;
-        const signature = await Promise.race([
-            signingClient.signTypedData({
-                ...eip712Doc,
-                account: signingClient.account,
-            }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Wallet did not respond to the signature request. '
-                + 'Please check your wallet app — you may need to manually switch to Ethereum mainnet and retry.')), SIGN_TIMEOUT_MS)),
-        ]);
-        console.log('[useWallet:generateEntropy] signTypedData succeeded, signature length:', signature.length);
-        onStatus?.('Signature approved. Setting up wallet...');
-        return hexToBytes(signature);
+        let timeoutHandle;
+        try {
+            const signature = await Promise.race([
+                signingClient.signTypedData({
+                    ...eip712Doc,
+                    account: signingClient.account,
+                }),
+                new Promise((_, reject) => {
+                    timeoutHandle = setTimeout(() => reject(new Error('Wallet did not respond to the signature request. '
+                        + 'Please check your wallet app — you may need to manually switch to Ethereum mainnet and retry.')), SIGN_TIMEOUT_MS);
+                }),
+            ]);
+            onStatus?.('Signature approved. Setting up wallet...');
+            return hexToBytes(signature);
+        }
+        finally {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+        }
     }, [auth, walletClient, connector, address, onStatus]);
     /**
      * Generate new wallet with facilitator accounts
      */
     const generateWallet = useCallback(async () => {
-        console.log('[useWallet:generateWallet] called', { normalizedAddress, allDeposits });
+        // Synchronous guard — blocks concurrent callers in the same tick.
+        // Must be checked and set before any `await` to beat React's state batching.
+        if (inFlightRef.current) {
+            console.log('[useWallet:generateWallet] skipped, already in flight');
+            return;
+        }
         if (!normalizedAddress) {
             throw new Error('Address required for wallet generation');
         }
+        inFlightRef.current = true;
         setIsLoading(true);
         setError(null);
         try {
@@ -246,6 +258,7 @@ export function useWallet({ client, address, auth, walletClient, connector, allD
             throw error;
         }
         finally {
+            inFlightRef.current = false;
             setIsLoading(false);
         }
     }, [normalizedAddress, getCachedWallet, generateEntropy, allDeposits, client.s0xGatewayAddress]);
@@ -259,18 +272,16 @@ export function useWallet({ client, address, auth, walletClient, connector, allD
         setWallet(null);
     }, [normalizedAddress]);
     /**
-     * Refresh wallet (regenerate if needed)
+     * Refresh wallet (regenerate if needed).
+     * User-initiated retry — bypasses the in-flight guard so a stuck
+     * signTypedData request (e.g. dropped silently by an in-app browser)
+     * doesn't permanently block future attempts.
      */
     const refreshWallet = useCallback(async () => {
+        inFlightRef.current = false;
         clearWallet();
         await generateWallet();
     }, [clearWallet, generateWallet]);
-    // When walletClient or connector changes (e.g. WalletConnect chain switch causes
-    // wagmi to recreate the walletClient), reset the generation guard. Any in-flight
-    // generation using stale WalletConnect references will hang on signTypedData,
-    // permanently blocking future calls.
-    useEffect(() => {
-    }, [walletClient, connector]);
     // Clear wallet when address changes (e.g. user switched from MetaMask to Phantom)
     const prevAddressRef = useRef(normalizedAddress);
     useEffect(() => {

package/dist/index.d.ts

@@ -11,6 +11,10 @@ export { OrdersProvider, useOrdersContext, useWalletFacilitatorGroups } from './
 export type { OrdersContextOrderMetadata, OrdersContextOrder, OrderDestination, FacilitatorGroup, OrdersContextType } from './contexts/OrdersContext.js';
 export { SilentSwapProvider, useSilentSwap } from './contexts/SilentSwapContext.js';
 export type { SilentSwapContextType, SilentSwapStatusData, SilentSwapFees, SilentSwapOrderTracking, SilentSwapEstimates, } from './contexts/SilentSwapContext.js';
+export { AuthProvider, useAuthContext } from './contexts/AuthContext.js';
+export type { AuthContextValue, AuthProviderProps } from './contexts/AuthContext.js';
+export { PrivateWalletProvider, usePrivateWalletContext } from './contexts/PrivateWalletContext.js';
+export type { PrivateWalletContextValue, PrivateWalletProviderProps } from './contexts/PrivateWalletContext.js';
 export { useSilentOrders } from './hooks/silent/useSilentOrders.js';
 export { useAuth } from './hooks/silent/useAuth.js';
 export { useWallet } from './hooks/silent/useWallet.js';

package/dist/index.js

@@ -5,6 +5,8 @@ export { AssetsProvider, useAssetsContext } from './contexts/AssetsContext.js';
 export { BalancesProvider, useBalancesContext } from './contexts/BalancesContext.js';
 export { OrdersProvider, useOrdersContext, useWalletFacilitatorGroups } from './contexts/OrdersContext.js';
 export { SilentSwapProvider, useSilentSwap } from './contexts/SilentSwapContext.js';
+export { AuthProvider, useAuthContext } from './contexts/AuthContext.js';
+export { PrivateWalletProvider, usePrivateWalletContext } from './contexts/PrivateWalletContext.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.1.52",
+  "version": "0.1.53",
   "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.52",
-    "@silentswap/ui-kit": "0.1.52",
+    "@silentswap/sdk": "0.1.53",
+    "@silentswap/ui-kit": "0.1.53",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",