@digitaldefiance/express-suite-react-components 2.9.7 → 2.9.11

package/src/contexts/AuthProvider.tsx

@@ -1,741 +0,0 @@
-import { Member as FrontendMember,
-    ECIESService,
-  EmailString,
-  IECIESConfig,
-  SecureString,
-  PasswordLoginService,
-  Constants as AppConstants,
-  Pbkdf2Service,
-} from '@digitaldefiance/ecies-lib';
-import {
-  CoreLanguageCode,
-  CurrencyCode,
-  Timezone,
-} from '@digitaldefiance/i18n-lib';
-import { Wallet } from '@ethereumjs/wallet';
-import {
-  createContext,
-  ReactNode,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useState,
-} from 'react';
-import { useI18n } from './I18nProvider';
-import { useTheme } from './ThemeProvider';
-import { createAuthService } from '../services/authService';
-import { createAuthenticatedApiClient } from '../services/authenticatedApi';
-import { useExpiringValue } from '../hooks/useExpiringValue';
-import { useLocalStorage } from '../hooks/useLocalStorage';
-import { useUserSettings } from '../hooks/useUserSettings';
-import { ISuccessMessage, IRequestUserDTO, SuiteCoreComponentId, SuiteCoreStringKey, IConstants, IUserSettings } from '@digitaldefiance/suite-core-lib';
-import { PaletteMode } from '@mui/material';
-
-export interface AuthContextData {
-  /**
-   * True if the user has a global admin role
-   */
-  admin: boolean;
-  /**
-   * Counter that increments on login/logout to trigger effects in dependent components
-   */
-  authState: number;
-  /**
-   * Performs a server side backup-code login
-   * @param identifier 
-   * @param code 
-   * @param isEmail 
-   * @param recoverMnemonic 
-   * @param newPassword 
-   * @returns 
-   */
-  backupCodeLogin: (
-    identifier: string,
-    code: string,
-    isEmail: boolean,
-    recoverMnemonic: boolean,
-    newPassword?: string,
-  ) => Promise<
-    | { token: string; codeCount: number; mnemonic?: string; message?: string }
-    | { error: string; status?: number }
-  >;
-  /**
-   * Verifies the stored token (if any) and updates auth state
-   * @returns void
-   */
-  checkAuth: () => void;
-  /**
-   * Changes the stored browser password login mnemonic
-   * @param currentPassword 
-   * @param newPassword 
-   * @returns 
-   */
-  changePassword: (
-    currentPassword: string,
-    newPassword: string,
-  ) => Promise<
-    | ISuccessMessage
-    | {
-        error: string;
-        errorType?: string | undefined;
-      }
-  >;
-  clearMnemonic: () => void;
-  clearWallet: () => void;
-  colorMode?: PaletteMode;
-  currencyCode?: CurrencyCode;
-  directLogin: (
-    mnemonic: SecureString,
-    username?: string,
-    email?: EmailString,
-    expireMnemonicSeconds?: number,
-    expireWalletSeconds?: number,
-  ) => Promise<
-    | { token: string; user: IRequestUserDTO; wallet: Wallet }
-    | { error: string; errorType?: string }
-  >;
-  emailChallengeLogin: (
-    mnemonic: SecureString,
-    token: string,
-    username?: string,
-    email?: EmailString,
-    expireMnemonicSeconds?: number,
-    expireWalletSeconds?: number,
-  ) => Promise<
-    | { token: string; user: IRequestUserDTO; wallet: Wallet; message: string }
-    | { error: string; errorType?: string }
-  >;
-  isAuthenticated: boolean;
-  // True only while the app is determining initial auth state (e.g., on first load or refresh)
-  isCheckingAuth: boolean;
-  isBrowserPasswordLoginAvailable?: () => boolean;
-  loading: boolean;
-  logout: () => void;
-  mnemonic?: SecureString;
-  mnemonicExpirationSeconds: number;
-  passwordLogin: (password: SecureString, username?: string, email?: EmailString) => Promise<{ token: string; user: IRequestUserDTO; wallet: Wallet } | { error: string; errorType?: string }>;
-  requestEmailLogin: (
-    username?: string,
-    email?: EmailString,
-  ) => Promise<string | { error: string; errorType?: string }>;
-  refreshToken: () => Promise<{ token: string; user: IRequestUserDTO }>;
-  register: (
-    username: string,
-    email: string,
-    timezone: string,
-    password?: string,
-  ) => Promise<
-    | {
-        success: boolean;
-        message: string;
-        mnemonic: string;
-      }
-    | {
-        error: string;
-        errorType?: string;
-        field?: string;
-        errors?: Array<{ path: string; msg: string }>;
-      }
-  >;
-  serverPublicKey: string | null;
-  /**
-   * Gets the remaining time in seconds for the mnemonic expiration
-   * @returns Number of seconds remaining, or 0 if no mnemonic is set
-   */
-  getMnemonicRemainingTime: () => number;
-  /**
-   * Gets the remaining time in seconds for the wallet expiration
-   * @returns Number of seconds remaining, or 0 if no wallet is set
-   */
-  getWalletRemainingTime: () => number;
-  setMnemonic: (mnemonic: SecureString, durationSeconds?: number) => void;
-  setMnemonicExpirationSeconds: (seconds: number) => void;
-  setWalletExpirationSeconds: (seconds: number) => void;
-  setUpBrowserPasswordLogin: (mnemonic: SecureString, password: SecureString, username?: string, email?: EmailString) => Promise<{ success: boolean; message: string } | { error: string; errorType?: string }>;
-  setUser: (user: IRequestUserDTO | null) => Promise<void>;
-  setUserSetting: (setting?: Partial<IUserSettings>) => Promise<void>;
-  setWallet: (wallet: Wallet, durationSeconds?: number) => void;
-  user: FrontendMember | null;
-  userData: IRequestUserDTO | null;
-  userSettings: IUserSettings | undefined;
-  token: string | null;
-  wallet?: Wallet;
-  walletExpirationSeconds: number;
-  verifyToken: (token: string) => Promise<boolean>;
-}
-
-export type AuthProviderProps = {
-  children: ReactNode;
-  baseUrl: string;
-  constants: IConstants;
-  eciesConfig: IECIESConfig;
-  /**
-   * Optional callback to handle navigation after logout
-   * If not provided, logout will only clear auth state without navigation
-   */
-  onLogout?: () => void;
-};
-
-export const AuthContext = createContext<AuthContextData>(
-  {} as AuthContextData,
-);
-
-const AuthProviderInner = ({ children, baseUrl, constants, eciesConfig, onLogout }: AuthProviderProps) => {
-  const { t, tComponent } = useI18n();
-  const { setColorMode: themeSetPaletteMode, mode: colorMode } = useTheme();
-  
-  const authService = useMemo(() => createAuthService(constants, baseUrl, eciesConfig), [constants, baseUrl, eciesConfig]);
-  const authenticatedApi = useMemo(() => createAuthenticatedApiClient(baseUrl), [baseUrl]);
-  
-  // Use the custom hooks for expiring values
-  const mnemonicManager = useExpiringValue<SecureString>(
-    constants.DefaultExpireMemoryMnemonicSeconds, 
-    'mnemonicExpirationSeconds'
-  );
-  const walletManager = useExpiringValue<Wallet>(
-    constants.DefaultExpireMemoryWalletSeconds, 
-    'walletExpirationSeconds'
-  );
-  
-  // Use localStorage hook for expiration settings
-  const [mnemonicExpirationSeconds, _setMnemonicExpirationSeconds] = useLocalStorage(
-    'mnemonicExpirationSeconds', 
-    constants.DefaultExpireMemoryMnemonicSeconds
-  );
-  const [walletExpirationSeconds, _setWalletExpirationSeconds] = useLocalStorage(
-    'walletExpirationSeconds', 
-    constants.DefaultExpireMemoryWalletSeconds
-  );
-  const [serverPublicKey, setServerPublicKey] = useState<string | null>(null);
-  const [user, setUser] = useState<IRequestUserDTO | null>(null);
-  const [frontendUser, setFrontendUser] =
-    useState<FrontendMember | null>(null);
-  const [isAuthenticated, setIsAuthenticated] = useState(false);
-  const [isGlobalAdmin, setIsGlobalAdmin] = useState(false);
-  const [loading, setLoading] = useState(true);
-  // Separate flag so route guards don't unmount during actions (e.g., register/login)
-  const [isCheckingAuth, setIsCheckingAuth] = useState(true);
-  const [token, setToken] = useState<string | null>(null);
-  const [authState, setAuthState] = useState(0);
-
-  // Use the user settings hook for settings management
-  const { userSettings, setUserSettingAndUpdateSettings } = useUserSettings({
-    authenticatedApi,
-    isAuthenticated,
-  });
-
-  // Helper functions to calculate remaining time (now provided by the hooks)
-  const getMnemonicRemainingTime = mnemonicManager.getRemainingTime;
-  const getWalletRemainingTime = walletManager.getRemainingTime;
-
-  // Wrapper functions to match the interface (the localStorage hook handles storage automatically)
-  const setMnemonicExpirationSeconds = _setMnemonicExpirationSeconds;
-  const setWalletExpirationSeconds = _setWalletExpirationSeconds;
-
-  // Sync user language with i18n provider when the user's saved language changes.
-  // Important: do NOT depend on currentLanguage here, or we'll run when the UI
-  // language changes and inadvertently revert to the older user.siteLanguage,
-  // causing a second update request with English US.
-  useEffect(() => {
-    if (user?.siteLanguage) {
-      (async () => {
-        await setUserSettingAndUpdateSettings({ siteLanguage: user.siteLanguage });
-      })();
-    }
-    // We intentionally only react to changes in the user's saved language.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [user?.siteLanguage]);
-
-  const setMnemonic = useCallback((mnemonic: SecureString, durationSeconds?: number) => {
-    const finalDurationSeconds = durationSeconds ?? mnemonicExpirationSeconds;
-    
-    // Store the duration to localStorage if provided
-    if (durationSeconds !== undefined) {
-      _setMnemonicExpirationSeconds(durationSeconds);
-    }
-    
-    // Only save to storage if a custom duration was provided
-    return mnemonicManager.setValue(mnemonic, finalDurationSeconds, durationSeconds !== undefined);
-  }, [mnemonicExpirationSeconds, mnemonicManager.setValue, _setMnemonicExpirationSeconds]);
-
-  const setWallet = useCallback((wallet: Wallet, durationSeconds?: number) => {
-    const finalDurationSeconds = durationSeconds ?? walletExpirationSeconds;
-    
-    // Store the duration to localStorage if provided
-    if (durationSeconds !== undefined) {
-      _setWalletExpirationSeconds(durationSeconds);
-    }
-    
-    // Only save to storage if a custom duration was provided
-    return walletManager.setValue(wallet, finalDurationSeconds, durationSeconds !== undefined);
-  }, [walletExpirationSeconds, walletManager.setValue, _setWalletExpirationSeconds]);
-
-  const clearMnemonic = mnemonicManager.clearValue;
-  const clearWallet = walletManager.clearValue;
-
-  const checkAuth = useCallback(async () => {
-    const token = localStorage.getItem('authToken');
-    if (!token) {
-      setUser(null);
-      setIsAuthenticated(false);
-      setLoading(false);
-      setIsCheckingAuth(false);
-      setToken(null);
-      setFrontendUser(null);
-      setServerPublicKey(null);
-      await setUserSettingAndUpdateSettings(undefined);
-      themeSetPaletteMode('light');
-      clearMnemonic();
-      clearWallet();
-      return;
-    }
-
-    try {
-      const userData = await authService.verifyToken(token);
-      if ('error' in userData && typeof userData.error === 'string') {
-        setIsAuthenticated(false);
-        setToken(null);
-      } else if ('id' in userData && 'email' in userData) {
-        const userDataDTO: IRequestUserDTO = userData as IRequestUserDTO;
-        setUser(userDataDTO);
-        setIsGlobalAdmin(
-          (userDataDTO).roles.some((r) => r.admin),
-        );
-        setIsAuthenticated(true);
-        setToken(token);
-        await setUserSettingAndUpdateSettings({
-          darkMode: userDataDTO.darkMode,
-          currency: new CurrencyCode(userDataDTO.currency),
-          timezone: new Timezone(userDataDTO.timezone),
-          siteLanguage: userDataDTO.siteLanguage as CoreLanguageCode,
-          email: new EmailString(userDataDTO.email),
-          directChallenge: userDataDTO.directChallenge,
-        })
-      }
-    } catch (error) {
-      console.error('Token verification failed:', error);
-      setUser(null);
-      setIsAuthenticated(false);
-      await setUserSettingAndUpdateSettings(undefined);
-      localStorage.removeItem('authToken');
-    } finally {
-      setLoading(false);
-      setIsCheckingAuth(false);
-    }
-  }, [authService, clearMnemonic, clearWallet, setUserSettingAndUpdateSettings, themeSetPaletteMode]);
-
-  useEffect(() => {
-    const token = localStorage.getItem('authToken');
-    if (token) {
-      (async () => {
-        await checkAuth();
-      })();
-    } else {
-      setLoading(false);
-      setIsCheckingAuth(false);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [authState]); // Only run when authState changes (login/logout), not when checkAuth is recreated
-
-  const directLogin: AuthContextData['directLogin'] = useCallback(
-    async (mnemonic, username, email, expireMnemonicSeconds, expireWalletSeconds) => {
-      setLoading(true);
-      const loginResult = await authService.directLogin(
-        mnemonic,
-        username,
-        email,
-      );
-      setLoading(false);
-      if (
-        typeof loginResult === 'object' &&
-        'token' in loginResult &&
-        'user' in loginResult &&
-        'wallet' in loginResult
-      ) {
-        setMnemonic(mnemonic, expireMnemonicSeconds);
-        setUser(loginResult.user);
-        setWallet(loginResult.wallet, expireWalletSeconds);
-        setIsAuthenticated(true);
-        setAuthState((prev) => prev + 1);
-        localStorage.setItem('authToken', loginResult.token);
-        localStorage.setItem('user', JSON.stringify(loginResult.user));
-        await setUserSettingAndUpdateSettings({
-          darkMode: loginResult.user.darkMode,
-          currency: new CurrencyCode(loginResult.user.currency),
-          timezone: new Timezone(loginResult.user.timezone),
-          siteLanguage: loginResult.user.siteLanguage as CoreLanguageCode,
-          email: new EmailString(loginResult.user.email),
-          directChallenge: loginResult.user.directChallenge,
-        });
-        return loginResult;
-      }
-      return loginResult;
-    },
-    [authService, setMnemonic, setWallet, setUserSettingAndUpdateSettings],
-  );
-
-  const emailChallengeLogin: AuthContextData['emailChallengeLogin'] =
-    useCallback(async (mnemonic, token, username, email, expireMnemonicSeconds, expireWalletSeconds) => {
-      setLoading(true);
-      const loginResult = await authService.emailChallengeLogin(
-        mnemonic,
-        token,
-        username,
-        email,
-      );
-      setLoading(false);
-      if (
-        typeof loginResult === 'object' &&
-        'token' in loginResult &&
-        'user' in loginResult &&
-        'wallet' in loginResult
-      ) {
-        setMnemonic(mnemonic, expireMnemonicSeconds);
-        setUser(loginResult.user);
-        setWallet(loginResult.wallet, expireWalletSeconds);
-        setIsAuthenticated(true);
-        setAuthState((prev) => prev + 1);
-        localStorage.setItem('authToken', loginResult.token);
-        localStorage.setItem('user', JSON.stringify(loginResult.user));
-        await setUserSettingAndUpdateSettings({
-          darkMode: loginResult.user.darkMode,
-          currency: new CurrencyCode(loginResult.user.currency),
-          timezone: new Timezone(loginResult.user.timezone),
-          siteLanguage: loginResult.user.siteLanguage as CoreLanguageCode,
-          email: new EmailString(loginResult.user.email),
-          directChallenge: loginResult.user.directChallenge,
-        });
-        return loginResult;
-      }
-      return loginResult;
-    }, [authService, setMnemonic, setWallet, setUserSettingAndUpdateSettings]);
-  const getPasswordLoginService = useCallback(() => {
-    const eciesService: ECIESService = new ECIESService(eciesConfig);
-    return new PasswordLoginService(eciesService, new Pbkdf2Service(AppConstants.PBKDF2_PROFILES, AppConstants.ECIES, AppConstants.PBKDF2));
-  }, [eciesConfig]);
-
-  const isBrowserPasswordLoginAvailable = useCallback(() => {
-    const storedEncryptedPassword = localStorage.getItem('encryptedPassword');
-    return !!storedEncryptedPassword;
-  }, []);
-
-  const passwordLogin: AuthContextData['passwordLogin'] = useCallback(
-    async (password: SecureString, username?: string, email?: EmailString) => {
-      if (!isBrowserPasswordLoginAvailable()) {
-        return { error: tComponent<SuiteCoreStringKey>(SuiteCoreComponentId, SuiteCoreStringKey.Error_Login_PasswordLoginNotSetup), errorType: 'PasswordLoginNotSetup' };
-      }
-      setLoading(true);
-      const passwordLoginService: PasswordLoginService = getPasswordLoginService();
-      const { wallet, mnemonic } = await passwordLoginService.getWalletAndMnemonicFromLocalStorageBundle(password);
-      const loginResult = await authService.directLogin(
-        mnemonic,
-        username,
-        email,
-      );
-      setLoading(false);
-      setWallet(wallet);
-      setMnemonic(mnemonic);
-      // Set theme based on user's darkMode preference if login succeeded
-      if ('user' in loginResult) {
-        await setUserSettingAndUpdateSettings({
-          darkMode: loginResult.user.darkMode,
-          currency: new CurrencyCode(loginResult.user.currency),
-          timezone: new Timezone(loginResult.user.timezone),
-          siteLanguage: loginResult.user.siteLanguage as CoreLanguageCode,
-          email: new EmailString(loginResult.user.email),
-          directChallenge: loginResult.user.directChallenge,
-        });
-      }
-      return loginResult;
-    },
-    [authService, getPasswordLoginService, setMnemonic, setWallet, t, tComponent, isBrowserPasswordLoginAvailable, setUserSettingAndUpdateSettings]
-  );
-
-  const refreshToken: AuthContextData['refreshToken'] =
-    useCallback(async () => {
-      try {
-        const result = await authService.refreshToken();
-        localStorage.setItem('authToken', result.token);
-        localStorage.setItem('user', JSON.stringify(result.user));
-        setUser(result.user);
-        setIsAuthenticated(true);
-        return result;
-      } catch (error) {
-        setUser(null);
-        setIsAuthenticated(false);
-        localStorage.removeItem('authToken');
-        localStorage.removeItem('user');
-        throw error;
-      }
-    }, [authService]);
-
-  const register: AuthContextData['register'] = useCallback(
-    async (
-      username: string,
-      email: string,
-      timezone: string,
-      password?: string,
-    ) => {
-      const registerResult = await authService.register(
-        username,
-        email,
-        timezone,
-        password,
-      );
-      return registerResult as Awaited<ReturnType<AuthContextData['register']>>;
-    },
-    [baseUrl],
-  );
-
-  const requestEmailLogin = useCallback(
-    async (
-      username?: string,
-      email?: EmailString,
-    ): Promise<string | { error: string; errorType?: string }> => {
-      setLoading(true);
-      const result = await authService.requestEmailLogin(username, email);
-      setLoading(false);
-      return result;
-    },
-    [baseUrl],
-  );
-
-  const setUpBrowserPasswordLogin = useCallback(
-    async (mnemonic: SecureString, password: SecureString, username?: string, email?: EmailString): Promise<{ success: boolean; message: string } | { error: string; errorType?: string }> => {
-      setLoading(true);
-      const passwordLoginService: PasswordLoginService = getPasswordLoginService();
-      try {
-        const wallet = await passwordLoginService.setupPasswordLoginLocalStorageBundle(mnemonic, password);
-        setLoading(false);
-        setWallet(wallet);
-        setMnemonic(mnemonic);
-        return { success: true, message: tComponent<SuiteCoreStringKey>(SuiteCoreComponentId,SuiteCoreStringKey.PasswordLogin_Setup_Success) };
-      } catch {
-        setLoading(false);
-        return { success: false, message: tComponent<SuiteCoreStringKey>(SuiteCoreComponentId, SuiteCoreStringKey.PasswordLogin_Setup_Failure) };
-      }
-    },
-    [setMnemonic, setWallet, t, tComponent],
-  );
-
-  const backupCodeLogin = useCallback(
-    async (
-      identifier: string,
-      code: string,
-      isEmail: boolean,
-      recoverMnemonic: boolean,
-      newPassword?: string,
-    ): Promise<
-      | {
-          token: string;
-          codeCount: number;
-          mnemonic?: string;
-          message?: string;
-        }
-      | { error: string; status?: number }
-    > => {
-      setLoading(true);
-      const loginResult = await authService.backupCodeLogin(
-        identifier,
-        code,
-        isEmail,
-        recoverMnemonic,
-        newPassword,
-      );
-      setLoading(false);
-      if (typeof loginResult === 'object' && 'token' in loginResult) {
-        localStorage.setItem('authToken', loginResult.token);
-        if (loginResult.user) {
-          setUser(loginResult.user);
-          setIsAuthenticated(true);
-          await setUserSettingAndUpdateSettings({
-            darkMode: loginResult.user.darkMode,
-            currency: new CurrencyCode(loginResult.user.currency),
-            timezone: new Timezone(loginResult.user.timezone),
-            siteLanguage: loginResult.user.siteLanguage as CoreLanguageCode,
-            email: new EmailString(loginResult.user.email),
-            directChallenge: loginResult.user.directChallenge,
-          });
-        }
-        setAuthState((prev) => prev + 1);
-        return {
-          token: loginResult.token,
-          mnemonic: loginResult.mnemonic,
-          message: loginResult.message,
-          codeCount: loginResult.codeCount,
-        };
-      }
-      return loginResult;
-    },
-    [authService, setUserSettingAndUpdateSettings],
-  );
-
-  const logout = useCallback(async () => {
-    localStorage.removeItem('user');
-    localStorage.removeItem('authToken');
-    clearMnemonic();
-    setUser(null);
-    clearWallet();
-    setIsAuthenticated(false);
-    await setUserSettingAndUpdateSettings(undefined);
-    setAuthState((prev) => prev + 1);
-    
-    // Call the optional navigation callback if provided
-    if (onLogout) {
-      onLogout();
-    }
-  }, [onLogout, clearMnemonic, clearWallet, setUserSettingAndUpdateSettings]);
-
-  const verifyToken = useCallback(async (token: string) => {
-    const requestUser = await authService.verifyToken(token);
-    if (typeof requestUser === 'object' && 'error' in requestUser) {
-      setIsAuthenticated(false);
-      await setUserSettingAndUpdateSettings(undefined);
-      return false;
-    } else {
-      setUser(requestUser);
-      setIsAuthenticated(true);
-      return true;
-    }
-  }, [authService, setUserSettingAndUpdateSettings]);
-
-  const changePassword = useCallback(
-    async (
-      currentPassword: string,
-      newPassword: string,
-    ): Promise<
-      | ISuccessMessage
-      | {
-          error: string;
-          errorType?: string | undefined;
-        }
-    > => {
-      if (!isBrowserPasswordLoginAvailable()) {
-        return { error: tComponent<SuiteCoreStringKey>(SuiteCoreComponentId, SuiteCoreStringKey.Error_Login_PasswordLoginNotSetup), errorType: 'PasswordLoginNotSetup' };
-      }
-      setLoading(true);
-      try {
-        const passwordLoginService: PasswordLoginService = getPasswordLoginService();
-        const { mnemonic, wallet } = await passwordLoginService.getWalletAndMnemonicFromLocalStorageBundle(new SecureString(currentPassword));
-        if (!mnemonic) {
-          setLoading(false);
-          return { error: tComponent<SuiteCoreStringKey>(SuiteCoreComponentId, SuiteCoreStringKey.PasswordLogin_InvalidCurrentPassword), errorType: 'InvalidCurrentPassword' };
-        }
-        await passwordLoginService.setupPasswordLoginLocalStorageBundle(mnemonic, new SecureString(newPassword));
-        setLoading(false);
-        setWallet(wallet);
-        setMnemonic(mnemonic);
-        return { success: true, message: tComponent<SuiteCoreStringKey>(SuiteCoreComponentId, SuiteCoreStringKey.PasswordChange_Success) };
-      } catch (error) {
-        setLoading(false);
-        return { error: 'Password change failed' };
-      }
-    },
-    [setMnemonic, setWallet, t, tComponent, isBrowserPasswordLoginAvailable],
-  );
-
-  const contextValue = useMemo(() => {
-    const setUserAndIsAuthenticated = async (newUser: IRequestUserDTO | null) => {
-      setUser(newUser);
-      setIsAuthenticated(!!newUser);
-    };
-
-    return {
-      admin: isGlobalAdmin,
-      authState,
-      backupCodeLogin,
-      changePassword,
-      checkAuth,
-      clearMnemonic,
-      clearWallet,
-      colorMode,
-      currencyCode: userSettings?.currency,
-      directLogin,
-      emailChallengeLogin,
-      getMnemonicRemainingTime,
-      getWalletRemainingTime,
-      isAuthenticated,
-      isCheckingAuth,
-      isBrowserPasswordLoginAvailable,
-      loading,
-      logout,
-      mnemonic: mnemonicManager.value,
-      mnemonicExpirationSeconds,
-      passwordLogin,
-      refreshToken,
-      register,
-      requestEmailLogin,
-      serverPublicKey,
-      setMnemonic,
-      setMnemonicExpirationSeconds,
-      setUpBrowserPasswordLogin,
-      setUser: setUserAndIsAuthenticated,
-      setUserSetting: setUserSettingAndUpdateSettings,
-      setWallet,
-      setWalletExpirationSeconds,
-      token,
-      user: frontendUser,
-      userData: user,
-      userSettings,
-      verifyToken,
-      wallet: walletManager.value,
-      walletExpirationSeconds,
-    };
-  }, [
-    authenticatedApi,
-    authState,
-    backupCodeLogin,
-    changePassword,
-    checkAuth,
-    clearMnemonic,
-    clearWallet,
-    colorMode,
-    directLogin,
-    emailChallengeLogin,
-    frontendUser,
-    getMnemonicRemainingTime,
-    getWalletRemainingTime,
-    isAuthenticated,
-    isCheckingAuth,
-    isGlobalAdmin,
-    isBrowserPasswordLoginAvailable,
-    loading,
-    logout,
-    mnemonicManager.value,
-    mnemonicExpirationSeconds,
-    passwordLogin,
-    refreshToken,
-    register,
-    requestEmailLogin,
-    serverPublicKey,
-    setMnemonic,
-    setMnemonicExpirationSeconds,
-    setUpBrowserPasswordLogin,
-    setUserSettingAndUpdateSettings,
-    setWallet,
-    setWalletExpirationSeconds,
-    token,
-    user,
-    userSettings,
-    verifyToken,
-    walletManager.value,
-    walletExpirationSeconds,
-  ]);
-
-  return (
-    <AuthContext.Provider value={contextValue}>{children}</AuthContext.Provider>
-  );
-};
-
-export const AuthProvider = ({ children, baseUrl, constants, eciesConfig, onLogout }: AuthProviderProps) => {
-  return (
-    <AuthProviderInner baseUrl={baseUrl} constants={constants} eciesConfig={eciesConfig} onLogout={onLogout}>
-      {children}
-    </AuthProviderInner>
-  );
-};
-
-export const useAuth = () => {
-  return useContext(AuthContext);
-};