@n1xyz/wallet-widget 0.0.35-alpha.0 → 0.0.35-alpha.1

package/dist/src/features/onboarding-flow/providers/WalletConnectionProvider.js

@@ -0,0 +1,938 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
+import { useTurnkey } from '../../../turnkey';
+import { useN1WalletContext } from '../../../hooks';
+import { useNetwork } from '../../../providers/N1WalletProvider/NetworkProvider';
+import { useSession } from '../../../providers/N1WalletProvider/SessionProvider';
+import { useModal, useModalActions } from '../../../providers/N1WalletProvider/ModalProvider';
+import { useSigningActions } from '../../../providers/N1WalletProvider/SigningProvider';
+import { logger } from '../../../utils/logger';
+import { EVENTS, createWalletEvent } from '../../../utils/events';
+import { createWalletError } from '../../../utils/errors';
+import { OnboardingStep, initialOnboardingContext } from '../types';
+import { useOnboardingState } from './OnboardingStateProvider';
+import { clearLastDepositRecord, readLastDepositRecord, readPendingDeposit } from '../utils/deposit/storage';
+import { N1ModalViewMode } from '../../../types/wallet';
+import { removeKeysFromLocalStorage } from '../utils/utils';
+import { SolanaNetwork } from '../../../config/solana';
+import { clearSession, clearPendingDeposit, } from '../../../services/bootstrap';
+var WALLET_CONNECTION_STEPS = new Set([
+    OnboardingStep.CONNECTING_WALLET,
+    OnboardingStep.TURNKEY_AUTH,
+    OnboardingStep.TURNKEY_PREPARING,
+]);
+var isWalletConnectionStep = function (step) {
+    return WALLET_CONNECTION_STEPS.has(step);
+};
+var useOptionalTurnkey = function () {
+    try {
+        return useTurnkey();
+    }
+    catch (_a) {
+        return null;
+    }
+};
+export var FLOW_STATE_STORAGE_KEY = 'n1_wallet_connection_flow_state';
+// Create the context with a default value
+var WalletConnectionContext = createContext(undefined);
+/**
+ * Provider component for the wallet connection context
+ */
+export var WalletConnectionProvider = function (_a) {
+    var _b, _c, _d, _e, _f;
+    var children = _a.children;
+    // Use new providers for wallet/session/modal state
+    var _g = useNetwork(), solanaAddress = _g.solanaAddress, solanaWallet = _g.solanaWallet, evmWallet = _g.evmWallet, setSolanaAddress = _g.setSolanaAddress, setSolanaWallet = _g.setSolanaWallet, setEvmWallet = _g.setEvmWallet, setEvmAddress = _g.setEvmAddress, setEvmChain = _g.setEvmChain, setPreferredWalletNetwork = _g.setPreferredWalletNetwork, setBalances = _g.setBalances;
+    var _h = useSession(), nordUser = _h.nordUser, dynamicSdkHasLoaded = _h.dynamicSdkHasLoaded, turnkeyEnabled = _h.turnkeyEnabled, setIsConnected = _h.setIsConnected, setNordUser = _h.setNordUser, setSessionPubKey = _h.setSessionPubKey, setWalletPubKey = _h.setWalletPubKey;
+    var _j = useModal(), showLogin = _j.showLogin, closeModal = _j.closeModal, onCloseComplete = _j.onCloseComplete, showDynamicWidget = _j.showDynamicWidget, dynamicHandleLogOut = _j.dynamicHandleLogOut, setViewMode = _j.setViewMode;
+    // nord client still comes from legacy context (passed as prop)
+    var nord = useN1WalletContext().nord;
+    // Signing setters from SigningProvider
+    var _k = useSigningActions(), setSignMessageWithSessionKey = _k.setSignMessageWithSessionKey, setSignMessageWithWalletKey = _k.setSignMessageWithWalletKey, setSignTransactionWithWalletKey = _k.setSignTransactionWithWalletKey;
+    // Disconnect handler from ModalProvider
+    var setDisconnectWalletHandler = useModalActions().setDisconnectWalletHandler;
+    // Get flow context
+    var _l = useOnboardingState(), state = _l.state, context = _l.context, flowActions = _l.actions, updateContext = _l.updateContext;
+    var _m = useState(false), isConnecting = _m[0], setIsConnecting = _m[1];
+    var dynamicWidgetRequestedRef = useRef(false);
+    var skipAutoResumeRef = useRef(false);
+    var turnkeyContext = useOptionalTurnkey();
+    var turnkey = turnkeyEnabled ? turnkeyContext : null;
+    var previousEvmWalletAddressRef = useRef(null);
+    var turnkeyAuthenticatedEvmAddressRef = useRef(null);
+    var lastConnectedWalletRef = useRef({
+        evm: null,
+        solana: null,
+    });
+    var getUserCacheRef = useRef(null);
+    var getUserInFlightRef = useRef(null);
+    var lastProcessedGetUserRef = useRef(null);
+    var GET_USER_CACHE_TTL_MS = 10000; // Cache getUser results for 10 seconds
+    var turnkeyStatus = (_b = turnkey === null || turnkey === void 0 ? void 0 : turnkey.turnkeyStatus) !== null && _b !== void 0 ? _b : (turnkeyEnabled ? 'idle' : 'ready');
+    var turnkeyError = (_c = turnkey === null || turnkey === void 0 ? void 0 : turnkey.turnkeyError) !== null && _c !== void 0 ? _c : null;
+    var turnkeyAddress = (_d = turnkey === null || turnkey === void 0 ? void 0 : turnkey.turnkeyAddress) !== null && _d !== void 0 ? _d : null;
+    var retryTurnkeyBootstrap = (_e = turnkey === null || turnkey === void 0 ? void 0 : turnkey.retryTurnkeyBootstrap) !== null && _e !== void 0 ? _e : (function () { });
+    var prepareTurnkeyWallet = turnkey === null || turnkey === void 0 ? void 0 : turnkey.prepareTurnkeyWallet;
+    var evmWalletAddress = useMemo(function () { var _a, _b, _c; return (_c = (_b = (_a = evmWallet === null || evmWallet === void 0 ? void 0 : evmWallet.address) === null || _a === void 0 ? void 0 : _a.toLowerCase) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null; }, [evmWallet === null || evmWallet === void 0 ? void 0 : evmWallet.address]);
+    var solanaWalletAddress = useMemo(function () { var _a; return (_a = solanaWallet === null || solanaWallet === void 0 ? void 0 : solanaWallet.address) !== null && _a !== void 0 ? _a : null; }, [solanaWallet === null || solanaWallet === void 0 ? void 0 : solanaWallet.address]);
+    // Auto-resume the flow if a wallet was restored so we don't strand users on EntrySelection
+    useEffect(function () {
+        if (!dynamicSdkHasLoaded) {
+            return;
+        }
+        if (skipAutoResumeRef.current) {
+            logger.debug('[WalletConnection] Skipping auto-resume after wallet switch');
+            skipAutoResumeRef.current = false;
+            return;
+        }
+        if (context.entryNetwork) {
+            return;
+        }
+        if (state !== OnboardingStep.ENTRY_SELECTION) {
+            return;
+        }
+        // Skip auto-resume if Turnkey is in error state - let the retry handle it first
+        if (turnkeyEnabled && turnkeyStatus === 'error') {
+            logger.debug('[WalletConnection] Skipping auto-resume - Turnkey in error state, waiting for retry');
+            return;
+        }
+        var walletChain = (solanaWallet === null || solanaWallet === void 0 ? void 0 : solanaWallet.chain)
+            ? String(solanaWallet.chain).toUpperCase()
+            : '';
+        var restoredNetwork = evmWallet || walletChain.startsWith('ETH') || walletChain.startsWith('ARB') || walletChain.startsWith('BASE')
+            ? 'evm'
+            : walletChain.startsWith('SOL')
+                ? 'solana'
+                : null;
+        if (!restoredNetwork) {
+            return;
+        }
+        logger.debug("[WalletConnection] Auto-selecting entry network from restored wallet", {
+            restoredNetwork: restoredNetwork,
+            hasEvmWallet: Boolean(evmWallet),
+            walletChain: walletChain,
+        });
+        flowActions.beginWalletConnection(restoredNetwork);
+    }, [context.entryNetwork, dynamicSdkHasLoaded, solanaWallet, evmWallet, flowActions, state, turnkeyEnabled, turnkeyStatus]);
+    useEffect(function () {
+        var _a = lastConnectedWalletRef.current, previousEvm = _a.evm, previousSolana = _a.solana;
+        var evmSwitched = Boolean(previousEvm && evmWalletAddress && previousEvm !== evmWalletAddress);
+        var solanaSwitched = Boolean(previousSolana && solanaWalletAddress && previousSolana !== solanaWalletAddress);
+        if (evmSwitched || solanaSwitched) {
+            logger.debug('Wallet switch detected; resetting onboarding flow', {
+                previousEvm: previousEvm,
+                currentEvm: evmWalletAddress,
+                previousSolana: previousSolana,
+                currentSolana: solanaWalletAddress,
+            });
+            skipAutoResumeRef.current = true;
+            flowActions.resetFlow();
+        }
+        lastConnectedWalletRef.current = {
+            evm: evmWalletAddress,
+            solana: solanaWalletAddress,
+        };
+    }, [evmWalletAddress, solanaWalletAddress, flowActions]);
+    useEffect(function () {
+        if (!turnkeyEnabled) {
+            return;
+        }
+        var previousAddress = previousEvmWalletAddressRef.current;
+        if (previousAddress === evmWalletAddress) {
+            return;
+        }
+        previousEvmWalletAddressRef.current = evmWalletAddress;
+        turnkeyAuthenticatedEvmAddressRef.current = null;
+        retryTurnkeyBootstrap();
+    }, [evmWalletAddress, retryTurnkeyBootstrap, turnkeyEnabled]);
+    // Use refs to track previous values
+    var processedWalletAddressRef = useRef(null);
+    var prevNordUserRef = useRef(nordUser);
+    var prevSessionIdRef = useRef((nordUser === null || nordUser === void 0 ? void 0 : nordUser.sessionId) ? nordUser.sessionId.toString() : null);
+    var prevStateRef = useRef(state);
+    var reportedNordClientErrorRef = useRef(false);
+    var clearWalletCache = useCallback(function () {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        try {
+            if (solanaAddress) {
+                var sessionIdKey = "n1_sessionId_".concat(solanaAddress);
+                window.localStorage.removeItem(sessionIdKey);
+                removeKeysFromLocalStorage(solanaAddress);
+            }
+            window.localStorage.removeItem(FLOW_STATE_STORAGE_KEY);
+            clearLastDepositRecord(solanaAddress);
+            updateContext(initialOnboardingContext);
+            logger.debug('Cleared wallet cache for address', { address: solanaAddress });
+        }
+        catch (error) {
+            logger.warn('Failed to clear wallet cache', error);
+        }
+    }, [solanaAddress, updateContext]);
+    var closeDynamicWidget = useCallback(function () {
+        if (!dynamicWidgetRequestedRef.current) {
+            return;
+        }
+        if (showDynamicWidget) {
+            try {
+                showDynamicWidget(false);
+            }
+            catch (error) {
+                logger.warn('Failed to close Dynamic widget', error);
+            }
+        }
+        dynamicWidgetRequestedRef.current = false;
+    }, [showDynamicWidget]);
+    /**
+     * Disconnect wallet
+     */
+    var disconnectWallet = useCallback(function () {
+        var currentAddress = solanaWalletAddress || evmWalletAddress;
+        logger.event(createWalletEvent(EVENTS.WALLET.DISCONNECT, {
+            address: currentAddress,
+            network: solanaWalletAddress ? 'solana' : evmWalletAddress ? 'evm' : null,
+        }));
+        try {
+            clearWalletCache();
+            dynamicHandleLogOut === null || dynamicHandleLogOut === void 0 ? void 0 : dynamicHandleLogOut();
+            closeDynamicWidget();
+            // Clear cached address from localStorage
+            if (typeof window !== 'undefined') {
+                window.localStorage.removeItem('n1_last_connected_address');
+            }
+        }
+        catch (error) {
+            logger.logError(createWalletError('DISCONNECT_FAILED', 'Error during wallet disconnect', {
+                cause: error instanceof Error ? error : undefined,
+                context: { address: currentAddress },
+            }));
+        }
+        processedWalletAddressRef.current = null;
+        turnkeyAuthenticatedEvmAddressRef.current = null;
+        previousEvmWalletAddressRef.current = null;
+        setIsConnected(false);
+        setSolanaAddress('');
+        setBalances([]);
+        setSolanaWallet(null);
+        setEvmWallet(null);
+        setEvmAddress(null);
+        setEvmChain(null);
+        setSessionPubKey(null);
+        setWalletPubKey(null);
+        setSignMessageWithSessionKey(null);
+        setSignMessageWithWalletKey(null);
+        setSignTransactionWithWalletKey(null);
+        setNordUser(null);
+        setViewMode(N1ModalViewMode.Automatic);
+        // Close modal via state machine (triggers closing → closed transition)
+        closeModal();
+        onCloseComplete();
+        flowActions.resetFlow();
+        setPreferredWalletNetwork(null);
+        // Clear any pending deposit to prevent it from being shown on a different wallet
+        clearPendingDeposit();
+        if (turnkeyEnabled) {
+            // Pass no address to unconditionally clear the session
+            // (passing evmWalletAddress would fail if stored session belongs to different wallet)
+            clearSession();
+        }
+    }, [
+        clearWalletCache,
+        closeDynamicWidget,
+        dynamicHandleLogOut,
+        setSolanaAddress,
+        setBalances,
+        setSolanaWallet,
+        setIsConnected,
+        setNordUser,
+        setSessionPubKey,
+        setSignMessageWithSessionKey,
+        setSignMessageWithWalletKey,
+        setSignTransactionWithWalletKey,
+        setViewMode,
+        setWalletPubKey,
+        flowActions,
+        setEvmWallet,
+        setEvmAddress,
+        setEvmChain,
+        solanaWalletAddress,
+        evmWalletAddress,
+        turnkeyEnabled,
+        setPreferredWalletNetwork,
+        closeModal,
+        onCloseComplete,
+    ]);
+    useEffect(function () {
+        setDisconnectWalletHandler(function () { return disconnectWallet; });
+    }, [disconnectWallet, setDisconnectWalletHandler]);
+    useEffect(function () {
+        if (state === OnboardingStep.CONNECTING_WALLET) {
+            processedWalletAddressRef.current = null;
+        }
+    }, [state]);
+    useEffect(function () {
+        if (!turnkeyEnabled ||
+            !evmWallet ||
+            context.entryNetwork !== 'evm' ||
+            !prepareTurnkeyWallet ||
+            turnkeyStatus !== 'idle') {
+            return;
+        }
+        prepareTurnkeyWallet().catch(function (error) {
+            logger.logError(createWalletError('CONNECT_FAILED', 'Turnkey bootstrap failed', {
+                cause: error instanceof Error ? error : undefined,
+            }));
+        });
+    }, [
+        context.entryNetwork,
+        evmWallet,
+        logger,
+        prepareTurnkeyWallet,
+        turnkeyEnabled,
+        turnkeyStatus,
+    ]);
+    useEffect(function () {
+        setPreferredWalletNetwork(context.entryNetwork);
+    }, [context.entryNetwork, setPreferredWalletNetwork]);
+    useEffect(function () {
+        var inTurnkeyState = state === OnboardingStep.TURNKEY_AUTH ||
+            state === OnboardingStep.TURNKEY_PREPARING;
+        // If we are in DEPOSIT_PROGRESS (e.g. recovering a bridge deposit),
+        // do not allow Turnkey status updates to hijack the view.
+        // Authentication happens in the background.
+        if (state === OnboardingStep.DEPOSIT_PROGRESS) {
+            return;
+        }
+        if (!turnkeyEnabled || context.entryNetwork === 'solana') {
+            if (inTurnkeyState) {
+                flowActions.returnToWalletConnection();
+            }
+            return;
+        }
+        if (turnkeyStatus === 'authenticating') {
+            if (state !== OnboardingStep.TURNKEY_AUTH) {
+                flowActions.enterTurnkeyAuth();
+            }
+            return;
+        }
+        if (turnkeyStatus === 'creating') {
+            if (state !== OnboardingStep.TURNKEY_PREPARING) {
+                flowActions.enterTurnkeyPreparing();
+            }
+            return;
+        }
+        if (turnkeyStatus === 'ready' &&
+            (state === OnboardingStep.TURNKEY_AUTH || state === OnboardingStep.TURNKEY_PREPARING)) {
+            // When bootstrap completes, leave the Turnkey-specific steps.
+            flowActions.goToChainSelection();
+            return;
+        }
+        if (turnkeyStatus === 'error') {
+            // Only set error state if we're actively in the Turnkey flow, not if user has reset
+            var isInTurnkeyFlow = state === OnboardingStep.CONNECTING_WALLET ||
+                state === OnboardingStep.TURNKEY_AUTH ||
+                state === OnboardingStep.TURNKEY_PREPARING;
+            if (isInTurnkeyFlow) {
+                logger.logError(createWalletError('CONNECT_FAILED', turnkeyError || 'Turnkey initialization failed'));
+                flowActions.setErrorState(new Error(turnkeyError || 'Turnkey initialization failed'));
+            }
+            return;
+        }
+    }, [turnkeyStatus, turnkeyEnabled, flowActions, state, context.entryNetwork]);
+    // If the user picked the EVM path but Dynamic silently restored a Solana session,
+    // clear it so the widget can prompt for an EVM wallet instead of hijacking with Phantom.
+    useEffect(function () {
+        if (context.entryNetwork !== 'evm') {
+            return;
+        }
+        if (!solanaWallet) {
+            return;
+        }
+        var walletChain = solanaWallet.chain
+            ? String(solanaWallet.chain).toUpperCase()
+            : '';
+        var isTurnkeySolana = (solanaWallet === null || solanaWallet === void 0 ? void 0 : solanaWallet.type) === 'turnkey' && walletChain.startsWith('SOL');
+        var isSolanaWallet = walletChain.startsWith('SOL');
+        if (!isSolanaWallet || isTurnkeySolana) {
+            return;
+        }
+        logger.debug('Solana wallet restored during EVM entry; clearing Dynamic session');
+        if (dynamicHandleLogOut) {
+            dynamicHandleLogOut().catch(function (error) {
+                logger.warn('Failed to log out of restored Solana wallet', error);
+            });
+        }
+        setSolanaWallet(null);
+        setSolanaAddress('');
+        setEvmWallet(null);
+        setEvmAddress(null);
+        setEvmChain(null);
+    }, [
+        context.entryNetwork,
+        dynamicHandleLogOut,
+        solanaWallet,
+        logger,
+        setSolanaAddress,
+        setSolanaWallet,
+        setEvmAddress,
+        setEvmChain,
+        setEvmWallet,
+    ]);
+    /**
+     * Connect wallet using Dynamic widget
+     */
+    var connectWallet = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var wantsEvm, walletChain, isTurnkeySolana, hasSolanaWallet, hasEvmWallet, error_1, hasMatchingWallet, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (isConnecting || !showDynamicWidget || !dynamicSdkHasLoaded)
+                        return [2 /*return*/];
+                    wantsEvm = context.entryNetwork === 'evm';
+                    walletChain = (solanaWallet === null || solanaWallet === void 0 ? void 0 : solanaWallet.chain) ? String(solanaWallet.chain).toUpperCase() : '';
+                    isTurnkeySolana = (solanaWallet === null || solanaWallet === void 0 ? void 0 : solanaWallet.type) === 'turnkey' && walletChain.startsWith('SOL');
+                    hasSolanaWallet = walletChain.startsWith('SOL') && !isTurnkeySolana;
+                    hasEvmWallet = Boolean(evmWalletAddress);
+                    if (!(wantsEvm && hasSolanaWallet && dynamicHandleLogOut)) return [3 /*break*/, 4];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, dynamicHandleLogOut()];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _a.sent();
+                    logger.warn('Failed to log out of existing Solana wallet before EVM connect', error_1);
+                    return [3 /*break*/, 4];
+                case 4:
+                    hasMatchingWallet = (context.entryNetwork === 'solana' &&
+                        (walletChain.startsWith('SOL') || isTurnkeySolana)) ||
+                        (context.entryNetwork === 'evm' && hasEvmWallet);
+                    if (hasMatchingWallet) {
+                        logger.debug('Wallet already available for selected entry; skipping widget open', {
+                            entryNetwork: context.entryNetwork,
+                            hasEvmWallet: hasEvmWallet,
+                            turnkeyEnabled: turnkeyEnabled,
+                            turnkeyStatus: turnkeyStatus,
+                        });
+                        // Wallet is already connected - need to proceed to next step
+                        // For EVM with Turnkey: the turnkeyStatus effect will handle transition
+                        // For Solana: need to trigger chain selection
+                        if (context.entryNetwork === 'solana') {
+                            flowActions.goToChainSelection();
+                        }
+                        // For EVM: Turnkey bootstrap should already be running via TurnkeyProvider effect
+                        // If it's not, we may need to trigger it - log current status for debugging
+                        if (context.entryNetwork === 'evm' && turnkeyEnabled) {
+                            logger.debug('EVM wallet connected, waiting for Turnkey bootstrap', {
+                                turnkeyStatus: turnkeyStatus,
+                                turnkeyError: turnkeyError,
+                            });
+                        }
+                        return [2 /*return*/];
+                    }
+                    setIsConnecting(true);
+                    logger.event(createWalletEvent(EVENTS.WALLET.CONNECT_START, {
+                        network: context.entryNetwork,
+                    }));
+                    dynamicWidgetRequestedRef.current = true;
+                    _a.label = 5;
+                case 5:
+                    _a.trys.push([5, 7, , 8]);
+                    return [4 /*yield*/, showDynamicWidget(true)];
+                case 6:
+                    _a.sent();
+                    logger.debug('Dynamic widget shown');
+                    return [3 /*break*/, 8];
+                case 7:
+                    error_2 = _a.sent();
+                    dynamicWidgetRequestedRef.current = false;
+                    setIsConnecting(false);
+                    logger.logError(createWalletError('CONNECT_FAILED', 'Dynamic widget could not be shown', {
+                        cause: error_2 instanceof Error ? error_2 : undefined,
+                        context: { network: context.entryNetwork },
+                    }));
+                    return [3 /*break*/, 8];
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        context.entryNetwork,
+        dynamicHandleLogOut,
+        dynamicSdkHasLoaded,
+        solanaWallet,
+        evmWalletAddress,
+        isConnecting,
+        showDynamicWidget,
+    ]);
+    useEffect(function () {
+        if (!dynamicSdkHasLoaded) {
+            return;
+        }
+        if (nord) {
+            reportedNordClientErrorRef.current = false;
+            return;
+        }
+        if (typeof nord === 'undefined') {
+            // Nord client is still initializing; wait before reporting an error
+            return;
+        }
+        if (reportedNordClientErrorRef.current) {
+            setIsConnecting(false);
+            return;
+        }
+        reportedNordClientErrorRef.current = true;
+        setIsConnecting(false);
+        flowActions.setErrorState(new Error('The client could not be initialized. Verify your Nord environment variables and try again.'));
+    }, [dynamicSdkHasLoaded, nord, flowActions]);
+    // Process nordUser changes
+    useEffect(function () {
+        var _a;
+        if (!dynamicSdkHasLoaded || !nordUser || !solanaWallet)
+            return;
+        // Early exit if we have a pending bridge deposit - don't run any transition logic
+        var pendingEarlyCheck = readPendingDeposit();
+        logger.info('[WalletConnection] Early exit check for pending deposit', {
+            pendingEarlyCheck: pendingEarlyCheck,
+            pendingStringified: JSON.stringify(pendingEarlyCheck),
+            hasPendingEarly: !!pendingEarlyCheck,
+            currentState: state,
+        });
+        var hasPendingBridgeEarly = pendingEarlyCheck &&
+            (pendingEarlyCheck.stage === 'bridge_submitted' ||
+                pendingEarlyCheck.stage === 'bridge_confirmed' ||
+                (pendingEarlyCheck.stage === 'failed' && pendingEarlyCheck.tx)) &&
+            pendingEarlyCheck.tx;
+        logger.info('[WalletConnection] Early exit check result', {
+            hasPendingBridgeEarly: hasPendingBridgeEarly,
+            pendingStage: pendingEarlyCheck === null || pendingEarlyCheck === void 0 ? void 0 : pendingEarlyCheck.stage,
+            pendingTx: !!(pendingEarlyCheck === null || pendingEarlyCheck === void 0 ? void 0 : pendingEarlyCheck.tx),
+            pendingTxValue: pendingEarlyCheck === null || pendingEarlyCheck === void 0 ? void 0 : pendingEarlyCheck.tx,
+        });
+        if (hasPendingBridgeEarly) {
+            logger.info('[WalletConnection] Effect early exit: pending bridge deposit detected, skipping all logic', {
+                pendingStage: pendingEarlyCheck.stage,
+                pendingTx: pendingEarlyCheck.tx,
+                currentState: state,
+            });
+            return;
+        }
+        var currentNordUser = nordUser;
+        var prevNordUser = prevNordUserRef.current;
+        var currentSessionId = currentNordUser.sessionId
+            ? currentNordUser.sessionId.toString()
+            : null;
+        var prevSessionId = prevSessionIdRef.current;
+        var walletAddress = (_a = solanaWallet.address) !== null && _a !== void 0 ? _a : null;
+        var hasProcessedWallet = walletAddress != null && processedWalletAddressRef.current === walletAddress;
+        // Early return if nothing meaningful changed
+        if (currentNordUser === prevNordUser &&
+            currentSessionId === prevSessionId &&
+            hasProcessedWallet) {
+            return;
+        }
+        // Check cache FIRST (synchronously) before starting any async work
+        var cached = getUserCacheRef.current;
+        var now = Date.now();
+        var isCacheValid = cached &&
+            cached.address === walletAddress &&
+            (now - cached.timestamp) < GET_USER_CACHE_TTL_MS;
+        // Check if we've already processed this exact combination (prevents rapid re-processing)
+        var lastProcessed = lastProcessedGetUserRef.current;
+        var isSameState = lastProcessed &&
+            lastProcessed.nordUser === currentNordUser &&
+            lastProcessed.sessionId === currentSessionId &&
+            lastProcessed.address === walletAddress;
+        // If we have valid cache AND same state, skip entirely
+        if (isCacheValid && isSameState) {
+            logger.debug('NordUser changed, cache valid and same state, skipping duplicate processing', {
+                cacheAge: "".concat(now - cached.timestamp, "ms"),
+            });
+            return;
+        }
+        // If we have valid cache but different state, we can still use cache but need to process
+        // If we have in-flight request, wait for it instead of starting new one
+        if (getUserInFlightRef.current && !isCacheValid) {
+            logger.debug('NordUser changed, getUser already in flight, skipping duplicate call');
+            return;
+        }
+        // Prevent concurrent execution
+        if (getUserInFlightRef.current) {
+            logger.debug('NordUser changed, getUser already in flight, skipping');
+            return;
+        }
+        prevNordUserRef.current = currentNordUser;
+        prevSessionIdRef.current = currentSessionId;
+        if (walletAddress) {
+            // Clear getUser cache if wallet address changed
+            var isNewWallet = processedWalletAddressRef.current !== walletAddress;
+            if (isNewWallet) {
+                getUserCacheRef.current = null;
+                logger.debug('Wallet address changed, cleared getUser cache');
+                // Log wallet connect success when a new wallet is processed
+                var isSolana = (solanaWallet === null || solanaWallet === void 0 ? void 0 : solanaWallet.chain) ? String(solanaWallet.chain).toUpperCase().startsWith('SOL') : false;
+                logger.event(createWalletEvent(EVENTS.WALLET.CONNECT_SUCCESS, {
+                    address: walletAddress,
+                    network: isSolana ? 'solana' : 'evm',
+                }));
+            }
+            processedWalletAddressRef.current = walletAddress;
+        }
+        // Mark this combination as being processed
+        lastProcessedGetUserRef.current = {
+            nordUser: currentNordUser,
+            sessionId: currentSessionId,
+            address: walletAddress !== null && walletAddress !== void 0 ? walletAddress : '',
+        };
+        // Only run if we have processed a wallet
+        if (solanaWallet) {
+            logger.debug('NordUser changed, checking account status', {
+                sessionIdChanged: currentSessionId !== prevSessionId,
+                nordUserChanged: currentNordUser !== prevNordUser,
+                walletChanged: processedWalletAddressRef.current !== walletAddress,
+                hasCache: Boolean(cached),
+                cacheValid: isCacheValid,
+            });
+            var runGetUser = (function () { return __awaiter(void 0, void 0, void 0, function () {
+                var nordAccount, cachedInside, nowInside, isCacheValidInside, getUserPromise, hasNordAccount, sessionId, sessionIdString, serverSessions, sessionMatchesServer, sessionIdKey, hasActiveSession, accountBalances, hasExistingBalance, pending, hasPendingBridgeDeposit, lastDepositRecord, isSolanaEntry, pendingCheck, hasPendingBridgeDepositCheck, error_3;
+                var _a, _b, _c, _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            _e.trys.push([0, 4, 5, 6]);
+                            if (!nord) {
+                                throw new Error('Nord client is not available.');
+                            }
+                            nordAccount = void 0;
+                            cachedInside = getUserCacheRef.current;
+                            nowInside = Date.now();
+                            isCacheValidInside = cachedInside &&
+                                cachedInside.address === solanaWallet.address &&
+                                (nowInside - cachedInside.timestamp) < GET_USER_CACHE_TTL_MS;
+                            if (!isCacheValidInside) return [3 /*break*/, 1];
+                            logger.debug('NordUser changed, using cached getUser result (checked inside async)', {
+                                cacheAge: "".concat(nowInside - cachedInside.timestamp, "ms"),
+                            });
+                            nordAccount = cachedInside.result;
+                            return [3 /*break*/, 3];
+                        case 1:
+                            logger.debug('NordUser changed, calling getUser (cache miss or expired)', {
+                                hasCache: Boolean(cachedInside),
+                                cacheAddress: ((_a = cachedInside === null || cachedInside === void 0 ? void 0 : cachedInside.address) === null || _a === void 0 ? void 0 : _a.substring(0, 10)) + "...",
+                                currentAddress: ((_b = solanaWallet.address) === null || _b === void 0 ? void 0 : _b.substring(0, 10)) + "...",
+                            });
+                            getUserPromise = nord.getUser({ pubkey: solanaWallet.address });
+                            getUserInFlightRef.current = getUserPromise;
+                            return [4 /*yield*/, getUserPromise];
+                        case 2:
+                            nordAccount = _e.sent();
+                            // Cache the result immediately
+                            getUserCacheRef.current = {
+                                address: solanaWallet.address,
+                                result: nordAccount,
+                                timestamp: Date.now(),
+                            };
+                            _e.label = 3;
+                        case 3:
+                            hasNordAccount = nordAccount != null;
+                            sessionId = currentNordUser.sessionId;
+                            sessionIdString = sessionId ? sessionId.toString() : null;
+                            serverSessions = (_c = nordAccount === null || nordAccount === void 0 ? void 0 : nordAccount.sessions) !== null && _c !== void 0 ? _c : {};
+                            sessionMatchesServer = sessionIdString != null && Boolean(serverSessions === null || serverSessions === void 0 ? void 0 : serverSessions[sessionIdString]);
+                            if (sessionIdString && !sessionMatchesServer) {
+                                logger.debug('Stored session is missing on Nord; clearing cached session ID');
+                                if (typeof window !== 'undefined') {
+                                    try {
+                                        sessionIdKey = "n1_sessionId_".concat(solanaWallet.address);
+                                        window.localStorage.removeItem(sessionIdKey);
+                                    }
+                                    catch (storageError) {
+                                        logger.warn('Failed to clear stale sessionId from localStorage', storageError);
+                                    }
+                                }
+                            }
+                            hasActiveSession = sessionMatchesServer;
+                            accountBalances = (_d = nordAccount === null || nordAccount === void 0 ? void 0 : nordAccount.balances) !== null && _d !== void 0 ? _d : [];
+                            hasExistingBalance = Array.isArray(accountBalances) &&
+                                accountBalances.some(function (b) { return typeof (b === null || b === void 0 ? void 0 : b.amount) === 'number' && b.amount > 0; });
+                            updateContext({ hasNordAccount: hasNordAccount, hasActiveSession: hasActiveSession, hasExistingBalance: hasExistingBalance });
+                            logger.debug('Nord account check', {
+                                walletAddress: solanaWallet.address,
+                                hasNordAccount: hasNordAccount,
+                                hasActiveSession: hasActiveSession,
+                                hasExistingBalance: hasExistingBalance,
+                                balanceCount: accountBalances.length,
+                                sessionId: sessionIdString,
+                                serverSessions: Object.keys(serverSessions !== null && serverSessions !== void 0 ? serverSessions : {}),
+                            });
+                            pending = readPendingDeposit();
+                            logger.info('[WalletConnection] Raw pending deposit check', {
+                                pending: pending,
+                                pendingStringified: JSON.stringify(pending),
+                                hasPending: !!pending,
+                            });
+                            hasPendingBridgeDeposit = pending &&
+                                (pending.stage === 'bridge_submitted' ||
+                                    pending.stage === 'bridge_confirmed' ||
+                                    (pending.stage === 'failed' && pending.tx)) &&
+                                pending.tx;
+                            logger.info('[WalletConnection] Checking for pending bridge deposit', {
+                                hasPending: !!pending,
+                                pendingStage: pending === null || pending === void 0 ? void 0 : pending.stage,
+                                pendingTx: !!(pending === null || pending === void 0 ? void 0 : pending.tx),
+                                pendingTxValue: pending === null || pending === void 0 ? void 0 : pending.tx,
+                                hasPendingBridgeDeposit: hasPendingBridgeDeposit,
+                                currentState: state,
+                                stageMatch: pending ? (pending.stage === 'bridge_submitted' || pending.stage === 'bridge_confirmed' || (pending.stage === 'failed' && pending.tx)) : false,
+                                stageCheck: pending ? {
+                                    isBridgeSubmitted: pending.stage === 'bridge_submitted',
+                                    isBridgeConfirmed: pending.stage === 'bridge_confirmed',
+                                    isFailedWithTx: pending.stage === 'failed' && pending.tx,
+                                } : null,
+                            });
+                            if (hasPendingBridgeDeposit) {
+                                // Only transition to DEPOSIT_PROGRESS if solanaWallet is ready (needed for claim signing)
+                                if (!solanaWallet) {
+                                    logger.info('[WalletConnection] Pending bridge deposit detected but solanaWallet not ready - waiting', {
+                                        pendingStage: pending.stage,
+                                        pendingTx: pending.tx,
+                                        currentState: state,
+                                        hasSolanaWallet: !!solanaWallet,
+                                    });
+                                    return [2 /*return*/];
+                                }
+                                logger.info('[WalletConnection] Pending bridge deposit detected, transitioning to DEPOSIT_PROGRESS', {
+                                    pendingStage: pending.stage,
+                                    pendingTx: pending.tx,
+                                    currentState: state,
+                                    hasSolanaWallet: !!solanaWallet,
+                                });
+                                closeDynamicWidget();
+                                setIsConnecting(false);
+                                // Transition directly to DEPOSIT_PROGRESS
+                                if (state !== OnboardingStep.DEPOSIT_PROGRESS) {
+                                    flowActions.startDeposit();
+                                }
+                                return [2 /*return*/];
+                            }
+                            if (state === OnboardingStep.CONNECTING_WALLET &&
+                                !context.isDepositOnlyFlow) {
+                                try {
+                                    lastDepositRecord = readLastDepositRecord(solanaWallet.address);
+                                    if (lastDepositRecord) {
+                                        logger.debug('Resuming last deposit from local storage');
+                                        flowActions.markDepositSuccess({
+                                            transactionId: lastDepositRecord.transactionId,
+                                            record: lastDepositRecord,
+                                        });
+                                        closeDynamicWidget();
+                                        setIsConnecting(false);
+                                        return [2 /*return*/];
+                                    }
+                                }
+                                catch (error) {
+                                    logger.logError(createWalletError('ADAPTER_ERROR', 'Error restoring last deposit record', {
+                                        cause: error instanceof Error ? error : undefined,
+                                    }));
+                                }
+                            }
+                            if (hasNordAccount && hasActiveSession) {
+                                setIsConnected(true);
+                                // If user already has balance and this is NOT an explicit deposit flow,
+                                // skip the deposit screens and just close the modal
+                                if (hasExistingBalance && !context.isDepositOnlyFlow) {
+                                    logger.info('[WalletConnection] User has existing Nord balance - skipping deposit flow', {
+                                        hasExistingBalance: hasExistingBalance,
+                                        isDepositOnlyFlow: context.isDepositOnlyFlow,
+                                    });
+                                    closeDynamicWidget();
+                                    setIsConnecting(false);
+                                    flowActions.completeFlow({
+                                        hasNordAccount: true,
+                                        hasActiveSession: true,
+                                    });
+                                    return [2 /*return*/];
+                                }
+                            }
+                            isSolanaEntry = context.entryNetwork === 'solana';
+                            if (!hasNordAccount && isSolanaEntry) {
+                                // If we have a pending deposit, allow the onboarding state to handle the flow
+                                // instead of forcing selection
+                                // Note: hasPendingBridgeDeposit is already checked earlier, but double-check here for safety
+                                if (state === OnboardingStep.DEPOSIT_PROGRESS || hasPendingBridgeDeposit) {
+                                    logger.debug('Pending deposit detected, skipping direct transition to Solana amount entry', {
+                                        state: state,
+                                        hasPendingBridgeDeposit: hasPendingBridgeDeposit,
+                                    });
+                                    closeDynamicWidget();
+                                    setIsConnecting(false);
+                                    return [2 /*return*/];
+                                }
+                                logger.debug('Proceeding directly to Solana amount entry');
+                                flowActions.selectChain({
+                                    id: 'solana',
+                                    name: 'Solana',
+                                    network: SolanaNetwork.MAINNET,
+                                });
+                                closeDynamicWidget();
+                                setIsConnecting(false);
+                                return [2 /*return*/];
+                            }
+                            closeDynamicWidget();
+                            // Transition immediately without setTimeout
+                            try {
+                                pendingCheck = readPendingDeposit();
+                                hasPendingBridgeDepositCheck = pendingCheck &&
+                                    (pendingCheck.stage === 'bridge_submitted' ||
+                                        pendingCheck.stage === 'bridge_confirmed' ||
+                                        (pendingCheck.stage === 'failed' && pendingCheck.tx)) &&
+                                    pendingCheck.tx;
+                                if (state === OnboardingStep.DEPOSIT_PROGRESS || hasPendingBridgeDepositCheck) {
+                                    logger.info('[WalletConnection] Skipping transition to CHAIN_SELECTION', {
+                                        reason: state === OnboardingStep.DEPOSIT_PROGRESS ? 'state is DEPOSIT_PROGRESS' : 'pending bridge deposit detected',
+                                        state: state,
+                                        hasPendingBridgeDepositCheck: hasPendingBridgeDepositCheck,
+                                        pendingStage: pendingCheck === null || pendingCheck === void 0 ? void 0 : pendingCheck.stage,
+                                    });
+                                }
+                                else {
+                                    logger.debug('Attempting transition to ' + OnboardingStep.CHAIN_SELECTION);
+                                    flowActions.goToChainSelection();
+                                    logger.debug('Transition to ' + OnboardingStep.CHAIN_SELECTION + ' completed');
+                                }
+                            }
+                            catch (error) {
+                                logger.logError(createWalletError('ADAPTER_ERROR', 'Error during transition', {
+                                    cause: error instanceof Error ? error : undefined,
+                                }));
+                            }
+                            finally {
+                                setIsConnecting(false);
+                            }
+                            return [3 /*break*/, 6];
+                        case 4:
+                            error_3 = _e.sent();
+                            logger.logError(createWalletError('ADAPTER_ERROR', 'Error checking account status', {
+                                cause: error_3 instanceof Error ? error_3 : undefined,
+                            }));
+                            closeDynamicWidget();
+                            setIsConnecting(false);
+                            return [3 /*break*/, 6];
+                        case 5:
+                            getUserInFlightRef.current = null;
+                            return [7 /*endfinally*/];
+                        case 6: return [2 /*return*/];
+                    }
+                });
+            }); })();
+            getUserInFlightRef.current = runGetUser;
+        }
+    }, [
+        nord,
+        nordUser,
+        solanaWallet,
+        updateContext,
+        flowActions,
+        setIsConnected,
+        state,
+        dynamicSdkHasLoaded,
+        context.isDepositOnlyFlow,
+        // Removed nordUser?.sessionId - it's redundant since nordUser is already in deps
+        closeDynamicWidget,
+        context.entryNetwork,
+    ]);
+    // Handle Dynamic widget closing while still connecting.
+    // If the Nord modal is gone, make sure we reset any pending Dynamic state
+    // so a subsequent open can trigger the widget again.
+    useEffect(function () {
+        if (showLogin) {
+            return;
+        }
+        if (dynamicWidgetRequestedRef.current) {
+            closeDynamicWidget();
+        }
+        if (isConnecting) {
+            logger.debug('Wallet modal closed before connection completed; resetting state');
+            setIsConnecting(false);
+        }
+    }, [isConnecting, showLogin, closeDynamicWidget]);
+    // Handle connecting state changes in a separate effect
+    useEffect(function () {
+        var currentState = state;
+        var prevState = prevStateRef.current;
+        // Only run if state has changed
+        if (currentState !== prevState) {
+            if (!isWalletConnectionStep(currentState) && isConnecting) {
+                // If we're no longer in the connecting state, reset the connecting flag
+                setIsConnecting(false);
+            }
+            // Update ref
+            prevStateRef.current = currentState;
+        }
+    }, [state, isConnecting]);
+    // Create the context value
+    var contextValue = {
+        isConnecting: isConnecting,
+        connectWallet: connectWallet,
+        disconnectWallet: disconnectWallet,
+        turnkeyEnabled: turnkeyEnabled,
+        turnkeyStatus: turnkeyStatus,
+        turnkeyError: turnkeyError,
+        retryTurnkeyBootstrap: retryTurnkeyBootstrap,
+        turnkeyAddress: turnkeyAddress,
+        turnkeySession: null, // We removed session machine usage for now as it was seemingly unused or redundant with provider
+        signTransaction: (_f = solanaWallet === null || solanaWallet === void 0 ? void 0 : solanaWallet.connector) === null || _f === void 0 ? void 0 : _f.signTransaction
+    };
+    return (_jsx(WalletConnectionContext.Provider, { value: contextValue, children: children }));
+};
+/**
+ * Custom hook to use the wallet connection context
+ * @returns The wallet connection context value
+ * @throws Error if used outside of a WalletConnectionProvider
+ */
+export var useWalletConnection = function () {
+    var context = useContext(WalletConnectionContext);
+    if (context === undefined) {
+        throw new Error('useWalletConnection must be used within a WalletConnectionProvider');
+    }
+    return context;
+};
+//# sourceMappingURL=WalletConnectionProvider.js.map