@n1xyz/wallet-widget 0.0.4 → 0.0.7

package/dist/Modal/NordFlow/hooks/useNordSession.js

@@ -0,0 +1,391 @@
+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, useEffect, useState } from 'react';
+import { WalletError, WalletErrorCode } from '../../../errors/types';
+import { createSigningFunction, createWebSession, generateSessionKeys, hasValidSession, storeSessionKeys } from '../../../Logic/sessionManager';
+import { useN1WalletContext, useN1WalletInternalContext } from '../../../Provider/hooks';
+import { N1SessionMode } from '../../../Provider/types';
+import { logger } from '../../../utils/logger';
+import { FlowState } from '../types';
+import { isNordConfigured } from '../utils/nordUtils';
+import { useNordInstance } from './useNordInstance';
+/**
+ * Hook for handling Nord session authentication
+ *
+ * @param options Configuration options
+ * @returns Nord session methods and state
+ */
+export var useNordSession = function (options) {
+    var state = options.state, context = options.context, transition = options.transition, handleError = options.handleError;
+    var _a = useN1WalletInternalContext(), dynamicWallet = _a.dynamicWallet, setSessionPubKey = _a.setSessionPubKey, setSignMessageWithSessionKey = _a.setSignMessageWithSessionKey, sessionMode = _a.sessionMode;
+    var _b = useN1WalletContext(), walletPubKey = _b.walletPubKey, address = _b.address, nord = _b.nord, signMessageWithWalletKey = _b.signMessageWithWalletKey;
+    var _c = useNordInstance(), getNordUser = _c.getNordUser, instanceNordUser = _c.nordUser, createNordUser = _c.createNordUser;
+    var _d = useState(false), isAuthenticating = _d[0], setIsAuthenticating = _d[1];
+    var _e = useState(context.hasNordAccount), hasNordAccount = _e[0], setHasNordAccount = _e[1];
+    var _f = useState(context.hasActiveSession), hasActiveSession = _f[0], setHasActiveSession = _f[1];
+    var _g = useState(null), keyPair = _g[0], setKeyPair = _g[1];
+    // Log dependencies when they change
+    useEffect(function () {
+        console.log('useNordSession dependencies:', {
+            hasNord: !!nord,
+            hasAddress: !!address,
+            hasWalletSignFn: !!signMessageWithWalletKey,
+            nordUser: !!instanceNordUser
+        });
+    }, [nord, address, signMessageWithWalletKey, instanceNordUser]);
+    /**
+     * Check if user has a Nord account
+     */
+    var checkNordAccount = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var accountIds, hasAccount, hasSession, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!address) {
+                        logger.warn('Cannot check Nord account without wallet address');
+                        return [2 /*return*/];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    // If Nord is configured, use it to check for accounts
+                    if (instanceNordUser && isNordConfigured(nord)) {
+                        try {
+                            accountIds = instanceNordUser.accountIds || [];
+                            hasAccount = accountIds && accountIds.length > 0;
+                            setHasNordAccount(hasAccount);
+                            setHasActiveSession(!!instanceNordUser.sessionId);
+                            // Update context
+                            transition(state, {
+                                hasNordAccount: hasAccount,
+                                hasActiveSession: !!instanceNordUser.sessionId
+                            });
+                            // Handle state transitions
+                            if (state === FlowState.WALLET_CONNECTED) {
+                                if (context.walletType === 'ethereum') {
+                                    transition(FlowState.ETH_TO_SOL_AUTH);
+                                }
+                                else if (hasAccount && instanceNordUser.sessionId) {
+                                    transition(FlowState.FINAL_SUCCESS, {
+                                        hasNordAccount: true,
+                                        hasActiveSession: true
+                                    });
+                                }
+                                else {
+                                    transition(FlowState.CHAIN_SELECTION);
+                                }
+                            }
+                            return [2 /*return*/];
+                        }
+                        catch (error) {
+                            logger.warn('Failed to check Nord account using Nord-TS, falling back to session check', error);
+                        }
+                    }
+                    return [4 /*yield*/, hasValidSession(address, N1SessionMode.Nord)];
+                case 2:
+                    hasSession = _a.sent();
+                    setHasNordAccount(hasSession);
+                    setHasActiveSession(hasSession);
+                    // Update context
+                    transition(state, {
+                        hasNordAccount: hasSession,
+                        hasActiveSession: hasSession
+                    });
+                    // If in WALLET_CONNECTED state, transition to appropriate next state
+                    if (state === FlowState.WALLET_CONNECTED) {
+                        if (context.walletType === 'ethereum') {
+                            transition(FlowState.ETH_TO_SOL_AUTH);
+                        }
+                        else if (hasSession) {
+                            transition(FlowState.FINAL_SUCCESS, {
+                                hasNordAccount: true,
+                                hasActiveSession: true
+                            });
+                        }
+                        else {
+                            transition(FlowState.CHAIN_SELECTION);
+                        }
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _a.sent();
+                    logger.error('Failed to check Nord account', error_1);
+                    handleError(error_1 instanceof Error
+                        ? error_1
+                        : new Error('Failed to check Nord account'));
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        address,
+        state,
+        context.walletType,
+        transition,
+        handleError,
+        nord,
+        instanceNordUser,
+    ]);
+    /**
+     * Initialize session keys
+     */
+    var initializeSessionKeys = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var newKeyPair, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, generateSessionKeys()];
+                case 1:
+                    newKeyPair = _a.sent();
+                    setKeyPair(newKeyPair);
+                    logger.debug('Generated new session keys');
+                    return [2 /*return*/, newKeyPair];
+                case 2:
+                    error_2 = _a.sent();
+                    logger.error('Failed to initialize session keys', error_2);
+                    handleError(error_2 instanceof Error
+                        ? error_2
+                        : new Error('Failed to initialize session keys'));
+                    return [2 /*return*/, null];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [handleError]);
+    /**
+     * Create and register a new session
+     */
+    var createSession = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var keys_1, _a, timestamp, nonce, createSession_1, sessionId, signFn_1, error_3, keys, _b, signFn_2, error_4;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (!dynamicWallet || !walletPubKey || !address) {
+                        logger.warn('Cannot create session without wallet');
+                        return [2 /*return*/, false];
+                    }
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 14, , 15]);
+                    if (!(instanceNordUser && nord && isNordConfigured(nord) && signMessageWithWalletKey)) return [3 /*break*/, 10];
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, 9, , 10]);
+                    _a = keyPair;
+                    if (_a) return [3 /*break*/, 4];
+                    return [4 /*yield*/, initializeSessionKeys()];
+                case 3:
+                    _a = (_c.sent());
+                    _c.label = 4;
+                case 4:
+                    keys_1 = _a;
+                    if (!keys_1) {
+                        throw new Error('Failed to initialize session keys');
+                    }
+                    return [4 /*yield*/, nord.getTimestamp()];
+                case 5:
+                    timestamp = _c.sent();
+                    return [4 /*yield*/, nord.getActionNonce()];
+                case 6:
+                    nonce = _c.sent();
+                    return [4 /*yield*/, import('@n1xyz/nord-ts/dist/nord/api/actions')];
+                case 7:
+                    createSession_1 = (_c.sent()).createSession;
+                    return [4 /*yield*/, createSession_1(nord.webServerUrl, signMessageWithWalletKey, timestamp, nonce, {
+                            userPubkey: walletPubKey,
+                            sessionPubkey: keys_1.publicKey,
+                        })];
+                case 8:
+                    sessionId = _c.sent();
+                    if (sessionId) {
+                        // Store session keys
+                        storeSessionKeys({
+                            privKey: keys_1.privateKey,
+                            walletPublicKey: address,
+                            chainName: dynamicWallet.chain,
+                            sessionMode: N1SessionMode.Nord
+                        });
+                        // Set session public key and signing function
+                        setSessionPubKey(keys_1.publicKey);
+                        signFn_1 = createSigningFunction(keys_1.privateKey);
+                        setSignMessageWithSessionKey(function () { return signFn_1; });
+                        logger.debug('Session created successfully using Nord-TS API');
+                        return [2 /*return*/, true];
+                    }
+                    else {
+                        logger.warn('Failed to create session using Nord-TS API, falling back to legacy method');
+                    }
+                    return [3 /*break*/, 10];
+                case 9:
+                    error_3 = _c.sent();
+                    logger.warn('Error creating session with Nord-TS API, falling back to legacy method', error_3);
+                    return [3 /*break*/, 10];
+                case 10:
+                    _b = keyPair;
+                    if (_b) return [3 /*break*/, 12];
+                    return [4 /*yield*/, initializeSessionKeys()];
+                case 11:
+                    _b = (_c.sent());
+                    _c.label = 12;
+                case 12:
+                    keys = _b;
+                    if (!keys) {
+                        throw new Error('Failed to initialize session keys');
+                    }
+                    signFn_2 = createSigningFunction(keys.privateKey);
+                    // Store session keys
+                    storeSessionKeys({
+                        privKey: keys.privateKey,
+                        walletPublicKey: address,
+                        chainName: dynamicWallet.chain,
+                        sessionMode: N1SessionMode.Nord
+                    });
+                    // Set session public key and signing function
+                    setSessionPubKey(keys.publicKey);
+                    setSignMessageWithSessionKey(function () { return signFn_2; });
+                    // Create web session
+                    return [4 /*yield*/, createWebSession(signFn_2, keys.publicKey, walletPubKey, N1SessionMode.Nord)];
+                case 13:
+                    // Create web session
+                    _c.sent();
+                    logger.debug('Session created successfully using legacy method');
+                    return [2 /*return*/, true];
+                case 14:
+                    error_4 = _c.sent();
+                    logger.error('Failed to create session', error_4);
+                    handleError(error_4 instanceof Error
+                        ? error_4
+                        : new Error('Failed to create session'));
+                    return [2 /*return*/, false];
+                case 15: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        dynamicWallet,
+        walletPubKey,
+        address,
+        keyPair,
+        initializeSessionKeys,
+        setSessionPubKey,
+        setSignMessageWithSessionKey,
+        handleError,
+        nord,
+        instanceNordUser,
+        signMessageWithWalletKey,
+    ]);
+    /**
+     * Authenticate Nord session
+     */
+    var authenticateSession = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var success, error_5;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (isAuthenticating)
+                        return [2 /*return*/];
+                    setIsAuthenticating(true);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    // Transition to loading state
+                    transition(FlowState.AUTH_LOADING);
+                    return [4 /*yield*/, createSession()];
+                case 2:
+                    success = _a.sent();
+                    if (success) {
+                        // Update state and context
+                        setHasActiveSession(true);
+                        transition(FlowState.FINAL_SUCCESS, { hasActiveSession: true });
+                    }
+                    else {
+                        throw new WalletError(WalletErrorCode.AUTHENTICATION_FAILED, 'Failed to authenticate Nord session');
+                    }
+                    return [3 /*break*/, 5];
+                case 3:
+                    error_5 = _a.sent();
+                    logger.error('Error in authenticateSession', error_5);
+                    setIsAuthenticating(false);
+                    handleError(error_5 instanceof Error
+                        ? error_5
+                        : new Error('Failed to authenticate Nord session'));
+                    return [3 /*break*/, 5];
+                case 4:
+                    setIsAuthenticating(false);
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, [
+        isAuthenticating,
+        transition,
+        createSession,
+        handleError
+    ]);
+    /**
+     * Run checks based on current state
+     */
+    useEffect(function () {
+        // When wallet is connected, check if user has a Nord account
+        if (state === FlowState.WALLET_CONNECTED && !hasNordAccount && sessionMode === N1SessionMode.Nord) {
+            checkNordAccount();
+        }
+        // When deposit is successful, check if user has an active session
+        if (state === FlowState.DEPOSIT_SUCCESS && !hasActiveSession && sessionMode === N1SessionMode.Nord) {
+            checkNordAccount();
+        }
+        // When in Nord auth state, start authentication
+        if (state === FlowState.NORD_AUTH && !isAuthenticating && sessionMode === N1SessionMode.Nord) {
+            authenticateSession();
+        }
+    }, [
+        state,
+        hasNordAccount,
+        hasActiveSession,
+        isAuthenticating,
+        sessionMode,
+        checkNordAccount,
+        authenticateSession,
+    ]);
+    return {
+        hasNordAccount: hasNordAccount,
+        hasActiveSession: hasActiveSession,
+        isAuthenticating: isAuthenticating,
+        checkNordAccount: checkNordAccount,
+        authenticateSession: authenticateSession,
+        nordUser: instanceNordUser
+    };
+};

package/dist/Modal/NordFlow/hooks/useNordWalletConnect.d.ts

@@ -0,0 +1,14 @@
+import { N1SessionMode } from '../../../Provider/types';
+import { FlowState } from '../types';
+/**
+ * Hook for handling wallet connection
+ *
+ * @param options Configuration options
+ * @returns Wallet connection methods and state
+ */
+export declare const useNordWalletConnect: (state: FlowState, transition: (newState: FlowState, contextUpdates?: Partial<any>) => void, context: any, updateContext: (updates: Partial<any>) => void, sessionMode?: N1SessionMode) => {
+    isConnecting: boolean;
+    walletType: "solana" | "ethereum" | null;
+    connectWallet: () => Promise<void>;
+    disconnectWallet: () => void;
+};

package/dist/Modal/NordFlow/hooks/useNordWalletConnect.js

@@ -0,0 +1,239 @@
+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, useEffect, useState, useRef } from 'react';
+import { useN1WalletContext, useN1WalletInternalContext, } from '../../../Provider/hooks';
+import { N1SessionMode } from '../../../Provider/types';
+import { logger } from '../../../utils/logger';
+import { FlowState } from '../types';
+/**
+ * Hook for handling wallet connection
+ *
+ * @param options Configuration options
+ * @returns Wallet connection methods and state
+ */
+export var useNordWalletConnect = function (state, transition, context, updateContext, sessionMode) {
+    var _a = useN1WalletContext(), nord = _a.nord, nordUser = _a.nordUser;
+    var _b = useN1WalletInternalContext(), showDynamicWidget = _b.showDynamicWidget, dynamicWallet = _b.dynamicWallet, setIsConnected = _b.setIsConnected;
+    var _c = useState(false), isConnecting = _c[0], setIsConnecting = _c[1];
+    var _d = useState(context.walletType), walletType = _d[0], setWalletType = _d[1];
+    var _e = useState(false), hasProcessedWallet = _e[0], setHasProcessedWallet = _e[1];
+    // Use a ref to track the current wallet address to prevent processing the same wallet multiple times
+    var processedWalletAddressRef = useRef(null);
+    /**
+     * Determine wallet type from Dynamic wallet
+     */
+    var determineWalletType = useCallback(function () {
+        var _a, _b;
+        if (!dynamicWallet)
+            return null;
+        // Check wallet connector id to determine if it's ethereum or solana
+        var connectorId = ((_b = (_a = dynamicWallet.connector) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.toLowerCase()) || '';
+        if (connectorId.includes('solana') || connectorId.includes('phantom')) {
+            return 'solana';
+        }
+        else {
+            // Default to ethereum for most other wallets
+            return 'ethereum';
+        }
+    }, [dynamicWallet]);
+    /**
+     * Connect wallet using Dynamic widget
+     */
+    var connectWallet = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (isConnecting || !showDynamicWidget)
+                        return [2 /*return*/];
+                    setIsConnecting(true);
+                    setHasProcessedWallet(false);
+                    logger.debug('Starting wallet connection process');
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    // Show Dynamic widget to connect wallet
+                    return [4 /*yield*/, showDynamicWidget(true)];
+                case 2:
+                    // Show Dynamic widget to connect wallet
+                    _a.sent();
+                    logger.debug('Dynamic widget shown');
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _a.sent();
+                    setIsConnecting(false);
+                    updateContext({ walletType: null });
+                    logger.error('Error showing Dynamic widget:', error_1);
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); }, [isConnecting, showDynamicWidget, updateContext]);
+    /**
+     * Disconnect wallet
+     */
+    var disconnectWallet = useCallback(function () {
+        logger.debug('Disconnecting wallet');
+        setWalletType(null);
+        setHasProcessedWallet(false);
+        updateContext({ walletType: null });
+    }, [updateContext]);
+    useEffect(function () {
+        if (hasProcessedWallet && nordUser) {
+            (function () { return __awaiter(void 0, void 0, void 0, function () {
+                var hasNordAccount, sessionId, hasActiveSession, transitionDestination;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, nord.accountExists(dynamicWallet.address)];
+                        case 1:
+                            hasNordAccount = _a.sent();
+                            sessionId = nordUser.sessionId;
+                            hasActiveSession = sessionId != null;
+                            updateContext({ hasNordAccount: hasNordAccount, hasActiveSession: hasActiveSession });
+                            transitionDestination = hasNordAccount
+                                ? sessionId != null
+                                    ? FlowState.FINAL_SUCCESS
+                                    : FlowState.AUTH_LOADING
+                                : FlowState.CHAIN_SELECTION;
+                            if (hasNordAccount && sessionId != null) {
+                                setIsConnected(true);
+                            }
+                            // Force a small delay to ensure UI updates properly
+                            setTimeout(function () {
+                                try {
+                                    logger.debug('Attempting transition to ' + transitionDestination);
+                                    transition(transitionDestination, {
+                                        walletType: 'solana',
+                                        hasNordAccount: hasNordAccount,
+                                        hasActiveSession: hasActiveSession,
+                                    });
+                                    logger.debug('Transition to ' + transitionDestination + ' completed');
+                                    // Try again with a longer delay as a fallback
+                                    setTimeout(function () {
+                                        logger.debug('Trying fallback transition after delay');
+                                        transition(transitionDestination, {
+                                            walletType: 'solana',
+                                            hasNordAccount: hasNordAccount,
+                                            hasActiveSession: hasActiveSession,
+                                        });
+                                    }, 500);
+                                }
+                                catch (error) {
+                                    logger.error('Error during transition:', error);
+                                }
+                                finally {
+                                    setIsConnecting(false);
+                                }
+                            }, 100);
+                            return [2 /*return*/];
+                    }
+                });
+            }); })();
+        }
+    }, [hasProcessedWallet, nordUser]);
+    /**
+     * Effect to handle wallet connection state changes
+     */
+    useEffect(function () {
+        var isNordMode = sessionMode === N1SessionMode.Nord;
+        // If we don't have a wallet, nothing to process
+        if (!dynamicWallet) {
+            return;
+        }
+        // If we've already processed this specific wallet address, don't process again
+        if (hasProcessedWallet &&
+            processedWalletAddressRef.current === dynamicWallet.address) {
+            logger.debug('Skipping wallet processing - already processed this address');
+            return;
+        }
+        // Use an IIFE to handle the async processing
+        (function () { return __awaiter(void 0, void 0, void 0, function () {
+            var type;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                // Prevent processing if already in progress
+                if (hasProcessedWallet) {
+                    logger.debug('Skipping wallet processing - hasProcessedWallet is true');
+                    return [2 /*return*/];
+                }
+                logger.debug('Processing wallet connection:', {
+                    wallet: (_a = dynamicWallet.connector) === null || _a === void 0 ? void 0 : _a.name,
+                    address: (_b = dynamicWallet.address) === null || _b === void 0 ? void 0 : _b.slice(0, 8),
+                    state: state,
+                    isNordMode: isNordMode,
+                });
+                // Set processed flag first to prevent re-entry
+                setHasProcessedWallet(true);
+                processedWalletAddressRef.current = dynamicWallet.address;
+                type = determineWalletType();
+                setWalletType(type);
+                return [2 /*return*/];
+            });
+        }); })();
+        // Cleanup function to handle component unmount
+        return function () {
+            logger.debug('Wallet connection effect cleanup');
+        };
+    }, [dynamicWallet, determineWalletType]);
+    // Handle wallet disconnection in a separate effect
+    useEffect(function () {
+        if (!dynamicWallet && hasProcessedWallet) {
+            logger.debug('Wallet disconnected, resetting processed flag');
+            processedWalletAddressRef.current = null;
+            setHasProcessedWallet(false);
+        }
+    }, [dynamicWallet, hasProcessedWallet]);
+    // Handle connecting state changes in a separate effect
+    useEffect(function () {
+        if (state === FlowState.CONNECTING_WALLET &&
+            !dynamicWallet &&
+            isConnecting) {
+            // Only keep isConnecting true if we're in the connecting state and don't have a wallet yet
+            // This prevents an infinite loop of setting isConnecting
+        }
+        else if (state !== FlowState.CONNECTING_WALLET && isConnecting) {
+            // If we're no longer in the connecting state, reset the connecting flag
+            setIsConnecting(false);
+        }
+    }, [state, dynamicWallet, isConnecting]);
+    return {
+        isConnecting: isConnecting,
+        walletType: walletType,
+        connectWallet: connectWallet,
+        disconnectWallet: disconnectWallet,
+    };
+};

package/dist/Modal/NordFlow/hooks/useTableValues.d.ts

@@ -0,0 +1,2 @@
+import { TableValues } from '../types';
+export declare function useTableValues(isSuccessView: boolean, selectedChain: string | null): TableValues;