@n1xyz/wallet-widget 0.0.4 → 0.0.5

package/dist/NordFlow/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Types for the wallet connection flow state machine
+ */
+/**
+ * Enum representing all possible states in the wallet connection flow
+ */
+export declare enum FlowState {
+    IDLE = "IDLE",
+    CONNECTING_WALLET = "CONNECTING_WALLET",
+    WALLET_CONNECTED = "WALLET_CONNECTED",
+    ETH_TO_SOL_AUTH = "ETH_TO_SOL_AUTH",
+    CHAIN_SELECTION = "CHAIN_SELECTION",
+    AMOUNT_INPUT = "AMOUNT_INPUT",
+    DEPOSIT_PROGRESS = "DEPOSIT_PROGRESS",
+    DEPOSIT_SUCCESS = "DEPOSIT_SUCCESS",
+    NORD_AUTH = "NORD_AUTH",
+    AUTH_LOADING = "AUTH_LOADING",
+    FINAL_SUCCESS = "FINAL_SUCCESS",
+    ERROR = "ERROR"
+}
+/**
+ * Interface representing the flow context, containing all data necessary
+ * for the wallet connection flow
+ */
+export interface FlowContext {
+    walletType: 'solana' | 'ethereum' | null;
+    hasNordAccount: boolean;
+    hasActiveSession: boolean;
+    selectedChain: string | null;
+    amount: string;
+    transactionId: string | null;
+    error: Error | null;
+    lastInterruption: {
+        timestamp: number;
+        state: FlowState;
+        context: Partial<FlowContext>;
+    } | null;
+}
+/**
+ * Interface for state transitions in the flow
+ */
+export interface StateTransition {
+    from: FlowState | FlowState[];
+    to: FlowState;
+    condition?: (context: FlowContext) => boolean;
+}
+/**
+ * Initial flow context with default values
+ */
+export declare const initialFlowContext: FlowContext;
+export interface TableValues {
+    amount?: {
+        text: string;
+        visible: boolean;
+        typing: boolean;
+    };
+    tx: {
+        text: string;
+        visible: boolean;
+        typing: boolean;
+    };
+    from: {
+        text: string;
+        visible: boolean;
+        typing: boolean;
+    };
+    to: {
+        text: string;
+        visible: boolean;
+        typing: boolean;
+    };
+    network: {
+        text: string;
+        visible: boolean;
+        typing: boolean;
+    };
+    status: {
+        text: string;
+        visible: boolean;
+        typing: boolean;
+    };
+}
+export interface WaitingMessageState {
+    title: string;
+    subtitle: string;
+    visible: boolean;
+    isTyping: boolean;
+}
+export interface Chain {
+    id: string;
+    name: string;
+    logo: string;
+}
+export interface App {
+    name: string;
+    color: string;
+    progress: number;
+}
+export type ButtonKey = 'deposit' | 'continue' | 'openApp';
+export interface ButtonState {
+    text: string;
+    isTyping: boolean;
+    showCursor: boolean;
+}
+export type ButtonStates = Record<ButtonKey, ButtonState>;

package/dist/NordFlow/types.js

@@ -0,0 +1,34 @@
+/**
+ * Types for the wallet connection flow state machine
+ */
+/**
+ * Enum representing all possible states in the wallet connection flow
+ */
+export var FlowState;
+(function (FlowState) {
+    FlowState["IDLE"] = "IDLE";
+    FlowState["CONNECTING_WALLET"] = "CONNECTING_WALLET";
+    FlowState["WALLET_CONNECTED"] = "WALLET_CONNECTED";
+    FlowState["ETH_TO_SOL_AUTH"] = "ETH_TO_SOL_AUTH";
+    FlowState["CHAIN_SELECTION"] = "CHAIN_SELECTION";
+    FlowState["AMOUNT_INPUT"] = "AMOUNT_INPUT";
+    FlowState["DEPOSIT_PROGRESS"] = "DEPOSIT_PROGRESS";
+    FlowState["DEPOSIT_SUCCESS"] = "DEPOSIT_SUCCESS";
+    FlowState["NORD_AUTH"] = "NORD_AUTH";
+    FlowState["AUTH_LOADING"] = "AUTH_LOADING";
+    FlowState["FINAL_SUCCESS"] = "FINAL_SUCCESS";
+    FlowState["ERROR"] = "ERROR";
+})(FlowState || (FlowState = {}));
+/**
+ * Initial flow context with default values
+ */
+export var initialFlowContext = {
+    walletType: null,
+    hasNordAccount: false,
+    hasActiveSession: false,
+    selectedChain: null,
+    amount: '',
+    transactionId: null,
+    error: null,
+    lastInterruption: null,
+};

package/dist/NordFlow/utils/persistence.d.ts

@@ -0,0 +1,24 @@
+import { FlowContext, FlowState } from '../types';
+/**
+ * Saves the current flow state and context to localStorage
+ * @param state Current flow state
+ * @param context Current flow context
+ */
+export declare const saveStateToLocalStorage: (state: FlowState, context: FlowContext) => void;
+/**
+ * Loads the flow state and context from localStorage if available and not expired
+ * @returns The loaded state and context, or null if not available or expired
+ */
+export declare const loadStateFromLocalStorage: () => {
+    state: FlowState;
+    context: FlowContext;
+} | null;
+/**
+ * Clears the stored flow state from localStorage
+ */
+export declare const clearStoredState: () => void;
+/**
+ * Checks if there is a stored state that can be recovered
+ * @returns True if there is a recoverable state, false otherwise
+ */
+export declare const hasRecoverableState: () => boolean;

package/dist/NordFlow/utils/persistence.js

@@ -0,0 +1,83 @@
+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 { initialFlowContext } from '../types';
+import { FLOW_STATE_STORAGE_KEY, STATE_EXPIRY_TIME } from '../constants';
+/**
+ * Saves the current flow state and context to localStorage
+ * @param state Current flow state
+ * @param context Current flow context
+ */
+export var saveStateToLocalStorage = function (state, context) {
+    try {
+        var persistedData = {
+            state: state,
+            context: __assign(__assign({}, context), { 
+                // Filter out any sensitive data or error objects that shouldn't be persisted
+                error: context.error
+                    ? {
+                        message: context.error.message,
+                        name: context.error.name,
+                    }
+                    : null }),
+            timestamp: Date.now(),
+        };
+        localStorage.setItem(FLOW_STATE_STORAGE_KEY, JSON.stringify(persistedData));
+    }
+    catch (error) {
+        console.error('Failed to save flow state:', error);
+    }
+};
+/**
+ * Loads the flow state and context from localStorage if available and not expired
+ * @returns The loaded state and context, or null if not available or expired
+ */
+export var loadStateFromLocalStorage = function () {
+    try {
+        var storedData = localStorage.getItem(FLOW_STATE_STORAGE_KEY);
+        if (!storedData) {
+            return null;
+        }
+        var parsedData = JSON.parse(storedData);
+        var state = parsedData.state, context = parsedData.context, timestamp = parsedData.timestamp;
+        // Check if data is expired
+        if (Date.now() - timestamp > STATE_EXPIRY_TIME) {
+            localStorage.removeItem(FLOW_STATE_STORAGE_KEY);
+            return null;
+        }
+        return {
+            state: state,
+            context: __assign(__assign({}, initialFlowContext), context),
+        };
+    }
+    catch (error) {
+        console.error('Failed to load flow state:', error);
+        return null;
+    }
+};
+/**
+ * Clears the stored flow state from localStorage
+ */
+export var clearStoredState = function () {
+    try {
+        localStorage.removeItem(FLOW_STATE_STORAGE_KEY);
+    }
+    catch (error) {
+        console.error('Failed to clear flow state:', error);
+    }
+};
+/**
+ * Checks if there is a stored state that can be recovered
+ * @returns True if there is a recoverable state, false otherwise
+ */
+export var hasRecoverableState = function () {
+    return loadStateFromLocalStorage() !== null;
+};

package/dist/Provider/LazyWalletProvider.js

@@ -46,86 +46,111 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState, useRef } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 import { useN1WalletInternalContext } from './hooks';
-import { logger } from '../utils/logger';
-import { N1ModalViewMode } from './types';
-var getSettings = function (darkMode) { return ({
-    initialAuthenticationMode: 'connect-only',
-    environmentId: '9a47561c-6a0b-4a5b-ace1-12621c11cebd',
-    theme: {
-        mode: darkMode ? 'dark' : 'light',
-    },
-    events: {
-        onAuthSuccess: function (args) {
-            console.log('onAuthSuccess was called', args);
-        },
-    },
-}); };
+import { N1SessionMode } from './types';
 function DynamicContextConsumer(_a) {
     var children = _a.children;
-    var _b = useN1WalletInternalContext(), setDynamicWallet = _b.setDynamicWallet, setAddress = _b.setAddress, setDynamicSdkHasLoaded = _b.setDynamicSdkHasLoaded, setShowDynamicWidget = _b.setShowDynamicWidget, setDynamicHandleLogOut = _b.setDynamicHandleLogOut, setViewMode = _b.setViewMode;
-    var _c = useState(null), DynamicContext = _c[0], setDynamicContext = _c[1];
+    var _b = useState(null), DynamicContext = _b[0], setDynamicContext = _b[1];
     var showAuthFlowRef = useRef(null);
+    // Use refs to track previous values and prevent unnecessary updates
+    var prevPrimaryWalletRef = useRef(null);
+    var prevHandleLogOutRef = useRef(null);
+    var prevSdkHasLoadedRef = useRef(null);
+    var _c = useN1WalletInternalContext(), setDynamicWallet = _c.setDynamicWallet, setDynamicHandleLogOut = _c.setDynamicHandleLogOut, setDynamicSdkHasLoaded = _c.setDynamicSdkHasLoaded, setAddress = _c.setAddress, setShowDynamicWidget = _c.setShowDynamicWidget;
+    // Load the Dynamic context only once
     useEffect(function () {
+        var isMounted = true;
         import('@dynamic-labs/sdk-react-core').then(function (_a) {
             var useDynamicContext = _a.useDynamicContext;
-            setDynamicContext(function () { return useDynamicContext; });
+            if (isMounted) {
+                setDynamicContext(function () { return useDynamicContext; });
+            }
         });
+        return function () { isMounted = false; };
     }, []);
-    // Set up a stable widget function that uses the ref
+    // Set up a stable widget function that uses the ref - only once
     useEffect(function () {
-        setShowDynamicWidget(function () { return function (show) {
-            console.log('yeeyyeye', showAuthFlowRef);
-            console.log('yeeyyeye', showAuthFlowRef.current, show);
+        var stableShowWidget = function (show) {
             if (showAuthFlowRef.current) {
                 showAuthFlowRef.current(show);
             }
-        }; });
+        };
+        setShowDynamicWidget(function () { return stableShowWidget; });
     }, [setShowDynamicWidget]);
     if (!DynamicContext) {
         return _jsx(_Fragment, { children: children });
     }
     var DynamicComponent = function () {
         var _a = DynamicContext(), primaryWallet = _a.primaryWallet, sdkHasLoaded = _a.sdkHasLoaded, setShowAuthFlow = _a.setShowAuthFlow, handleLogOut = _a.handleLogOut;
-        // Store setShowAuthFlow in ref to avoid re-renders
+        // Store setShowAuthFlow in ref to avoid re-renders - only when it changes
         useEffect(function () {
-            showAuthFlowRef.current = setShowAuthFlow;
+            if (setShowAuthFlow !== showAuthFlowRef.current) {
+                showAuthFlowRef.current = setShowAuthFlow;
+            }
         }, [setShowAuthFlow]);
+        // Set the dynamic wallet and address when the primary wallet changes
+        // Use deep comparison to prevent unnecessary updates
         useEffect(function () {
-            if (primaryWallet === null || primaryWallet === void 0 ? void 0 : primaryWallet.address) {
-                logger.debug('Primary wallet found');
+            // Skip if the wallet hasn't actually changed
+            if (primaryWallet === prevPrimaryWalletRef.current) {
+                return;
+            }
+            prevPrimaryWalletRef.current = primaryWallet;
+            if (primaryWallet) {
                 setDynamicWallet(primaryWallet);
                 setAddress(primaryWallet.address);
             }
             else {
-                logger.debug('No primary wallet found');
                 setDynamicWallet(null);
                 setAddress('');
-                setViewMode(N1ModalViewMode.Connect);
             }
-        }, [primaryWallet]);
+        }, [primaryWallet, setDynamicWallet, setAddress]);
+        // Set the logout handler when it changes - only when it actually changes
         useEffect(function () {
-            if (sdkHasLoaded) {
-                setDynamicSdkHasLoaded(true);
+            if (handleLogOut && handleLogOut !== prevHandleLogOutRef.current) {
+                prevHandleLogOutRef.current = handleLogOut;
+                setDynamicHandleLogOut(function () { return handleLogOut; });
             }
-        }, [sdkHasLoaded]);
-        // Set the logout handler
+        }, [handleLogOut, setDynamicHandleLogOut]);
+        // Set the SDK loaded flag when it changes - only when it actually changes
         useEffect(function () {
-            if (handleLogOut) {
-                setDynamicHandleLogOut(function () { return handleLogOut; });
+            if (sdkHasLoaded !== prevSdkHasLoadedRef.current) {
+                prevSdkHasLoadedRef.current = sdkHasLoaded;
+                setDynamicSdkHasLoaded(sdkHasLoaded);
             }
-        }, [handleLogOut]);
+        }, [sdkHasLoaded, setDynamicSdkHasLoaded]);
         return _jsx(_Fragment, { children: children });
     };
     return _jsx(DynamicComponent, {});
 }
+var getSettings = function (darkMode) { return ({
+    initialAuthenticationMode: 'connect-only',
+    environmentId: '9a47561c-6a0b-4a5b-ace1-12621c11cebd',
+    silentAuthentication: true,
+    silentAuth: true,
+    theme: {
+        mode: darkMode ? 'dark' : 'light',
+    },
+    events: {
+        onAuthSuccess: function (args) {
+            console.log('onAuthSuccess was called', args);
+        },
+    },
+}); };
 function LazyInternal(props) {
     var _this = this;
     var _a = useState(null), Provider = _a[0], setProvider = _a[1];
     var _b = useState([]), walletConnectors = _b[0], setWalletConnectors = _b[1];
-    var darkMode = useN1WalletInternalContext().darkMode;
+    var _c = useN1WalletInternalContext(), darkMode = _c.darkMode, sessionMode = _c.sessionMode;
+    // Use a ref to track the previous session mode
+    var prevSessionModeRef = useRef(null);
     useEffect(function () {
+        // Skip if the session mode hasn't changed
+        if (sessionMode === prevSessionModeRef.current) {
+            return;
+        }
+        prevSessionModeRef.current = sessionMode;
         var loadDynamicDeps = function () { return __awaiter(_this, void 0, void 0, function () {
             var _a, DynamicContextProvider_1, EthereumWalletConnectors, SolanaWalletConnectors, error_1;
             return __generator(this, function (_b) {
@@ -140,7 +165,14 @@ function LazyInternal(props) {
                     case 1:
                         _a = _b.sent(), DynamicContextProvider_1 = _a[0].DynamicContextProvider, EthereumWalletConnectors = _a[1].EthereumWalletConnectors, SolanaWalletConnectors = _a[2].SolanaWalletConnectors;
                         setProvider(function () { return DynamicContextProvider_1; });
-                        setWalletConnectors([EthereumWalletConnectors, SolanaWalletConnectors]);
+                        if (sessionMode === N1SessionMode.Nord) {
+                            // Only use Solana wallet connectors for Nord mode
+                            setWalletConnectors([SolanaWalletConnectors]);
+                        }
+                        else {
+                            // Use all wallet connectors for NTS mode
+                            setWalletConnectors([EthereumWalletConnectors, SolanaWalletConnectors]);
+                        }
                         return [3 /*break*/, 3];
                     case 2:
                         error_1 = _b.sent();
@@ -151,12 +183,13 @@ function LazyInternal(props) {
             });
         }); };
         loadDynamicDeps();
-    }, []);
+    }, [sessionMode]);
+    // Memoize the dynamic settings to prevent unnecessary re-renders
+    var dynamicSettings = useCallback(function () { return (__assign(__assign({}, getSettings(darkMode)), { walletConnectors: walletConnectors })); }, [darkMode, walletConnectors]);
     if (!Provider || walletConnectors.length === 0) {
         return null;
     }
-    var dynamicSettings = __assign(__assign({}, getSettings(darkMode)), { walletConnectors: walletConnectors });
-    return (_jsx(Provider, { settings: dynamicSettings, theme: darkMode ? 'dark' : 'light', children: _jsx(DynamicContextConsumer, { children: props.children }) }));
+    return (_jsx(Provider, { settings: dynamicSettings(), theme: darkMode ? 'dark' : 'light', children: _jsx(DynamicContextConsumer, { children: props.children }) }));
 }
 export function LazyWalletProvider(_a) {
     var children = _a.children;

package/dist/Provider/N1WalletProvider.d.ts

@@ -1,2 +1,2 @@
 import { N1WalletProviderProps } from './types';
-export declare function N1WalletProvider({ children, providedSessionMode, appId, darkMode, onError, }: N1WalletProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function N1WalletProvider({ children, providedSessionMode, appId, darkMode, onError, faucetUrl, nord, }: N1WalletProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/Provider/N1WalletProvider.js

@@ -56,6 +56,9 @@ import { N1WalletModal } from '../Modal/N1WalletModal';
 import { WalletError, WalletErrorCode } from '../errors/types';
 import { N1InternalWalletContext, N1WalletContext } from './context';
 import { N1ModalViewMode, N1SessionMode, } from './types';
+import { useNordWalletConnect } from '../Modal/NordFlow/hooks/useNordWalletConnect';
+import { useNordInstance } from '../Modal/NordFlow/hooks/useNordInstance';
+import { FlowState } from '../Modal/NordFlow/types';
 var LazyWalletProvider = React.lazy(function () {
     return import('./LazyWalletProvider').then(function (mod) { return ({
         default: mod.LazyWalletProvider,
@@ -83,7 +86,7 @@ var WalletErrorBoundary = /** @class */ (function (_super) {
 }(React.Component));
 export function N1WalletProvider(_a) {
     var _this = this;
-    var children = _a.children, providedSessionMode = _a.providedSessionMode, appId = _a.appId, _b = _a.darkMode, darkMode = _b === void 0 ? true : _b, onError = _a.onError;
+    var children = _a.children, providedSessionMode = _a.providedSessionMode, appId = _a.appId, _b = _a.darkMode, darkMode = _b === void 0 ? true : _b, onError = _a.onError, faucetUrl = _a.faucetUrl, nord = _a.nord;
     var _c = useState(false), isConnected = _c[0], setIsConnected = _c[1];
     var _d = useState(null), ntsInterface = _d[0], setNtsInterface = _d[1];
     var _e = useState(false), showLogin = _e[0], setShowLogin = _e[1];
@@ -93,28 +96,35 @@ export function N1WalletProvider(_a) {
     var _j = useState(''), username = _j[0], setUsername = _j[1];
     var _k = useState(null), signMessageWithSessionKey = _k[0], setSignMessageWithSessionKey = _k[1];
     var _l = useState(null), signMessageWithWalletKey = _l[0], setSignMessageWithWalletKey = _l[1];
-    var _m = useState(false), showSidebar = _m[0], setShowSidebar = _m[1];
-    var _o = useState(false), startClosingLogin = _o[0], setStartClosingLogin = _o[1];
-    var _p = useState(false), loading = _p[0], setLoading = _p[1];
-    var _q = useState(N1ModalViewMode.Connect), viewMode = _q[0], setViewMode = _q[1];
-    // Log initialization only once on mount
-    useEffect(function () {
-        // eslint-disable-next-line no-console
-        console.log('N1WalletProvider initializing');
-    }, []);
+    var _m = useState(null), signTransactionWithWalletKey = _m[0], setSignTransactionWithWalletKey = _m[1];
+    var _o = useState(false), showSidebar = _o[0], setShowSidebar = _o[1];
+    var _p = useState(false), startClosingLogin = _p[0], setStartClosingLogin = _p[1];
+    var _q = useState(false), loading = _q[0], setLoading = _q[1];
+    var _r = useState(N1ModalViewMode.Connect), viewMode = _r[0], setViewMode = _r[1];
+    var _s = useState(null), nordUser = _s[0], setNordUser = _s[1];
     // dynamic
-    var _r = useState(''), address = _r[0], setAddress = _r[1];
-    var _s = useState([]), balances = _s[0], setBalances = _s[1];
-    var _t = useState(''), chain = _t[0], setChain = _t[1];
-    var _u = useState(null), dynamicSdkHasLoaded = _u[0], setDynamicSdkHasLoaded = _u[1];
-    var _v = useState(null), dynamicHandleLogOut = _v[0], setDynamicHandleLogOut = _v[1];
-    var _w = useState(null), sessionMode = _w[0], setSessionMode = _w[1];
-    var _x = useState(null), dynamicWallet = _x[0], setDynamicWallet = _x[1];
-    var _y = useState(null), showDynamicWidget = _y[0], setShowDynamicWidget = _y[1];
+    var _t = useState(''), address = _t[0], setAddress = _t[1];
+    var _u = useState([]), balances = _u[0], setBalances = _u[1];
+    var _v = useState(''), chain = _v[0], setChain = _v[1];
+    var _w = useState(null), dynamicSdkHasLoaded = _w[0], setDynamicSdkHasLoaded = _w[1];
+    var _x = useState(null), dynamicHandleLogOut = _x[0], setDynamicHandleLogOut = _x[1];
+    var _y = useState(null), sessionMode = _y[0], setSessionMode = _y[1];
+    var _z = useState(null), dynamicWallet = _z[0], setDynamicWallet = _z[1];
+    var _0 = useState(null), showDynamicWidget = _0[0], setShowDynamicWidget = _0[1];
+    // Create a separate component for Nord hooks to avoid conditional hook calls
+    var NordHooks = function () {
+        useNordInstance();
+        useNordWalletConnect(FlowState.IDLE, function (newState) { return console.log('State transition:', newState); }, {}, // context
+        function (updates) { return console.log('Context updates:', updates); }, providedSessionMode);
+        return null;
+    };
     // Combine SDK loading and initialization into a single effect
     useEffect(function () {
         var mounted = true;
-        var loadNTSSDK = function () { return __awaiter(_this, void 0, void 0, function () {
+        // Set the session mode from props
+        setSessionMode(providedSessionMode);
+        // Load the appropriate SDK
+        var loadSDK = function () { return __awaiter(_this, void 0, void 0, function () {
             var NTSInterface, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -122,8 +132,6 @@ export function N1WalletProvider(_a) {
                         // eslint-disable-next-line no-console
                         console.log('Loading NTS SDK');
                         if (providedSessionMode === N1SessionMode.Nord) {
-                            // eslint-disable-next-line no-console
-                            console.log('Nord mode, skipping NTS SDK load');
                             return [2 /*return*/];
                         }
                         _a.label = 1;
@@ -149,11 +157,11 @@ export function N1WalletProvider(_a) {
                 }
             });
         }); };
-        loadNTSSDK();
+        loadSDK();
         return function () {
             mounted = false;
         };
-    }, [providedSessionMode]);
+    }, [providedSessionMode, onError]);
     // Separate effect to handle loading state based on both SDKs
     useEffect(function () {
         var isDynamicReady = dynamicSdkHasLoaded || providedSessionMode === N1SessionMode.Nord;
@@ -170,25 +178,31 @@ export function N1WalletProvider(_a) {
             return [2 /*return*/];
         });
     }); };
-    return (_jsx(WalletErrorBoundary, { onError: handleError, children: _jsx(N1WalletContext.Provider, { value: {
-                address: address,
-                balances: balances,
-                appId: appId,
-                chain: chain,
-                isConnected: isConnected,
-                ntsInterface: ntsInterface,
-                sessionMode: sessionMode,
-                sessionPubKey: sessionPubKey,
-                setShowLogin: setShowLogin,
-                showLogin: showLogin,
-                signMessageWithSessionKey: signMessageWithSessionKey,
-                signMessageWithWalletKey: signMessageWithWalletKey,
-                userChain: userChain,
-                username: username,
-                viewMode: viewMode,
-                walletPubKey: walletPubKey,
-                throwTestError: throwTestError,
-            }, children: _jsxs(N1InternalWalletContext.Provider, { value: {
+    // Create the wallet context value
+    var walletContextValue = {
+        address: address,
+        appId: appId,
+        balances: balances,
+        chain: chain,
+        isConnected: isConnected,
+        ntsInterface: ntsInterface,
+        sessionMode: sessionMode,
+        sessionPubKey: sessionPubKey,
+        setShowLogin: setShowLogin,
+        showLogin: showLogin,
+        signMessageWithSessionKey: signMessageWithSessionKey,
+        signMessageWithWalletKey: signMessageWithWalletKey,
+        signTransactionWithWalletKey: signTransactionWithWalletKey,
+        userChain: userChain,
+        username: username,
+        viewMode: viewMode,
+        walletPubKey: walletPubKey,
+        throwTestError: throwTestError,
+        faucetUrl: faucetUrl,
+        nord: nord,
+        nordUser: nordUser,
+    };
+    return (_jsx(WalletErrorBoundary, { onError: handleError, children: _jsx(N1WalletContext.Provider, { value: walletContextValue, children: _jsxs(N1InternalWalletContext.Provider, { value: {
                     dynamicHandleLogOut: dynamicHandleLogOut,
                     dynamicWallet: dynamicWallet,
                     loading: loading,
@@ -208,6 +222,7 @@ export function N1WalletProvider(_a) {
                     setShowSidebar: setShowSidebar,
                     setSignMessageWithSessionKey: setSignMessageWithSessionKey,
                     setSignMessageWithWalletKey: setSignMessageWithWalletKey,
+                    setSignTransactionWithWalletKey: setSignTransactionWithWalletKey,
                     setStartClosingLogin: setStartClosingLogin,
                     setUsername: setUsername,
                     setUserChain: setUserChain,
@@ -218,5 +233,8 @@ export function N1WalletProvider(_a) {
                     showDynamicWidget: showDynamicWidget,
                     setShowDynamicWidget: setShowDynamicWidget,
                     darkMode: darkMode,
-                }, children: [children, _jsx(N1WalletModal, {}), _jsx(Suspense, { fallback: null, children: _jsx(LazyWalletProvider, {}) })] }) }) }));
+                    sessionMode: sessionMode,
+                    faucetUrl: faucetUrl,
+                    setNordUser: setNordUser,
+                }, children: [children, providedSessionMode === N1SessionMode.Nord && _jsx(NordHooks, {}), _jsx(N1WalletModal, {}), _jsx(Suspense, { fallback: null, children: _jsx(LazyWalletProvider, {}) })] }) }) }));
 }