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

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

@@ -0,0 +1,762 @@
+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, useRef, useState } from 'react';
+import { useN1WalletContext } from '../../../hooks';
+import { logger } from '../../../utils/logger';
+import { EVENTS, createDepositEvent } from '../../../utils/events';
+import { createDepositError } from '../../../utils/errors';
+import { useBridgeDeposit } from '../hooks/useBridgeDeposit';
+import { useDepositAuth } from '../hooks/useDepositAuth';
+import { useDepositHydration } from '../hooks/useDepositHydration';
+import { usePendingDepositState } from '../hooks/usePendingDepositState';
+import { useSolanaDeposit } from '../hooks/useSolanaDeposit';
+import { OnboardingStep } from '../types';
+import { deriveChainLabel } from '../utils/deposit/bridgeUtils';
+import { toDepositError } from '../errors/depositError';
+import { getSolanaExplorerUrl, } from '../utils/deposit/solanaDepositTransaction';
+import { advancePendingDeposit, clearLastDepositRecord, clearPendingDeposit, readPendingDeposit, saveLastDepositRecord } from '../utils/deposit/storage';
+import { isLikelyLedgerSolanaWallet } from '../utils/deposit/walletUtils';
+import { explorerBaseForChain, pickExplorerUrl } from '../utils/explorerUrl';
+import { useOnboardingState } from './OnboardingStateProvider';
+import { useWalletConnection } from './WalletConnectionProvider';
+import { useNetwork } from '../../../providers/N1WalletProvider/NetworkProvider';
+import { useSession } from '../../../providers/N1WalletProvider/SessionProvider';
+// Create the context with a default value
+var DepositFlowContext = createContext(undefined);
+/**
+ * Provider component for the deposit flow state
+ */
+export var DepositFlowProvider = function (_a) {
+    var children = _a.children;
+    // Get flow state context
+    var _b = useOnboardingState(), state = _b.state, context = _b.context, flowActions = _b.actions, updateContext = _b.updateContext, isDebugOverride = _b.isDebugOverride;
+    // Get wallet context
+    var nord = useN1WalletContext().nord;
+    var _c = useNetwork(), address = _c.solanaAddress, evmAddress = _c.evmAddress, solanaWallet = _c.solanaWallet, evmWallet = _c.evmWallet, solanaAdapter = _c.solanaAdapter;
+    var _d = useSession(), nordUser = _d.nordUser, turnkeyEnabled = _d.turnkeyEnabled;
+    var _e = useWalletConnection(), turnkeyAddress = _e.turnkeyAddress, turnkeyStatus = _e.turnkeyStatus;
+    // chain
+    var _f = useState(context.selectedChain), selectedChain = _f[0], setSelectedChain = _f[1];
+    // transaction & deposit
+    var _g = useState(context.amount), amount = _g[0], setAmount = _g[1];
+    var _h = useState(false), isDepositing = _h[0], setIsDepositing = _h[1];
+    // Initialize phase - only check deposit ID, determine bridge flow from context
+    var getInitialPhase = function () {
+        var _a, _b;
+        var pending = readPendingDeposit();
+        if (!(pending === null || pending === void 0 ? void 0 : pending.depositId))
+            return 'solana';
+        // Determine if it's a bridge flow from context (not from localStorage)
+        var entryNetwork = (_a = context.entryNetwork) !== null && _a !== void 0 ? _a : 'solana';
+        var selectedChainId = (_b = context.selectedChainId) !== null && _b !== void 0 ? _b : '';
+        var isBridgeFlow = entryNetwork === 'evm' && selectedChainId.toLowerCase() !== 'solana';
+        if (isBridgeFlow) {
+            // Bridge flow with deposit ID -> claim phase (we'll determine actual state by checking attestation)
+            return 'claim';
+        }
+        // Direct Solana flow
+        return 'solana';
+    };
+    var _j = useState(getInitialPhase()), depositProgressPhase = _j[0], setDepositProgressPhase = _j[1];
+    var _k = useState(context.transactionId), transactionId = _k[0], setTransactionId = _k[1];
+    var _l = useState(null), transactionResult = _l[0], setTransactionResult = _l[1];
+    var _m = useState(null), pendingBridgeExplorerUrl = _m[0], setPendingBridgeExplorerUrl = _m[1];
+    var _o = useState(null), pendingBridgeTx = _o[0], setPendingBridgeTx = _o[1];
+    var _p = useState(null), pendingMintTx = _p[0], setPendingMintTx = _p[1];
+    var bridgeCompletionRef = useRef(false);
+    var startDepositInFlightRef = useRef(false);
+    // Use refs to track previous values
+    var prevContextRef = useRef(context);
+    /**
+     * Handle an error by transitioning to error state
+     */
+    var handleError = useCallback(function (error) {
+        var normalized = toDepositError(error);
+        logger.logError(createDepositError('BRIDGE_FAILED', normalized.message, {
+            recoverable: normalized.retryable,
+            cause: error,
+            context: {
+                code: normalized.code,
+                userMessage: normalized.userMessage,
+                details: normalized.details,
+            },
+        }));
+        flowActions.setErrorState(normalized);
+    }, [flowActions]);
+    var _q = useDepositAuth(), authStatus = _q.authStatus, authErrorMessage = _q.authErrorMessage, authStatusMessage = _q.authStatusMessage, performAuth = _q.performAuth;
+    var _r = usePendingDepositState(), setPendingDepositId = _r.setPendingDepositId, ensurePendingDraft = _r.ensurePendingDraft;
+    var finalizeBridgeSuccess = useCallback(function (status) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        logger.info('[DepositFlow] finalizeBridgeSuccess called', status);
+        if (bridgeCompletionRef.current) {
+            logger.warn('[DepositFlow] finalizeBridgeSuccess skipped - already completed');
+            return;
+        }
+        var pending = readPendingDeposit();
+        var draft = pending;
+        var chainInfo = deriveChainLabel((_b = (_a = draft === null || draft === void 0 ? void 0 : draft.chain) !== null && _a !== void 0 ? _a : context.selectedChainId) !== null && _b !== void 0 ? _b : selectedChain);
+        var txId = (_h = (_g = (_f = (_e = (_d = (_c = status.tx) !== null && _c !== void 0 ? _c : status.solanaTx) !== null && _d !== void 0 ? _d : status.mintTx) !== null && _e !== void 0 ? _e : status.bridgeTx) !== null && _f !== void 0 ? _f : draft === null || draft === void 0 ? void 0 : draft.tx) !== null && _g !== void 0 ? _g : draft === null || draft === void 0 ? void 0 : draft.mintTx) !== null && _h !== void 0 ? _h : null;
+        logger.debug('[DepositFlow] Finalizing bridge success', { txId: txId, draft: draft, chainInfo: chainInfo });
+        var depositAmount = (_j = ((draft === null || draft === void 0 ? void 0 : draft.amount) && draft.amount !== '' ? draft.amount : null)) !== null && _j !== void 0 ? _j : amount;
+        var record = {
+            transactionId: txId !== null && txId !== void 0 ? txId : 'pending-bridge',
+            amount: depositAmount,
+            tokenSymbol: 'USDC',
+            chainId: chainInfo.id,
+            chainName: chainInfo.name,
+            chainNetwork: (_k = context.selectedChainNetwork) !== null && _k !== void 0 ? _k : null,
+            timestamp: Date.now(),
+        };
+        var result = {
+            success: true,
+            transactionId: record.transactionId,
+            amount: depositAmount,
+            tokenSymbol: 'USDC',
+            fromAddress: address || 'Your Wallet',
+            toAddress: 'Exchange Account',
+            networkName: chainInfo.name,
+            status: 'Completed',
+            explorerUrl: (_o = (_m = pickExplorerUrl((_l = draft === null || draft === void 0 ? void 0 : draft.explorerUrl) !== null && _l !== void 0 ? _l : null, explorerBaseForChain(chainInfo.id), record.transactionId)) !== null && _m !== void 0 ? _m : getSolanaExplorerUrl(record.transactionId)) !== null && _o !== void 0 ? _o : undefined,
+        };
+        logger.info('[DepositFlow] marking bridge completion', { record: record });
+        bridgeCompletionRef.current = true;
+        setTransactionId(txId !== null && txId !== void 0 ? txId : null);
+        setTransactionResult(result);
+        setDepositProgressPhase('nord');
+        setIsDepositing(false);
+        clearPendingDeposit();
+        saveLastDepositRecord(address, record);
+        logger.info('[DepositFlow] dispatching markDepositSuccess');
+        flowActions.markDepositSuccess({
+            transactionId: record.transactionId,
+            record: record,
+        });
+    }, [address, amount, context.selectedChainId, context.selectedChainNetwork, evmAddress, flowActions, selectedChain]);
+    var runSolanaDeposit = useSolanaDeposit({
+        setDepositProgressPhase: setDepositProgressPhase,
+        ensurePendingDraft: ensurePendingDraft,
+    }).runSolanaDeposit;
+    var _s = useBridgeDeposit({
+        setDepositProgressPhase: setDepositProgressPhase,
+        setPendingBridgeTx: setPendingBridgeTx,
+        setPendingMintTx: setPendingMintTx,
+        setPendingDepositId: setPendingDepositId,
+        setPendingBridgeExplorerUrl: setPendingBridgeExplorerUrl,
+        ensurePendingDraft: ensurePendingDraft,
+        finalizeBridgeSuccess: finalizeBridgeSuccess,
+        setIsDepositing: setIsDepositing,
+        runSolanaDeposit: runSolanaDeposit,
+    }), startCctpBridge = _s.startCctpBridge, resumeClaimProcess = _s.resumeClaimProcess, bridgeRetryable = _s.bridgeRetryable, setBridgeRetryable = _s.setBridgeRetryable, bridgeError = _s.bridgeError, setBridgeError = _s.setBridgeError, bridgeApprovalPending = _s.bridgeApprovalPending, setBridgeApprovalPending = _s.setBridgeApprovalPending, bridgeApprovalError = _s.bridgeApprovalError, setBridgeApprovalError = _s.setBridgeApprovalError;
+    useDepositHydration({
+        setPendingDepositId: setPendingDepositId,
+        setAmount: setAmount,
+        setTransactionId: setTransactionId,
+        setIsDepositing: setIsDepositing,
+        setPendingBridgeExplorerUrl: setPendingBridgeExplorerUrl,
+        setPendingBridgeTx: setPendingBridgeTx,
+        setPendingMintTx: setPendingMintTx,
+        setDepositProgressPhase: setDepositProgressPhase,
+        setBridgeError: setBridgeError,
+        setBridgeRetryable: setBridgeRetryable,
+    });
+    /**
+     * Update amount for deposit
+     */
+    var updateAmount = useCallback(function (newAmount) {
+        setAmount(newAmount);
+        updateContext({ amount: newAmount });
+    }, [updateContext]);
+    /**
+     * Helper to handle resuming a pending deposit
+     */
+    var handleResumePendingDeposit = useCallback(function (pending, walletMatches) { return __awaiter(void 0, void 0, void 0, function () {
+        var e_1, pendingChain, pendingStage, isSolanaNative, txId, isEvmFlow, turnkeyReady, canClaim, errorMsg, bridgeTxFromPending, explorerUrl, claimError_1, normalized;
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    // If user is connected with a different wallet, do not start a new deposit.
+                    // Ask them to connect the correct wallet (or clear the pending deposit) first.
+                    if (!walletMatches) {
+                        logger.logError(createDepositError('WALLET_MISMATCH', 'Pending deposit exists but connected wallet does not match', {
+                            recoverable: false,
+                            context: {
+                                pendingWallet: pending.wallet,
+                                depositId: pending.depositId,
+                            },
+                        }));
+                        setBridgeError('You have a pending deposit. Please connect the same wallet that started it to continue.');
+                        setBridgeRetryable(false);
+                        setIsDepositing(false);
+                        setDepositProgressPhase('claim');
+                        setPendingDepositId(pending.depositId);
+                        return [2 /*return*/];
+                    }
+                    if (!solanaWallet) return [3 /*break*/, 4];
+                    _h.label = 1;
+                case 1:
+                    _h.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, isLikelyLedgerSolanaWallet(solanaWallet, solanaAdapter)];
+                case 2:
+                    if (_h.sent()) {
+                        logger.logError(createDepositError('LEDGER_UNSUPPORTED', 'Ledger-like wallet detected during resume', {
+                            recoverable: false,
+                        }));
+                        setBridgeError('Ledger wallets are not supported. Please connect a standard wallet to continue.');
+                        setBridgeRetryable(false);
+                        setIsDepositing(false);
+                        return [2 /*return*/];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_1 = _h.sent();
+                    if ((e_1 === null || e_1 === void 0 ? void 0 : e_1.code) === 'N1_SIGNATURE_CANCELLED') {
+                        setIsDepositing(false);
+                        flowActions.markDepositFailed('Signature cancelled');
+                        return [2 /*return*/];
+                    }
+                    throw e_1;
+                case 4:
+                    pendingChain = ((_a = pending.chain) !== null && _a !== void 0 ? _a : '').toLowerCase();
+                    pendingStage = ((_b = pending.stage) !== null && _b !== void 0 ? _b : '').toLowerCase();
+                    isSolanaNative = pendingChain === 'solana' ||
+                        pendingStage.includes('solana') ||
+                        ((!pendingChain || pendingChain === 'solana') && !pendingStage.includes('bridge'));
+                    if (isSolanaNative) {
+                        logger.info('[Deposit] ===== SOLANA RESUME DETECTED =====', {
+                            depositId: pending.depositId,
+                            chain: pending.chain,
+                            stage: pending.stage
+                        });
+                        // If the deposit is already confirmed, transition to success immediately
+                        if (pending.stage === 'solana_confirmed') {
+                            logger.info('[Deposit] Solana deposit already confirmed - transitioning to success', {
+                                depositId: pending.depositId,
+                                tx: pending.tx,
+                                mintTx: pending.mintTx,
+                            });
+                            txId = pending.mintTx || pending.tx || pending.depositId;
+                            clearPendingDeposit();
+                            flowActions.markDepositSuccess({
+                                transactionId: txId,
+                                record: {
+                                    transactionId: txId,
+                                    amount: (_c = pending.amount) !== null && _c !== void 0 ? _c : '0',
+                                    tokenSymbol: 'USDC',
+                                    chainId: (_d = pending.chain) !== null && _d !== void 0 ? _d : 'solana',
+                                    chainName: pending.chain === 'solana' ? 'Solana' : ((_e = pending.chain) !== null && _e !== void 0 ? _e : 'Solana'),
+                                    chainNetwork: null,
+                                    timestamp: Date.now(),
+                                },
+                            });
+                            return [2 /*return*/];
+                        }
+                        setPendingDepositId(pending.depositId);
+                        setDepositProgressPhase('solana');
+                        // If we have a transaction hash, we can try to "resume" monitoring,
+                        // but typically the UI just needs to be in 'solana' phase and useSolanaDeposit internals
+                        // or the user interaction will handle the rest.
+                        // If there's NO tx hash, it just means they started but didn't sign.
+                        // In that case, we should probably allow them to just "Retry" (sign again)
+                        // rather than showing a "missing bridge hash" error.
+                        if (pending.tx) {
+                            setTransactionId(pending.tx);
+                            // We could try to auto-monitor here if we had a dedicated "resumeSolana" function,
+                            // but for now, setting phase to 'solana' allows the user to see the state.
+                            // If it was already confirmed, the initial hydration might have caught it?
+                            // or we just let them "Retry" if it seems stuck.
+                            setBridgeError('Transaction submitted. Please wait for confirmation.');
+                            setBridgeRetryable(false); // Maybe true if they want to try again?
+                            setIsDepositing(true);
+                        }
+                        else {
+                            // No TX hash yet - likely interrupted before signing
+                            logger.info('[Deposit] Solana deposit resumed without TX - allowing retry');
+                            setBridgeError(null);
+                            setBridgeRetryable(true); // Allow them to click "Sign" / "Retry" 
+                            setIsDepositing(false);
+                        }
+                        return [2 /*return*/];
+                    }
+                    // --- EVM / CCTP FLOW BELOW ---
+                    // STATE 1: Pending deposit ID exists and matches wallet address (EVM or Solana) -> CLAIM
+                    logger.info('[Deposit] ===== CLAIM MODE DETECTED (CCTP) =====', {
+                        depositId: pending.depositId,
+                    });
+                    isEvmFlow = context.entryNetwork === 'evm';
+                    turnkeyReady = !turnkeyEnabled || !!solanaWallet;
+                    canClaim = !isEvmFlow || turnkeyReady;
+                    if (!canClaim) {
+                        errorMsg = turnkeyEnabled && !solanaWallet
+                            ? 'Preparing Solana wallet... Please wait.'
+                            : 'Wallet not ready. Please try again.';
+                        setBridgeError(errorMsg);
+                        setBridgeRetryable(true);
+                        setIsDepositing(false);
+                        return [2 /*return*/];
+                    }
+                    // Clear previous errors
+                    setBridgeError(null);
+                    setBridgeRetryable(false);
+                    setBridgeApprovalError(null);
+                    bridgeTxFromPending = (_f = pending.tx) !== null && _f !== void 0 ? _f : null;
+                    if (bridgeTxFromPending) {
+                        setPendingBridgeTx(bridgeTxFromPending);
+                        explorerUrl = (_g = pending.explorerUrl) !== null && _g !== void 0 ? _g : pickExplorerUrl(null, explorerBaseForChain(pending.chain), bridgeTxFromPending);
+                        if (explorerUrl) {
+                            setPendingBridgeExplorerUrl(explorerUrl);
+                        }
+                    }
+                    else {
+                        logger.warn('[DepositFlow] Pending deposit missing bridge tx hash');
+                        setPendingDepositId(pending.depositId);
+                        setDepositProgressPhase('claim');
+                        setBridgeError('Pending deposit found, but the bridge transaction hash is missing. Please retry from the progress screen.');
+                        setBridgeRetryable(true);
+                        setIsDepositing(false);
+                        return [2 /*return*/];
+                    }
+                    // Restore mint tx
+                    if (pending.mintTx) {
+                        setPendingMintTx(pending.mintTx);
+                    }
+                    setPendingDepositId(pending.depositId);
+                    setDepositProgressPhase('claim');
+                    setIsDepositing(true);
+                    _h.label = 5;
+                case 5:
+                    _h.trys.push([5, 7, , 8]);
+                    return [4 /*yield*/, resumeClaimProcess(pending)];
+                case 6:
+                    _h.sent();
+                    return [3 /*break*/, 8];
+                case 7:
+                    claimError_1 = _h.sent();
+                    normalized = toDepositError(claimError_1, { depositId: pending.depositId, stage: 'claim' });
+                    setIsDepositing(false);
+                    setBridgeError(normalized.userMessage);
+                    setBridgeRetryable(normalized.retryable);
+                    throw claimError_1;
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        context.entryNetwork,
+        solanaWallet,
+        turnkeyEnabled,
+        setBridgeError,
+        setBridgeRetryable,
+        setIsDepositing,
+        setDepositProgressPhase,
+        setPendingDepositId,
+        setBridgeApprovalError,
+        setPendingBridgeTx,
+        setPendingBridgeExplorerUrl,
+        setPendingMintTx,
+        resumeClaimProcess,
+        setTransactionId
+    ]);
+    /**
+     * Helper to validate conditions for a new deposit
+     */
+    var validateNewDeposit = useCallback(function (amountStr, isBridgeFlow, targetChainId) {
+        if (!amountStr || parseFloat(amountStr) <= 0) {
+            throw new Error('Invalid amount');
+        }
+        if (!nord) {
+            throw new Error('Nord client is unavailable. Please check your configuration and try again.');
+        }
+        if (!nordUser) {
+            throw new Error('Your Nord session is not ready yet. Reconnect your wallet to retry.');
+        }
+        if (!address && !turnkeyAddress) {
+            throw new Error('We were unable to determine your Solana deposit address. Please reconnect your wallet and try again.');
+        }
+        if (isBridgeFlow && !evmAddress) {
+            throw new Error('No connected EVM wallet was found for bridging. Please reconnect your EVM wallet.');
+        }
+    }, [nord, nordUser, address, turnkeyAddress, evmAddress]);
+    /**
+     * Helper to handle starting a NEW deposit
+     */
+    var handleNewDeposit = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var targetChainId, normalizedTargetChainIdRaw, normalizedTargetChainId, hasEvmWallet, isEvmChain, isBridgeFlow, e_2, pendingState, txId, result, depositRecord, depositError_1, normalized, existing, isBridgeError;
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    logger.debug('[DepositFlow] SUBMIT MODE: Starting new deposit');
+                    // Cleanup previous state
+                    bridgeCompletionRef.current = false;
+                    setPendingBridgeTx(null);
+                    setPendingMintTx(null);
+                    setPendingBridgeExplorerUrl(null);
+                    setBridgeError(null);
+                    setBridgeRetryable(false);
+                    setBridgeApprovalError(null);
+                    targetChainId = (_b = (_a = context.selectedChainId) !== null && _a !== void 0 ? _a : (context.selectedChain ? context.selectedChain.toLowerCase() : null)) !== null && _b !== void 0 ? _b : (selectedChain ? selectedChain.toLowerCase() : null);
+                    normalizedTargetChainIdRaw = ((_c = targetChainId !== null && targetChainId !== void 0 ? targetChainId : context.entryNetwork) !== null && _c !== void 0 ? _c : 'solana').toLowerCase();
+                    normalizedTargetChainId = normalizedTargetChainIdRaw === 'evm'
+                        ? 'ethereum'
+                        : normalizedTargetChainIdRaw === 'arb' || normalizedTargetChainIdRaw === 'arbitrum-one'
+                            ? 'arbitrum'
+                            : normalizedTargetChainIdRaw;
+                    hasEvmWallet = !!evmAddress;
+                    isEvmChain = normalizedTargetChainId !== 'solana';
+                    isBridgeFlow = hasEvmWallet && isEvmChain;
+                    if (!(!isBridgeFlow && solanaWallet)) return [3 /*break*/, 4];
+                    _h.label = 1;
+                case 1:
+                    _h.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, isLikelyLedgerSolanaWallet(solanaWallet, solanaAdapter)];
+                case 2:
+                    if (_h.sent()) {
+                        handleError(new Error('Ledger wallets are not supported for this action'));
+                        return [2 /*return*/];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_2 = _h.sent();
+                    if ((e_2 === null || e_2 === void 0 ? void 0 : e_2.code) === 'N1_SIGNATURE_CANCELLED') {
+                        setIsDepositing(false);
+                        flowActions.markDepositFailed('Signature cancelled');
+                        return [2 /*return*/];
+                    }
+                    handleError(e_2 instanceof Error ? e_2 : new Error(String(e_2)));
+                    return [2 /*return*/];
+                case 4:
+                    try {
+                        validateNewDeposit(amount, isBridgeFlow, targetChainId);
+                    }
+                    catch (validationError) {
+                        handleError(validationError);
+                        return [2 /*return*/];
+                    }
+                    logger.event(createDepositEvent(EVENTS.DEPOSIT.START, {
+                        amount: amount,
+                        chain: selectedChain || context.selectedChain,
+                        isBridgeFlow: isBridgeFlow,
+                    }));
+                    setIsDepositing(true);
+                    flowActions.startDeposit();
+                    _h.label = 5;
+                case 5:
+                    _h.trys.push([5, 9, 10, 11]);
+                    if (!isBridgeFlow) return [3 /*break*/, 7];
+                    return [4 /*yield*/, startCctpBridge(amount)];
+                case 6:
+                    _h.sent();
+                    setDepositProgressPhase('bridge');
+                    return [2 /*return*/];
+                case 7:
+                    pendingState = ensurePendingDraft(amount);
+                    return [4 /*yield*/, runSolanaDeposit(amount, pendingState)];
+                case 8:
+                    txId = (_h.sent()).txId;
+                    result = {
+                        success: true,
+                        transactionId: txId,
+                        amount: amount,
+                        tokenSymbol: 'USDC',
+                        fromAddress: address || 'Your Wallet',
+                        toAddress: 'Exchange Account',
+                        networkName: (_d = selectedChain !== null && selectedChain !== void 0 ? selectedChain : context.selectedChain) !== null && _d !== void 0 ? _d : 'Solana',
+                        status: 'Completed',
+                        explorerUrl: getSolanaExplorerUrl(txId),
+                    };
+                    depositRecord = {
+                        transactionId: txId,
+                        amount: amount,
+                        tokenSymbol: 'USDC',
+                        chainId: (_e = context.selectedChainId) !== null && _e !== void 0 ? _e : (selectedChain !== null && selectedChain !== void 0 ? selectedChain : 'solana'),
+                        chainName: (_f = context.selectedChain) !== null && _f !== void 0 ? _f : (selectedChain !== null && selectedChain !== void 0 ? selectedChain : 'Solana'),
+                        chainNetwork: (_g = context.selectedChainNetwork) !== null && _g !== void 0 ? _g : null,
+                        timestamp: Date.now(),
+                    };
+                    saveLastDepositRecord(address, depositRecord);
+                    clearPendingDeposit();
+                    setPendingDepositId(null);
+                    setBridgeRetryable(false);
+                    setBridgeError(null);
+                    setTransactionId(txId);
+                    setTransactionResult(result);
+                    logger.event(createDepositEvent(EVENTS.DEPOSIT.COMPLETE, {
+                        transactionId: txId,
+                        amount: amount,
+                        chain: selectedChain || context.selectedChain,
+                    }));
+                    flowActions.markDepositSuccess({
+                        transactionId: txId,
+                        record: depositRecord,
+                    });
+                    return [3 /*break*/, 11];
+                case 9:
+                    depositError_1 = _h.sent();
+                    normalized = toDepositError(depositError_1, {
+                        stage: depositProgressPhase,
+                        isBridgeFlow: depositProgressPhase === 'bridge' || depositProgressPhase === 'claim',
+                    });
+                    logger.event(createDepositEvent(EVENTS.DEPOSIT.FAILED, {
+                        code: normalized.code,
+                        message: normalized.message,
+                        retryable: normalized.retryable,
+                        stage: depositProgressPhase,
+                    }));
+                    logger.logError(createDepositError('BRIDGE_FAILED', normalized.message || 'Deposit failed', {
+                        recoverable: normalized.retryable,
+                        context: { code: normalized.code, stage: depositProgressPhase },
+                        cause: depositError_1 instanceof Error ? depositError_1 : undefined,
+                    }));
+                    // Try to persist failure state
+                    try {
+                        existing = readPendingDeposit();
+                        if (existing) {
+                            advancePendingDeposit(existing, {
+                                stage: normalized.retryable ? existing.stage : 'failed',
+                                reason: normalized.message || 'Deposit failed',
+                            });
+                        }
+                    }
+                    catch (e) { /* ignore */ }
+                    isBridgeError = depositProgressPhase === 'bridge' || depositProgressPhase === 'claim';
+                    if (isBridgeError) {
+                        setBridgeError(normalized.userMessage);
+                        setBridgeRetryable(normalized.retryable);
+                        if (bridgeApprovalPending) {
+                            setBridgeApprovalError(normalized.userMessage);
+                            setBridgeApprovalPending(false);
+                        }
+                    }
+                    if (normalized.retryable) {
+                        setBridgeError(normalized.userMessage);
+                        setBridgeRetryable(true);
+                        return [2 /*return*/];
+                    }
+                    flowActions.markDepositFailed(normalized.message || 'Failed to process deposit');
+                    return [3 /*break*/, 11];
+                case 10:
+                    setIsDepositing(false);
+                    return [7 /*endfinally*/];
+                case 11: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        context,
+        selectedChain,
+        evmAddress,
+        solanaWallet,
+        evmWallet,
+        amount,
+        address,
+        turnkeyAddress,
+        nord,
+        nordUser,
+        handleError,
+        setBridgeError,
+        setBridgeRetryable,
+        setBridgeApprovalError,
+        setPendingBridgeTx,
+        setPendingMintTx,
+        setPendingBridgeExplorerUrl,
+        setPendingDepositId,
+        setDepositProgressPhase,
+        startCctpBridge,
+        runSolanaDeposit,
+        ensurePendingDraft,
+        flowActions,
+        depositProgressPhase,
+        bridgeApprovalPending,
+        validateNewDeposit,
+        setTransactionId,
+        setTransactionResult,
+        bridgeApprovalPending
+    ]);
+    /**
+     * Main entry point for starting a deposit
+     */
+    var startDeposit = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var pending, pendingWalletLower, evmAddressLower, addressLower, walletMatches;
+        var _a, _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    if (startDepositInFlightRef.current) {
+                        logger.debug('[DepositFlow] startDeposit ignored (already in flight)');
+                        return [2 /*return*/];
+                    }
+                    startDepositInFlightRef.current = true;
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, , 5, 6]);
+                    logger.debug('[DepositFlow] startDeposit called');
+                    updateContext({ depositError: undefined });
+                    pending = readPendingDeposit();
+                    if (!(pending === null || pending === void 0 ? void 0 : pending.depositId)) return [3 /*break*/, 3];
+                    pendingWalletLower = (_b = (_a = pending.wallet) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
+                    evmAddressLower = (_c = evmAddress === null || evmAddress === void 0 ? void 0 : evmAddress.toLowerCase()) !== null && _c !== void 0 ? _c : '';
+                    addressLower = (_d = address === null || address === void 0 ? void 0 : address.toLowerCase()) !== null && _d !== void 0 ? _d : '';
+                    walletMatches = pendingWalletLower && (evmAddressLower === pendingWalletLower ||
+                        addressLower === pendingWalletLower);
+                    return [4 /*yield*/, handleResumePendingDeposit(pending, !!walletMatches)];
+                case 2:
+                    _e.sent();
+                    return [2 /*return*/];
+                case 3: 
+                // Otherwise, start a new one
+                return [4 /*yield*/, handleNewDeposit()];
+                case 4:
+                    // Otherwise, start a new one
+                    _e.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    startDepositInFlightRef.current = false;
+                    return [7 /*endfinally*/];
+                case 6: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        readPendingDeposit,
+        evmAddress,
+        address,
+        handleResumePendingDeposit,
+        handleNewDeposit,
+        updateContext
+    ]);
+    /**
+     * Complete the deposit process and move to the next screen
+     */
+    var completeDeposit = useCallback(function () {
+        clearLastDepositRecord(address);
+        clearPendingDeposit();
+        setPendingDepositId(null);
+        updateContext({ lastDeposit: null });
+        if (context.isDepositOnlyFlow) {
+            flowActions.completeFlow({
+                hasNordAccount: true,
+                hasActiveSession: true,
+            });
+            return;
+        }
+        // Check if user has an active session to determine the next state
+        if (context.hasActiveSession) {
+            // If user has an active session, go directly to FINAL_SUCCESS
+            flowActions.completeFlow({
+                hasNordAccount: true,
+                hasActiveSession: true,
+            });
+        }
+        else {
+            // If user doesn't have an active session, go to authentication flow
+            flowActions.requireAuth({ hasNordAccount: true });
+        }
+    }, [context.hasActiveSession, context.isDepositOnlyFlow, flowActions, address, updateContext, evmAddress, setPendingDepositId]);
+    /**
+     * Update state based on context changes
+     */
+    useEffect(function () {
+        var prevContext = prevContextRef.current;
+        // Only update state if the relevant context values have actually changed
+        if (context.selectedChain !== prevContext.selectedChain) {
+            setSelectedChain(context.selectedChain);
+        }
+        if (context.amount !== prevContext.amount) {
+            setAmount(context.amount);
+        }
+        if (context.transactionId !== prevContext.transactionId) {
+            setTransactionId(context.transactionId);
+        }
+        // Update the ref to the current context
+        prevContextRef.current = context;
+    }, [context]);
+    // Phase correction logic removed.
+    // We now rely on correct hydration in useDepositHydration.ts.
+    useEffect(function () {
+        var _a, _b;
+        if (!isDebugOverride || state !== OnboardingStep.DEPOSIT_SUCCESS || transactionResult) {
+            return;
+        }
+        var mockTransactionId = (_a = context.transactionId) !== null && _a !== void 0 ? _a : 'debug-tx-12345';
+        var fallbackChain = (_b = context.selectedChain) !== null && _b !== void 0 ? _b : 'Solana';
+        setTransactionId(mockTransactionId);
+        setTransactionResult({
+            success: true,
+            transactionId: mockTransactionId,
+            amount: context.amount || '1,250',
+            tokenSymbol: 'USDC',
+            fromAddress: address || 'Debug Wallet',
+            toAddress: 'Nord Account',
+            networkName: fallbackChain,
+            status: 'Completed',
+            explorerUrl: getSolanaExplorerUrl(mockTransactionId),
+        });
+    }, [isDebugOverride, state, transactionResult, context, address]);
+    // Create the context value
+    var contextValue = {
+        amount: amount,
+        isDepositing: isDepositing,
+        depositProgressPhase: depositProgressPhase,
+        pendingBridgeExplorerUrl: pendingBridgeExplorerUrl,
+        pendingBridgeTx: pendingBridgeTx,
+        pendingMintTx: pendingMintTx,
+        bridgeRetryable: bridgeRetryable,
+        bridgeApprovalPending: bridgeApprovalPending,
+        bridgeApprovalError: bridgeApprovalError,
+        bridgeError: bridgeError,
+        transactionId: transactionId,
+        transactionResult: transactionResult,
+        authStatus: authStatus,
+        authErrorMessage: authErrorMessage,
+        authStatusMessage: authStatusMessage,
+        updateAmount: updateAmount,
+        startDeposit: startDeposit,
+        completeDeposit: completeDeposit,
+        performAuth: performAuth,
+    };
+    return (_jsx(DepositFlowContext.Provider, { value: contextValue, children: children }));
+};
+/**
+ * Hook to use the deposit flow context
+ */
+export var useDepositFlow = function () {
+    var context = useContext(DepositFlowContext);
+    if (context === undefined) {
+        throw new Error('useDepositFlow must be used within a DepositFlowProvider');
+    }
+    return context;
+};
+//# sourceMappingURL=DepositFlowProvider.js.map