@n1xyz/wallet-widget 0.0.4 → 0.0.5

package/dist/NordFlow/hooks/useInterruptHandler.d.ts

@@ -0,0 +1,27 @@
+import { FlowState } from '../types';
+/**
+ * Hook for handling interruptions during the flow
+ *
+ * @param options Configuration options
+ * @returns Interruption handling methods and state
+ */
+export declare const useInterruptHandler: (options: {
+    /**
+     * Flow state
+     */
+    state: FlowState;
+    /**
+     * Record an interruption
+     */
+    recordInterruption: () => void;
+    /**
+     * Callback to handle modal close
+     */
+    onClose?: () => void;
+}) => {
+    isClosing: boolean;
+    showConfirmation: boolean;
+    handleCloseRequest: () => boolean;
+    confirmClose: () => void;
+    cancelClose: () => void;
+};

package/dist/NordFlow/hooks/useInterruptHandler.js

@@ -0,0 +1,101 @@
+import { useCallback, useEffect, useState } from 'react';
+import { FlowState } from '../types';
+/**
+ * Critical states that require confirmation before closing
+ */
+var CRITICAL_STATES = [
+    FlowState.DEPOSIT_PROGRESS,
+    FlowState.AUTH_LOADING,
+    FlowState.ETH_TO_SOL_AUTH,
+];
+/**
+ * Hook for handling interruptions during the flow
+ *
+ * @param options Configuration options
+ * @returns Interruption handling methods and state
+ */
+export var useInterruptHandler = function (options) {
+    var state = options.state, recordInterruption = options.recordInterruption, onClose = options.onClose;
+    var _a = useState(false), isClosing = _a[0], setIsClosing = _a[1];
+    var _b = useState(false), showConfirmation = _b[0], setShowConfirmation = _b[1];
+    /**
+     * Handle modal close request
+     */
+    var handleCloseRequest = useCallback(function () {
+        // If in a critical state, show confirmation
+        if (CRITICAL_STATES.includes(state)) {
+            setShowConfirmation(true);
+            return false;
+        }
+        // Otherwise, proceed with closing
+        setIsClosing(true);
+        recordInterruption();
+        // Delay actual close to allow animation
+        setTimeout(function () {
+            if (onClose) {
+                onClose();
+            }
+        }, 300);
+        return true;
+    }, [state, recordInterruption, onClose]);
+    /**
+     * Confirm close
+     */
+    var confirmClose = useCallback(function () {
+        setShowConfirmation(false);
+        setIsClosing(true);
+        recordInterruption();
+        // Delay actual close to allow animation
+        setTimeout(function () {
+            if (onClose) {
+                onClose();
+            }
+        }, 300);
+    }, [recordInterruption, onClose]);
+    /**
+     * Cancel close
+     */
+    var cancelClose = useCallback(function () {
+        setShowConfirmation(false);
+    }, []);
+    /**
+     * Handle beforeunload event to record interruptions
+     */
+    useEffect(function () {
+        var handleBeforeUnload = function (event) {
+            // Record the interruption
+            recordInterruption();
+            // If in a critical state, show confirmation
+            if (CRITICAL_STATES.includes(state)) {
+                // Show a confirmation dialog
+                event.preventDefault();
+                event.returnValue = '';
+                return '';
+            }
+        };
+        window.addEventListener('beforeunload', handleBeforeUnload);
+        return function () {
+            window.removeEventListener('beforeunload', handleBeforeUnload);
+        };
+    }, [state, recordInterruption]);
+    /**
+     * Handle focus events to detect when user returns to the page
+     */
+    useEffect(function () {
+        var handleFocus = function () {
+            // Here we could potentially check for state changes
+            // that happened while the user was away
+        };
+        window.addEventListener('focus', handleFocus);
+        return function () {
+            window.removeEventListener('focus', handleFocus);
+        };
+    }, []);
+    return {
+        isClosing: isClosing,
+        showConfirmation: showConfirmation,
+        handleCloseRequest: handleCloseRequest,
+        confirmClose: confirmClose,
+        cancelClose: cancelClose,
+    };
+};

package/dist/NordFlow/hooks/useNordSession.d.ts

@@ -0,0 +1,32 @@
+import { FlowContext, FlowState } from '../types';
+/**
+ * Hook for handling Nord session authentication
+ *
+ * @param options Configuration options
+ * @returns Nord session methods and state
+ */
+export declare const useNordSession: (options: {
+    /**
+     * Flow state
+     */
+    state: FlowState;
+    /**
+     * Flow context
+     */
+    context: FlowContext;
+    /**
+     * Transition to a new state
+     */
+    transition: (newState: FlowState, contextUpdates?: Partial<FlowContext>) => boolean;
+    /**
+     * Handle errors
+     */
+    handleError: (error: Error) => void;
+}) => {
+    isAuthenticating: boolean;
+    hasNordAccount: boolean;
+    hasActiveSession: boolean;
+    checkNordAccount: () => Promise<void>;
+    checkActiveSession: () => Promise<void>;
+    authenticateSession: () => Promise<void>;
+};

package/dist/NordFlow/hooks/useNordSession.js

@@ -0,0 +1,193 @@
+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 { FlowState } from '../types';
+/**
+ * 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 = useState(false), isAuthenticating = _a[0], setIsAuthenticating = _a[1];
+    var _b = useState(context.hasNordAccount), hasNordAccount = _b[0], setHasNordAccount = _b[1];
+    var _c = useState(context.hasActiveSession), hasActiveSession = _c[0], setHasActiveSession = _c[1];
+    /**
+     * Check if user has a Nord account
+     * This is a placeholder implementation
+     */
+    var checkNordAccount = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                // In the real implementation, this would check with the backend
+                // For now, simulate the check with a timeout
+                setTimeout(function () {
+                    // For demo purposes, simulate the result
+                    var hasAccount = Math.random() > 0.3;
+                    setHasNordAccount(hasAccount);
+                    // Update context
+                    transition(state, { hasNordAccount: hasAccount });
+                    // 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 (hasAccount) {
+                            if (context.hasActiveSession) {
+                                transition(FlowState.FINAL_SUCCESS);
+                            }
+                            else {
+                                transition(FlowState.NORD_AUTH);
+                            }
+                        }
+                        else {
+                            transition(FlowState.CHAIN_SELECTION);
+                        }
+                    }
+                }, 1000);
+            }
+            catch (error) {
+                handleError(error instanceof Error
+                    ? error
+                    : new Error('Failed to check Nord account'));
+            }
+            return [2 /*return*/];
+        });
+    }); }, [
+        state,
+        context.walletType,
+        context.hasActiveSession,
+        transition,
+        handleError,
+    ]);
+    /**
+     * Check if user has an active Nord session
+     * This is a placeholder implementation
+     */
+    var checkActiveSession = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                // In the real implementation, this would check with the backend
+                // For now, simulate the check with a timeout
+                setTimeout(function () {
+                    // For demo purposes, simulate the result
+                    var hasSession = Math.random() > 0.5;
+                    setHasActiveSession(hasSession);
+                    // Update context
+                    transition(state, { hasActiveSession: hasSession });
+                    // If in DEPOSIT_SUCCESS state, transition to appropriate next state
+                    if (state === FlowState.DEPOSIT_SUCCESS) {
+                        if (hasSession) {
+                            transition(FlowState.FINAL_SUCCESS);
+                        }
+                        else {
+                            transition(FlowState.NORD_AUTH);
+                        }
+                    }
+                }, 1000);
+            }
+            catch (error) {
+                handleError(error instanceof Error
+                    ? error
+                    : new Error('Failed to check active session'));
+            }
+            return [2 /*return*/];
+        });
+    }); }, [state, transition, handleError]);
+    /**
+     * Authenticate Nord session
+     * This is a placeholder implementation
+     */
+    var authenticateSession = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var transitionResult;
+        return __generator(this, function (_a) {
+            console.log('authenticateSession start', { state: state, isAuthenticating: isAuthenticating });
+            if (isAuthenticating)
+                return [2 /*return*/];
+            setIsAuthenticating(true);
+            try {
+                console.log('About to transition to AUTH_LOADING');
+                transitionResult = transition(FlowState.AUTH_LOADING);
+                console.log('Transition to AUTH_LOADING result:', transitionResult);
+                // The actual authentication will now be handled by the AuthLoadingScreen component
+                // This simplifies our flow and avoids closure issues with the state variable
+            }
+            catch (error) {
+                console.error('Error in authenticateSession:', error);
+                setIsAuthenticating(false);
+                handleError(error instanceof Error
+                    ? error
+                    : new Error('Failed to authenticate Nord session'));
+            }
+            return [2 /*return*/];
+        });
+    }); }, [isAuthenticating, transition, handleError, state]);
+    /**
+     * 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) {
+            checkNordAccount();
+        }
+        // When deposit is successful, check if user has an active session
+        if (state === FlowState.DEPOSIT_SUCCESS && !hasActiveSession) {
+            checkActiveSession();
+        }
+        // When in Nord auth state, start authentication
+        if (state === FlowState.NORD_AUTH && !isAuthenticating) {
+            authenticateSession();
+        }
+    }, [
+        state,
+        hasNordAccount,
+        hasActiveSession,
+        isAuthenticating,
+        checkNordAccount,
+        checkActiveSession,
+        authenticateSession,
+    ]);
+    return {
+        isAuthenticating: isAuthenticating,
+        hasNordAccount: hasNordAccount,
+        hasActiveSession: hasActiveSession,
+        checkNordAccount: checkNordAccount,
+        checkActiveSession: checkActiveSession,
+        authenticateSession: authenticateSession,
+    };
+};

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

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

package/dist/NordFlow/hooks/useTableValues.js

@@ -0,0 +1,69 @@
+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/NordFlow/hooks/useWaitingMessage.d.ts

@@ -0,0 +1,6 @@
+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/NordFlow/hooks/useWaitingMessage.js

@@ -0,0 +1,89 @@
+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/NordFlow/hooks/useWalletConnect.d.ts

@@ -0,0 +1,30 @@
+import { FlowContext, FlowState } from '../types';
+/**
+ * Hook for handling wallet connection
+ *
+ * @param options Configuration options
+ * @returns Wallet connection methods and state
+ */
+export declare const useWalletConnect: (options: {
+    /**
+     * Flow state management
+     */
+    state: FlowState;
+    /**
+     * Flow context
+     */
+    context: FlowContext;
+    /**
+     * Transition to a new state
+     */
+    transition: (newState: FlowState, contextUpdates?: Partial<FlowContext>) => boolean;
+    /**
+     * Handle errors
+     */
+    handleError: (error: Error) => void;
+}) => {
+    isConnecting: boolean;
+    walletType: "solana" | "ethereum" | null;
+    connectWallet: () => Promise<void>;
+    disconnectWallet: () => void;
+};