@digitaldefiance/express-suite-react-components 2.9.38 → 2.9.39

package/src/contexts/AuthProvider.tsx

@@ -1,924 +0,0 @@
-import {
-  AESGCMService,
-  Constants as AppConstants,
-  ECIESService,
-  EmailString,
-  Member as FrontendMember,
-  IECIESConfig,
-  PasswordLoginService,
-  Pbkdf2Service,
-  SecureString,
-} from '@digitaldefiance/ecies-lib';
-import {
-  CoreLanguageCode,
-  CurrencyCode,
-  Timezone,
-} from '@digitaldefiance/i18n-lib';
-import {
-  IConstants,
-  IRequestUserDTO,
-  ISuccessMessage,
-  IUserSettings,
-  SuiteCoreComponentId,
-  SuiteCoreStringKey,
-} from '@digitaldefiance/suite-core-lib';
-import { Wallet } from '@ethereumjs/wallet';
-import { PaletteMode } from '@mui/material';
-import {
-  createContext,
-  ReactNode,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useState,
-} from 'react';
-import { useExpiringValue } from '../hooks/useExpiringValue';
-import { useLocalStorage } from '../hooks/useLocalStorage';
-import { useUserSettings } from '../hooks/useUserSettings';
-import { createAuthService } from '../services/authService';
-import { createAuthenticatedApiClient } from '../services/authenticatedApi';
-import { useI18n } from './I18nProvider';
-import { useTheme } from './ThemeProvider';
-
-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 { 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
-      );
-    },
-    // mnemonicManager is intentionally excluded as it's a stable reference from useExpiringValue
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      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
-      );
-    },
-    // walletManager is intentionally excluded as it's a stable reference from useExpiringValue
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      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);
-    const aesGcmService = new AESGCMService();
-    return new PasswordLoginService(
-      aesGcmService,
-      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,
-      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']>>;
-    },
-    [authService]
-  );
-
-  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;
-    },
-    [authService]
-  );
-
-  const setUpBrowserPasswordLogin = useCallback(
-    async (
-      mnemonic: SecureString,
-      password: SecureString
-    ): 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
-          ),
-        };
-      }
-    },
-    [getPasswordLoginService, setMnemonic, setWallet, 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 {
-        setLoading(false);
-        return { error: 'Password change failed' };
-      }
-    },
-    [
-      getPasswordLoginService,
-      setMnemonic,
-      setWallet,
-      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 is intentionally excluded as it's a stable reference from useMemo
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [
-    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);
-};