@n1xyz/wallet-widget 0.0.8 → 0.0.10

package/dist/WalletConnectionFlow/hooks/useFlowState.js

@@ -1,163 +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 { useCallback, useEffect, useState } from 'react';
-import { FlowState, initialFlowContext } from '../types';
-import { STATE_TRANSITIONS } from '../constants';
-import { clearStoredState, loadStateFromLocalStorage, saveStateToLocalStorage, } from '../utils/persistence';
-/**
- * Custom hook for managing the wallet connection flow state machine
- * @param options Configuration options
- * @returns Flow state management methods and properties
- */
-export var useFlowState = function (options) {
-    var _a = options.autoRecover, autoRecover = _a === void 0 ? true : _a, onStateChange = options.onStateChange, onError = options.onError;
-    // Flow state
-    var _b = useState(FlowState.IDLE), state = _b[0], setState = _b[1];
-    var _c = useState(null), prevState = _c[0], setPrevState = _c[1];
-    var _d = useState(initialFlowContext), context = _d[0], setContext = _d[1];
-    var _e = useState(false), isTransitioning = _e[0], setIsTransitioning = _e[1];
-    var _f = useState(false), isRecoveryAvailable = _f[0], setIsRecoveryAvailable = _f[1];
-    /**
-     * Check if a transition is allowed based on current state and context
-     */
-    var canTransition = useCallback(function (targetState) {
-        return STATE_TRANSITIONS.some(function (transition) {
-            var fromMatches = Array.isArray(transition.from)
-                ? transition.from.includes(state)
-                : transition.from === state;
-            if (!fromMatches || transition.to !== targetState) {
-                return false;
-            }
-            if (transition.condition) {
-                return transition.condition(context);
-            }
-            return true;
-        });
-    }, [state, context]);
-    /**
-     * Transition to a new state if allowed
-     */
-    var transition = useCallback(function (targetState, contextUpdates) {
-        if (contextUpdates === void 0) { contextUpdates = {}; }
-        if (!canTransition(targetState)) {
-            console.warn("Transition from ".concat(state, " to ").concat(targetState, " is not allowed"));
-            return false;
-        }
-        setIsTransitioning(true);
-        // Update context first
-        setContext(function (prevContext) {
-            var newContext = __assign(__assign({}, prevContext), contextUpdates);
-            // Save new state and context to localStorage for recovery
-            saveStateToLocalStorage(targetState, newContext);
-            return newContext;
-        });
-        // Then update state
-        setPrevState(state);
-        setState(targetState);
-        if (onStateChange) {
-            onStateChange(targetState, state);
-        }
-        setIsTransitioning(false);
-        return true;
-    }, [canTransition, state, onStateChange]);
-    /**
-     * Reset flow to initial state
-     */
-    var reset = useCallback(function () {
-        clearStoredState();
-        setContext(initialFlowContext);
-        setPrevState(null);
-        setState(FlowState.IDLE);
-        if (onStateChange) {
-            onStateChange(FlowState.IDLE, state);
-        }
-    }, [state, onStateChange]);
-    /**
-     * Handle an error by transitioning to error state
-     */
-    var handleError = useCallback(function (error) {
-        if (onError) {
-            onError(error);
-        }
-        transition(FlowState.ERROR, { error: error });
-    }, [transition, onError]);
-    /**
-     * Recover state from localStorage
-     */
-    var recover = useCallback(function () {
-        var savedState = loadStateFromLocalStorage();
-        if (!savedState) {
-            setIsRecoveryAvailable(false);
-            return false;
-        }
-        setContext(savedState.context);
-        setPrevState(state);
-        setState(savedState.state);
-        if (onStateChange) {
-            onStateChange(savedState.state, state);
-        }
-        return true;
-    }, [state, onStateChange]);
-    /**
-     * Update context without state transition
-     */
-    var updateContext = useCallback(function (updates) {
-        setContext(function (prevContext) {
-            var newContext = __assign(__assign({}, prevContext), updates);
-            saveStateToLocalStorage(state, newContext);
-            return newContext;
-        });
-    }, [state]);
-    /**
-     * Record an interruption in the flow (e.g., modal close, page reload)
-     */
-    var recordInterruption = useCallback(function () {
-        updateContext({
-            lastInterruption: {
-                timestamp: Date.now(),
-                state: state,
-                context: __assign({}, context),
-            },
-        });
-    }, [state, context, updateContext]);
-    // Check for recoverable state on mount
-    useEffect(function () {
-        var hasRecoverable = loadStateFromLocalStorage() !== null;
-        setIsRecoveryAvailable(hasRecoverable);
-        if (autoRecover && hasRecoverable) {
-            recover();
-        }
-    }, [autoRecover, recover]);
-    // Register unload handler to record interruptions
-    useEffect(function () {
-        var handleBeforeUnload = function () {
-            recordInterruption();
-        };
-        window.addEventListener('beforeunload', handleBeforeUnload);
-        return function () {
-            window.removeEventListener('beforeunload', handleBeforeUnload);
-        };
-    }, [recordInterruption]);
-    return {
-        state: state,
-        prevState: prevState,
-        context: context,
-        isTransitioning: isTransitioning,
-        isRecoveryAvailable: isRecoveryAvailable,
-        transition: transition,
-        updateContext: updateContext,
-        reset: reset,
-        recover: recover,
-        recordInterruption: recordInterruption,
-        handleError: handleError,
-    };
-};

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

@@ -1,27 +0,0 @@
-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/WalletConnectionFlow/hooks/useInterruptHandler.js

@@ -1,101 +0,0 @@
-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/WalletConnectionFlow/hooks/useNordSession.d.ts

@@ -1,32 +0,0 @@
-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/WalletConnectionFlow/hooks/useNordSession.js

@@ -1,193 +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 { 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/WalletConnectionFlow/hooks/useTableValues.d.ts

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

package/dist/WalletConnectionFlow/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/WalletConnectionFlow/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/WalletConnectionFlow/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 };
-}