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

package/dist/src/features/onboarding-flow/hooks/useBridgeDeposit.js

@@ -0,0 +1,585 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { useCallback, useRef, useState } from 'react';
+import { useOnboardingState } from '../providers/OnboardingStateProvider';
+import { getCctpRuntimeConfig } from '../cctp/config';
+import { advancePendingDeposit, clearPendingDeposit, writePendingDeposit, } from '../utils/deposit/storage';
+import { formatBridgeError, normalizeCctpChain } from '../utils/deposit/bridgeUtils';
+import { explorerBaseForChain, pickExplorerUrl } from '../utils/explorerUrl';
+import { logger } from '../../../utils/logger';
+import { createDepositError } from '../../../utils/errors';
+import { useWalletConnection } from '../providers/WalletConnectionProvider';
+import { BridgeKitClient } from '../cctp/bridgeKitClient';
+import { checkUsedNonceAccount } from '../utils/deposit/nonceUtils';
+import { waitForAttestation } from '../utils/deposit/attestationUtils';
+import { ensureCorrectNetwork, getWalletProvider, validateBridgeConfig } from '../utils/deposit/walletUtils';
+import { submitClaimWithRetry } from '../utils/deposit/claimSubmission';
+import { confirmClaimAndGetUsdcBalance } from '../utils/deposit/claimConfirmation';
+import { EvmTxInterceptor } from '../utils/deposit/evmTxInterceptor';
+import { useNetwork } from '../../../providers/N1WalletProvider/NetworkProvider';
+export var useBridgeDeposit = function (_a) {
+    var setDepositProgressPhase = _a.setDepositProgressPhase, setPendingBridgeTx = _a.setPendingBridgeTx, setPendingMintTx = _a.setPendingMintTx, setPendingDepositId = _a.setPendingDepositId, setPendingBridgeExplorerUrl = _a.setPendingBridgeExplorerUrl, ensurePendingDraft = _a.ensurePendingDraft, finalizeBridgeSuccess = _a.finalizeBridgeSuccess, setIsDepositing = _a.setIsDepositing, runSolanaDeposit = _a.runSolanaDeposit;
+    var _b = useOnboardingState(), context = _b.context, updateContext = _b.updateContext;
+    // Use NetworkProvider for wallet state
+    var _c = useNetwork(), solanaAddress = _c.solanaAddress, evmWallet = _c.evmWallet, solanaWallet = _c.solanaWallet, evmAdapter = _c.evmAdapter;
+    var _d = useWalletConnection(), turnkeyAddress = _d.turnkeyAddress, turnkeyStatus = _d.turnkeyStatus, turnkeyEnabled = _d.turnkeyEnabled;
+    var _e = useState(false), bridgeRetryable = _e[0], setBridgeRetryable = _e[1];
+    var _f = useState(null), bridgeError = _f[0], setBridgeError = _f[1];
+    var _g = useState(false), bridgeApprovalPending = _g[0], setBridgeApprovalPending = _g[1];
+    var _h = useState(null), bridgeApprovalError = _h[0], setBridgeApprovalError = _h[1];
+    var lookupTableAddress = process.env.NEXT_PUBLIC_CCTP_LOOKUP_TABLE_ADDRESS;
+    var claimFinalizationInFlightRef = useRef(null);
+    var confirmClaimAndDeposit = useCallback(function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var promise;
+        var signature = _b.signature, destinationAddress = _b.destinationAddress, amountHint = _b.amountHint, pendingState = _b.pendingState, skipConfirmation = _b.skipConfirmation;
+        return __generator(this, function (_c) {
+            logger.info('[BridgeDeposit] confirmClaimAndDeposit called', {
+                signature: signature,
+                destinationAddress: destinationAddress,
+                amountHint: amountHint,
+                skipConfirmation: skipConfirmation,
+                pendingStage: pendingState === null || pendingState === void 0 ? void 0 : pendingState.stage,
+                pendingTx: pendingState === null || pendingState === void 0 ? void 0 : pendingState.tx,
+            });
+            if (claimFinalizationInFlightRef.current) {
+                logger.info('[BridgeDeposit] confirmClaimAndDeposit - already in flight, returning existing promise');
+                return [2 /*return*/, claimFinalizationInFlightRef.current];
+            }
+            promise = (function () { return __awaiter(void 0, void 0, void 0, function () {
+                var amount, txSignature, res, e_1, message, draft, withBridgeStage, depositResult;
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 2, , 3]);
+                            logger.info('[BridgeDeposit] Calling confirmClaimAndGetUsdcBalance...');
+                            return [4 /*yield*/, confirmClaimAndGetUsdcBalance({
+                                    signature: signature,
+                                    destinationAddress: destinationAddress,
+                                    amountHint: amountHint,
+                                    skipConfirmation: skipConfirmation,
+                                })];
+                        case 1:
+                            res = _b.sent();
+                            logger.info('[BridgeDeposit] confirmClaimAndGetUsdcBalance returned', {
+                                amount: res.amount,
+                                txSignature: res.txSignature,
+                            });
+                            amount = res.amount;
+                            txSignature = res.txSignature;
+                            return [3 /*break*/, 3];
+                        case 2:
+                            e_1 = _b.sent();
+                            logger.warn('[BridgeDeposit] confirmClaimAndGetUsdcBalance threw error', {
+                                error: e_1 instanceof Error ? e_1.message : String(e_1),
+                            });
+                            message = e_1 instanceof Error ? e_1.message : String(e_1);
+                            // If the claim nonce was already processed and there's no USDC to deposit,
+                            // the user likely already completed the deposit earlier. Clear pending state
+                            // to avoid trapping them in an endless "resume" loop.
+                            if (message.toLowerCase().includes('already be completed')) {
+                                logger.info('[BridgeDeposit] Deposit appears to be already completed - clearing pending state', {
+                                    message: message,
+                                });
+                                clearPendingDeposit();
+                                setPendingDepositId(null);
+                                updateContext({
+                                    depositError: 'This deposit appears to be already completed. Your funds should be in your Nord account.',
+                                });
+                                // Do not duplicate the message as a bridgeError; depositError is rendered on the progress screen.
+                                setBridgeError(null);
+                                setBridgeRetryable(false);
+                                setDepositProgressPhase('claim');
+                                setIsDepositing(false);
+                                return [2 /*return*/];
+                            }
+                            throw e_1;
+                        case 3:
+                            draft = pendingState !== null && pendingState !== void 0 ? pendingState : ensurePendingDraft(amount);
+                            withBridgeStage = advancePendingDeposit(draft, {
+                                stage: 'bridge_confirmed',
+                                tx: txSignature,
+                                mintTx: txSignature,
+                                amount: amount,
+                            });
+                            setDepositProgressPhase('solana');
+                            return [4 /*yield*/, runSolanaDeposit(amount, withBridgeStage)];
+                        case 4:
+                            depositResult = _b.sent();
+                            finalizeBridgeSuccess({
+                                tx: depositResult.txId,
+                                mintTx: txSignature,
+                                bridgeTx: (_a = withBridgeStage.tx) !== null && _a !== void 0 ? _a : txSignature,
+                                solanaTx: depositResult.solanaTx,
+                                depositId: withBridgeStage.depositId,
+                            });
+                            return [2 /*return*/];
+                    }
+                });
+            }); })().finally(function () {
+                claimFinalizationInFlightRef.current = null;
+            });
+            claimFinalizationInFlightRef.current = promise;
+            return [2 /*return*/, promise];
+        });
+    }); }, [
+        ensurePendingDraft,
+        finalizeBridgeSuccess,
+        runSolanaDeposit,
+        setDepositProgressPhase,
+        setPendingDepositId,
+        setBridgeError,
+        setBridgeRetryable,
+        setIsDepositing,
+        updateContext,
+    ]);
+    var startCctpBridge = useCallback(function (draftAmount) { return __awaiter(void 0, void 0, void 0, function () {
+        var cctpClient, cctpConfig, fromChain, workingState, solanaRecipient, _a, provider, walletClient, interceptor, walletForBridge, bridgeTxId, depositId, attestationId, submission, error_1, message, bridgeExplorerUrl, attestationData, nonceAlreadyProcessed, updatedState, finalSignature;
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+        return __generator(this, function (_v) {
+            switch (_v.label) {
+                case 0:
+                    setDepositProgressPhase('bridge');
+                    setBridgeApprovalPending(true);
+                    setBridgeApprovalError(null);
+                    cctpClient = new BridgeKitClient();
+                    cctpConfig = getCctpRuntimeConfig();
+                    fromChain = normalizeCctpChain((_c = (_b = context.selectedChainId) !== null && _b !== void 0 ? _b : context.entryNetwork) !== null && _c !== void 0 ? _c : cctpConfig.fromChain);
+                    return [4 /*yield*/, ensureCorrectNetwork({ evmWallet: evmWallet, evmAdapter: evmAdapter, targetChain: fromChain })];
+                case 1:
+                    _v.sent();
+                    validateBridgeConfig(cctpConfig, fromChain, draftAmount);
+                    workingState = ensurePendingDraft(draftAmount);
+                    solanaRecipient = solanaAddress || turnkeyAddress || '';
+                    if (!solanaRecipient) {
+                        setBridgeApprovalPending(false);
+                        throw new Error('Turnkey Solana address is not ready yet. Please wait a moment and retry.');
+                    }
+                    return [4 /*yield*/, getWalletProvider(evmWallet, evmAdapter)];
+                case 2:
+                    _a = _v.sent(), provider = _a.provider, walletClient = _a.walletClient;
+                    if (!provider && !walletClient && !cctpConfig.useMock) {
+                        setBridgeApprovalPending(false);
+                        throw new Error('Wallet provider not available for CCTP bridging');
+                    }
+                    interceptor = new EvmTxInterceptor(function (txHash) {
+                        workingState = writePendingDeposit(__assign(__assign({}, workingState), { depositId: txHash, stage: 'bridge_submitted', tx: txHash, chain: workingState.chain || fromChain, amount: workingState.amount || draftAmount, updatedAt: Date.now() }));
+                        setPendingDepositId(workingState.depositId);
+                        setPendingBridgeTx(txHash);
+                        setDepositProgressPhase('claim');
+                    });
+                    walletForBridge = interceptor.wrap(provider || walletClient);
+                    _v.label = 3;
+                case 3:
+                    _v.trys.push([3, 5, 6, 7]);
+                    return [4 /*yield*/, cctpClient.submitBridge({
+                            amount: draftAmount,
+                            fromChain: fromChain,
+                            toChain: 'solana',
+                            destinationAddress: solanaRecipient,
+                            wallet: walletForBridge,
+                        })];
+                case 4:
+                    submission = _v.sent();
+                    bridgeTxId = submission.bridgeTxId;
+                    depositId = submission.depositId;
+                    attestationId = submission.attestationId;
+                    return [3 /*break*/, 7];
+                case 5:
+                    error_1 = _v.sent();
+                    message = formatBridgeError(error_1);
+                    setBridgeApprovalError(message);
+                    setBridgeError(message);
+                    setBridgeRetryable(true);
+                    setBridgeApprovalPending(false);
+                    clearPendingDeposit();
+                    throw error_1;
+                case 6:
+                    setBridgeApprovalPending(false);
+                    return [7 /*endfinally*/];
+                case 7:
+                    bridgeExplorerUrl = pickExplorerUrl(workingState.explorerUrl, (_d = cctpConfig.explorerBaseUrl) !== null && _d !== void 0 ? _d : explorerBaseForChain(context.entryNetwork), bridgeTxId);
+                    workingState = advancePendingDeposit(workingState, {
+                        stage: 'bridge_submitted',
+                        tx: bridgeTxId,
+                        attestationId: attestationId,
+                        explorerUrl: bridgeExplorerUrl !== null && bridgeExplorerUrl !== void 0 ? bridgeExplorerUrl : null,
+                    });
+                    setPendingBridgeExplorerUrl((_e = workingState.explorerUrl) !== null && _e !== void 0 ? _e : null);
+                    setPendingBridgeTx(bridgeTxId);
+                    if (depositId && depositId !== workingState.depositId) {
+                        workingState = writePendingDeposit(__assign(__assign({}, workingState), { depositId: depositId, attestationId: (_f = attestationId !== null && attestationId !== void 0 ? attestationId : workingState.attestationId) !== null && _f !== void 0 ? _f : null, updatedAt: Date.now() }));
+                    }
+                    setPendingDepositId(depositId || workingState.depositId);
+                    return [4 /*yield*/, waitForAttestation({
+                            cctpClient: cctpClient,
+                            bridgeTxId: bridgeTxId,
+                            sourceChain: fromChain,
+                            timeoutMs: (_g = cctpConfig.attestationTimeoutMs) !== null && _g !== void 0 ? _g : 120000,
+                            retryBackoffMs: (_h = cctpConfig.retryBackoffMs) !== null && _h !== void 0 ? _h : 5000,
+                        })];
+                case 8:
+                    attestationData = _v.sent();
+                    return [4 /*yield*/, checkUsedNonceAccount((_j = attestationData === null || attestationData === void 0 ? void 0 : attestationData.decodedMessage) === null || _j === void 0 ? void 0 : _j.nonce)];
+                case 9:
+                    nonceAlreadyProcessed = _v.sent();
+                    if (!nonceAlreadyProcessed) return [3 /*break*/, 11];
+                    updatedState = advancePendingDeposit(workingState, {
+                        stage: 'bridge_confirmed',
+                        tx: (_l = (_k = workingState.tx) !== null && _k !== void 0 ? _k : bridgeTxId) !== null && _l !== void 0 ? _l : null,
+                        mintTx: (_m = workingState.mintTx) !== null && _m !== void 0 ? _m : null,
+                        attestationId: attestationId,
+                        explorerUrl: (_o = workingState.explorerUrl) !== null && _o !== void 0 ? _o : null,
+                    });
+                    setPendingMintTx((_p = updatedState.mintTx) !== null && _p !== void 0 ? _p : null);
+                    setPendingDepositId(updatedState.depositId);
+                    setDepositProgressPhase('claim');
+                    return [4 /*yield*/, confirmClaimAndDeposit({
+                            signature: (_r = (_q = updatedState.mintTx) !== null && _q !== void 0 ? _q : updatedState.tx) !== null && _r !== void 0 ? _r : null,
+                            destinationAddress: solanaRecipient,
+                            amountHint: draftAmount,
+                            pendingState: updatedState,
+                            skipConfirmation: true,
+                        })];
+                case 10:
+                    _v.sent();
+                    return [2 /*return*/, updatedState];
+                case 11:
+                    setDepositProgressPhase('solana');
+                    return [4 /*yield*/, submitClaimWithRetry({
+                            depositId: depositId,
+                            message: attestationData.message,
+                            attestation: attestationData.attestation,
+                            sourceChain: fromChain,
+                            destinationAddress: solanaRecipient,
+                            lookupTableAddress: lookupTableAddress !== null && lookupTableAddress !== void 0 ? lookupTableAddress : '',
+                            solanaWallet: solanaWallet,
+                            fallbackWallet: solanaAddress || turnkeyAddress || '',
+                            fallbackAmount: ((_t = (_s = attestationData.decodedMessage) === null || _s === void 0 ? void 0 : _s.decodedMessageBody) === null || _t === void 0 ? void 0 : _t.amount) || draftAmount || '0',
+                            bridgeTx: bridgeTxId,
+                            attestationId: attestationId !== null && attestationId !== void 0 ? attestationId : null,
+                        })];
+                case 12:
+                    finalSignature = _v.sent();
+                    workingState = advancePendingDeposit(workingState, {
+                        stage: 'bridge_confirmed',
+                        tx: finalSignature,
+                        mintTx: finalSignature,
+                        attestationId: attestationId,
+                        explorerUrl: finalSignature
+                            ? pickExplorerUrl(null, (_u = cctpConfig.mintExplorerBaseUrl) !== null && _u !== void 0 ? _u : explorerBaseForChain('solana'), finalSignature)
+                            : workingState.explorerUrl,
+                    });
+                    setPendingMintTx(finalSignature);
+                    setPendingDepositId(workingState.depositId);
+                    setDepositProgressPhase('claim');
+                    return [4 /*yield*/, confirmClaimAndDeposit({
+                            signature: finalSignature,
+                            destinationAddress: solanaRecipient,
+                            amountHint: draftAmount,
+                            pendingState: workingState,
+                        })];
+                case 13:
+                    _v.sent();
+                    return [2 /*return*/, workingState];
+            }
+        });
+    }); }, [
+        solanaAddress,
+        confirmClaimAndDeposit,
+        context.entryNetwork,
+        context.selectedChainId,
+        ensurePendingDraft,
+        evmAdapter,
+        evmWallet,
+        lookupTableAddress,
+        setDepositProgressPhase,
+        setPendingBridgeExplorerUrl,
+        setPendingBridgeTx,
+        setPendingDepositId,
+        setPendingMintTx,
+        solanaWallet,
+        turnkeyAddress,
+    ]);
+    var resumeClaimProcess = useCallback(function (pendingState) { return __awaiter(void 0, void 0, void 0, function () {
+        var depositId, bridgeTx, isEvmFlow, turnkeyStillInitializing, solanaRecipient, cctpClient, cctpConfig, fromChain, attestationData, nonceAlreadyProcessed, updated_1, claimDepositError_1, errorMessage, signature, updated, error_2;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        return __generator(this, function (_m) {
+            switch (_m.label) {
+                case 0:
+                    // Log full pending state for debugging
+                    logger.info('[BridgeDeposit] resumeClaimProcess called', {
+                        depositId: pendingState.depositId,
+                        stage: pendingState.stage,
+                        tx: pendingState.tx,
+                        mintTx: pendingState.mintTx,
+                        chain: pendingState.chain,
+                        amount: pendingState.amount,
+                        wallet: pendingState.wallet,
+                        reason: pendingState.reason,
+                        updatedAt: pendingState.updatedAt,
+                    });
+                    depositId = pendingState.depositId;
+                    if (!depositId) {
+                        logger.warn('[BridgeDeposit] resumeClaimProcess - no depositId, showing error');
+                        setBridgeError('Missing deposit ID. Please start a new deposit.');
+                        setBridgeRetryable(false);
+                        return [2 /*return*/];
+                    }
+                    // If the deposit is already in a terminal state, don't try to resume
+                    if (pendingState.stage === 'solana_confirmed') {
+                        logger.info('[BridgeDeposit] Deposit already in solana_confirmed state - clearing and completing', {
+                            depositId: depositId,
+                            stage: pendingState.stage,
+                        });
+                        clearPendingDeposit();
+                        finalizeBridgeSuccess({
+                            tx: pendingState.tx,
+                            mintTx: pendingState.mintTx,
+                            bridgeTx: pendingState.tx,
+                            depositId: pendingState.depositId,
+                        });
+                        return [2 /*return*/];
+                    }
+                    // If the deposit was submitted to Solana but we refreshed before confirmation,
+                    // the deposit might have actually completed. Show message with Start Over option.
+                    if (pendingState.stage === 'solana_submitted' && pendingState.tx) {
+                        logger.info('[BridgeDeposit] Deposit in solana_submitted state - may already be complete', {
+                            depositId: depositId,
+                            stage: pendingState.stage,
+                            tx: pendingState.tx,
+                        });
+                        // Clear state and show message - user can check their Nord account
+                        clearPendingDeposit();
+                        setBridgeError('Your deposit may have already completed. Please check your Nord account balance. Click "Start Over" if you need to make another deposit.');
+                        setBridgeRetryable(false);
+                        setIsDepositing(false);
+                        return [2 /*return*/];
+                    }
+                    bridgeTx = pendingState.tx;
+                    if (!bridgeTx || !bridgeTx.startsWith('0x')) {
+                        logger.warn('[BridgeDeposit] Cannot resume claim: missing bridge tx hash (likely refreshed before signing burn tx)', {
+                            depositId: depositId,
+                            tx: pendingState.tx,
+                            stage: pendingState.stage,
+                        });
+                        setBridgeError('Bridge transaction was not completed. Please start the deposit again.');
+                        setBridgeRetryable(true);
+                        setIsDepositing(false);
+                        return [2 /*return*/];
+                    }
+                    isEvmFlow = context.entryNetwork === 'evm';
+                    turnkeyStillInitializing = turnkeyEnabled && turnkeyStatus !== 'ready';
+                    if (isEvmFlow && turnkeyStillInitializing) {
+                        setBridgeError('Preparing Solana wallet... Please wait.');
+                        setBridgeRetryable(false); // Don't allow retry until Turnkey is ready
+                        setDepositProgressPhase('claim');
+                        return [2 /*return*/];
+                    }
+                    solanaRecipient = solanaAddress || turnkeyAddress || pendingState.wallet;
+                    if (!solanaRecipient) {
+                        setBridgeError('Missing Solana deposit address. Please reconnect your wallet.');
+                        setBridgeRetryable(true);
+                        return [2 /*return*/];
+                    }
+                    setPendingBridgeTx(bridgeTx);
+                    setDepositProgressPhase('claim');
+                    setIsDepositing(true);
+                    setBridgeError(null);
+                    setBridgeRetryable(false);
+                    _m.label = 1;
+                case 1:
+                    _m.trys.push([1, 11, , 12]);
+                    cctpClient = new BridgeKitClient();
+                    cctpConfig = getCctpRuntimeConfig();
+                    fromChain = normalizeCctpChain(pendingState.chain || context.selectedChainId || context.entryNetwork || cctpConfig.fromChain);
+                    return [4 /*yield*/, cctpClient.getAttestation(bridgeTx, fromChain)];
+                case 2:
+                    attestationData = _m.sent();
+                    if (!attestationData) {
+                        setBridgeError('Attestation not ready yet. Please wait a moment and try again.');
+                        setBridgeRetryable(true);
+                        setIsDepositing(false);
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, checkUsedNonceAccount((_a = attestationData.decodedMessage) === null || _a === void 0 ? void 0 : _a.nonce)];
+                case 3:
+                    nonceAlreadyProcessed = _m.sent();
+                    if (!nonceAlreadyProcessed) return [3 /*break*/, 8];
+                    logger.info('[BridgeDeposit] Nonce already processed - CCTP claim was completed previously', {
+                        depositId: depositId,
+                        bridgeTx: bridgeTx,
+                        nonce: (_b = attestationData.decodedMessage) === null || _b === void 0 ? void 0 : _b.nonce,
+                    });
+                    updated_1 = advancePendingDeposit(pendingState, {
+                        stage: 'bridge_confirmed',
+                        tx: (_c = pendingState.tx) !== null && _c !== void 0 ? _c : null,
+                        mintTx: (_e = (_d = pendingState.mintTx) !== null && _d !== void 0 ? _d : pendingState.tx) !== null && _e !== void 0 ? _e : null,
+                        attestationId: pendingState.attestationId,
+                    });
+                    setPendingMintTx((_f = updated_1.mintTx) !== null && _f !== void 0 ? _f : null);
+                    setPendingDepositId(updated_1.depositId);
+                    setDepositProgressPhase('claim');
+                    _m.label = 4;
+                case 4:
+                    _m.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, confirmClaimAndDeposit({
+                            signature: (_h = (_g = updated_1.mintTx) !== null && _g !== void 0 ? _g : updated_1.tx) !== null && _h !== void 0 ? _h : null,
+                            destinationAddress: solanaRecipient,
+                            amountHint: pendingState.amount,
+                            pendingState: updated_1,
+                            skipConfirmation: true,
+                        })];
+                case 5:
+                    _m.sent();
+                    return [3 /*break*/, 7];
+                case 6:
+                    claimDepositError_1 = _m.sent();
+                    errorMessage = claimDepositError_1 instanceof Error ? claimDepositError_1.message : String(claimDepositError_1);
+                    logger.info('[BridgeDeposit] confirmClaimAndDeposit failed after nonce processed - deposit likely complete', {
+                        error: errorMessage,
+                    });
+                    // Clear the pending state so user isn't stuck
+                    clearPendingDeposit();
+                    setBridgeError('This deposit appears to be already completed. Your funds should be in your Nord account. Click "Start Over" to continue.');
+                    setBridgeRetryable(false);
+                    setIsDepositing(false);
+                    return [3 /*break*/, 7];
+                case 7: return [2 /*return*/];
+                case 8:
+                    // If the nonce was NOT processed, we need a Solana signer to submit the claim.
+                    if (!solanaWallet) {
+                        setBridgeError('Solana wallet not connected. Please connect your Solana wallet to continue.');
+                        setBridgeRetryable(true);
+                        setDepositProgressPhase('claim');
+                        setIsDepositing(false);
+                        return [2 /*return*/];
+                    }
+                    if (solanaWallet.chain !== 'SOL') {
+                        setBridgeError('Wallet is not a Solana wallet. Please connect a Solana wallet.');
+                        setBridgeRetryable(true);
+                        setDepositProgressPhase('claim');
+                        setIsDepositing(false);
+                        return [2 /*return*/];
+                    }
+                    setDepositProgressPhase('solana');
+                    return [4 /*yield*/, submitClaimWithRetry({
+                            depositId: depositId,
+                            message: attestationData.message,
+                            attestation: attestationData.attestation,
+                            sourceChain: pendingState.chain || fromChain,
+                            destinationAddress: solanaRecipient,
+                            lookupTableAddress: lookupTableAddress !== null && lookupTableAddress !== void 0 ? lookupTableAddress : '',
+                            solanaWallet: solanaWallet,
+                            fallbackWallet: solanaAddress || turnkeyAddress || '',
+                            fallbackAmount: ((_k = (_j = attestationData.decodedMessage) === null || _j === void 0 ? void 0 : _j.decodedMessageBody) === null || _k === void 0 ? void 0 : _k.amount) || pendingState.amount || '0',
+                            bridgeTx: bridgeTx,
+                            attestationId: (_l = pendingState.attestationId) !== null && _l !== void 0 ? _l : null,
+                        })];
+                case 9:
+                    signature = _m.sent();
+                    updated = advancePendingDeposit(pendingState, {
+                        stage: 'bridge_confirmed',
+                        tx: signature,
+                        mintTx: signature,
+                        attestationId: pendingState.attestationId,
+                    });
+                    setPendingMintTx(signature);
+                    setPendingDepositId(updated.depositId);
+                    setDepositProgressPhase('claim');
+                    return [4 /*yield*/, confirmClaimAndDeposit({
+                            signature: signature,
+                            destinationAddress: solanaRecipient,
+                            amountHint: pendingState.amount,
+                            pendingState: updated,
+                        })];
+                case 10:
+                    _m.sent();
+                    return [3 /*break*/, 12];
+                case 11:
+                    error_2 = _m.sent();
+                    logger.logError(createDepositError('CLAIM_FAILED', 'Failed to resume claim process', {
+                        cause: error_2 instanceof Error ? error_2 : undefined,
+                        context: { depositId: depositId },
+                    }));
+                    setBridgeError(formatBridgeError(error_2));
+                    setIsDepositing(false);
+                    throw error_2;
+                case 12: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        solanaAddress,
+        confirmClaimAndDeposit,
+        context.entryNetwork,
+        context.selectedChainId,
+        lookupTableAddress,
+        setDepositProgressPhase,
+        setIsDepositing,
+        setPendingBridgeTx,
+        setPendingDepositId,
+        setPendingMintTx,
+        solanaWallet,
+        turnkeyAddress,
+        turnkeyEnabled,
+        turnkeyStatus,
+    ]);
+    return {
+        startCctpBridge: startCctpBridge,
+        resumeClaimProcess: resumeClaimProcess,
+        bridgeRetryable: bridgeRetryable,
+        setBridgeRetryable: setBridgeRetryable,
+        bridgeError: bridgeError,
+        setBridgeError: setBridgeError,
+        bridgeApprovalPending: bridgeApprovalPending,
+        setBridgeApprovalPending: setBridgeApprovalPending,
+        bridgeApprovalError: bridgeApprovalError,
+        setBridgeApprovalError: setBridgeApprovalError,
+    };
+};
+//# sourceMappingURL=useBridgeDeposit.js.map