@n1xyz/wallet-widget 0.0.8 → 0.0.10

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

@@ -1,391 +0,0 @@
-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/useTableValues.d.ts

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

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

@@ -1,69 +0,0 @@
-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);
-};
-import { useState, useEffect } from 'react';
-import { CHAINS, TYPING_INTERVAL } from '../constants';
-export function useTableValues(isSuccessView, selectedChain) {
-    var _a = useState({
-        tx: { text: '', visible: false, typing: false },
-        from: { text: '', visible: false, typing: false },
-        to: { text: '', visible: false, typing: false },
-        network: { text: '', visible: false, typing: false },
-        status: { text: '', visible: false, typing: false },
-    }), tableValues = _a[0], setTableValues = _a[1];
-    useEffect(function () {
-        if (isSuccessView) {
-            var chain = CHAINS.find(function (c) { return c.id === selectedChain; });
-            var values = {
-                tx: '0x1234...5678',
-                from: '0xabcd...ef01',
-                to: '0x2345...6789',
-                network: (chain === null || chain === void 0 ? void 0 : chain.name) || 'Unknown',
-                status: 'Success',
-            };
-            Object.entries(values).forEach(function (_a, index) {
-                var key = _a[0], value = _a[1];
-                setTimeout(function () {
-                    var textIndex = 0;
-                    setTableValues(function (prev) {
-                        var _a;
-                        return (__assign(__assign({}, prev), (_a = {}, _a[key] = __assign(__assign({}, prev[key]), { visible: true }), _a)));
-                    });
-                    var interval = setInterval(function () {
-                        if (textIndex <= value.length) {
-                            setTableValues(function (prev) {
-                                var _a;
-                                return (__assign(__assign({}, prev), (_a = {}, _a[key] = {
-                                    text: value.slice(0, textIndex),
-                                    visible: true,
-                                    typing: true,
-                                }, _a)));
-                            });
-                            textIndex++;
-                        }
-                        else {
-                            clearInterval(interval);
-                            setTableValues(function (prev) {
-                                var _a;
-                                return (__assign(__assign({}, prev), (_a = {}, _a[key] = {
-                                    text: value,
-                                    visible: true,
-                                    typing: false,
-                                }, _a)));
-                            });
-                        }
-                    }, TYPING_INTERVAL);
-                }, index * 500);
-            });
-        }
-    }, [isSuccessView, selectedChain]);
-    return tableValues;
-}

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

@@ -1,6 +0,0 @@
-import { Dispatch, SetStateAction } from 'react';
-import { WaitingMessageState } from '../types';
-export declare function useWaitingMessage(isSigningView: boolean, isWaitingForTx: boolean, setIsWaitingForTx: Dispatch<SetStateAction<boolean>>, setIsSuccessView: Dispatch<SetStateAction<boolean>>, setIsSigningView: Dispatch<SetStateAction<boolean>>): {
-    waitingMessage: WaitingMessageState;
-    setHasError: Dispatch<SetStateAction<boolean>>;
-};

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

@@ -1,89 +0,0 @@
-import { useState, useEffect } from 'react';
-import { TYPING_INTERVAL } from '../constants';
-export function useWaitingMessage(isSigningView, isWaitingForTx, setIsWaitingForTx, setIsSuccessView, setIsSigningView) {
-    var _a = useState({
-        title: '',
-        subtitle: '',
-        visible: false,
-        isTyping: false,
-    }), waitingMessage = _a[0], setWaitingMessage = _a[1];
-    var _b = useState(false), hasError = _b[0], setHasError = _b[1];
-    useEffect(function () {
-        if (isSigningView && !isWaitingForTx) {
-            var messages_1 = [
-                {
-                    title: 'Waiting for signature',
-                    subtitle: 'Please sign the transaction in your wallet',
-                    delay: 0,
-                },
-                {
-                    title: 'Waiting for transaction',
-                    subtitle: 'Transaction is being processed...',
-                    delay: 3000,
-                },
-            ];
-            var currentMessageIndex = 0;
-            var showMessage_1 = function (message) {
-                var index = 0;
-                var interval = setInterval(function () {
-                    if (index <= Math.max(message.title.length, message.subtitle.length)) {
-                        setWaitingMessage({
-                            title: message.title.slice(0, index),
-                            subtitle: message.subtitle.slice(0, index),
-                            visible: true,
-                            isTyping: true,
-                        });
-                        index++;
-                    }
-                    else {
-                        clearInterval(interval);
-                        setWaitingMessage({
-                            title: message.title,
-                            subtitle: message.subtitle,
-                            visible: true,
-                            isTyping: false,
-                        });
-                    }
-                }, TYPING_INTERVAL);
-                return interval;
-            };
-            var currentInterval_1 = showMessage_1(messages_1[currentMessageIndex]);
-            var messageTimeout_1 = setTimeout(function () {
-                clearInterval(currentInterval_1);
-                currentInterval_1 = showMessage_1(messages_1[1]);
-                setTimeout(function () {
-                    setIsWaitingForTx(true);
-                    setTimeout(function () {
-                        if (!hasError) {
-                            setIsSuccessView(true);
-                        }
-                        else {
-                            setWaitingMessage({
-                                title: 'Transaction Failed',
-                                subtitle: 'Please try again',
-                                visible: true,
-                                isTyping: false,
-                            });
-                            setTimeout(function () {
-                                setIsWaitingForTx(false);
-                                setIsSigningView(false);
-                            }, 2000);
-                        }
-                    }, 4000);
-                }, 4000);
-            }, messages_1[1].delay);
-            return function () {
-                clearInterval(currentInterval_1);
-                clearTimeout(messageTimeout_1);
-            };
-        }
-    }, [
-        isSigningView,
-        isWaitingForTx,
-        setIsWaitingForTx,
-        setIsSuccessView,
-        hasError,
-        setIsSigningView,
-    ]);
-    return { waitingMessage: waitingMessage, setHasError: setHasError };
-}

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

@@ -1,14 +0,0 @@
-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 useWalletConnect: (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;
-};