@oxyhq/services 5.16.17 → 5.16.19

package/src/ui/context/hooks/useAuthOperations.ts

@@ -3,11 +3,11 @@ import type { ApiError, User } from '../../../models/interfaces';
 import type { AuthState } from '../../stores/authStore';
 import type { ClientSession, SessionLoginResponse } from '../../../models/session';
 import { DeviceManager } from '../../../utils/deviceManager';
-import { fetchSessionsWithFallback, mapSessionsToClient } from '../utils/sessionHelpers';
-import { handleAuthError, isInvalidSessionError } from '../utils/errorHandlers';
-import type { StorageInterface } from '../utils/storageHelpers';
+import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sessionHelpers';
+import { handleAuthError, isInvalidSessionError } from '../../utils/errorHandlers';
+import type { StorageInterface } from '../../utils/storageHelpers';
 import type { OxyServices } from '../../../core';
-import { KeyManager, SignatureService, RecoveryPhraseService } from '../../../crypto';
+import { KeyManager, SignatureService } from '../../../crypto';
 
 export interface UseAuthOperationsOptions {
   oxyServices: OxyServices;
@@ -34,9 +34,9 @@ export interface UseAuthOperationsOptions {
 
 export interface UseAuthOperationsResult {
   /** Create a new identity locally (offline-first) and optionally sync with server */
-  createIdentity: () => Promise<{ recoveryPhrase: string[]; synced: boolean }>;
-  /** Import an existing identity from recovery phrase */
-  importIdentity: (phrase: string) => Promise<{ synced: boolean }>;
+  createIdentity: () => Promise<{ synced: boolean }>;
+  /** Import an existing identity from backup file data */
+  importIdentity: (backupData: { encrypted: string; salt: string; iv: string; publicKey: string }, password: string) => Promise<{ synced: boolean }>;
   /** Sign in with existing identity on device */
   signIn: (deviceName?: string) => Promise<User>;
   /** Logout from current session */
@@ -274,18 +274,19 @@ export const useAuthOperations = ({
   );
 
   /**
-   * Create a new identity with recovery phrase (offline-first)
+   * Create a new identity (offline-first)
    * Identity is purely cryptographic - no username or email required
    */
   const createIdentity = useCallback(
-    async (): Promise<{ recoveryPhrase: string[]; synced: boolean }> => {
+    async (): Promise<{ synced: boolean }> => {
       if (!storage) throw new Error('Storage not initialized');
 
       setAuthState({ isLoading: true, error: null });
 
       try {
-        // Generate new identity with recovery phrase (works offline)
-        const { phrase, words, publicKey } = await RecoveryPhraseService.generateIdentityWithRecovery();
+        // Generate new key pair directly (works offline)
+        const { publicKey, privateKey } = await KeyManager.generateKeyPair();
+        await KeyManager.importKeyPair(privateKey);
 
         // Mark as not synced
         await storage.setItem('oxy_identity_synced', 'false');
@@ -301,7 +302,6 @@ export const useAuthOperations = ({
           setIdentitySynced(true);
 
           return {
-            recoveryPhrase: words,
             synced: true,
           };
         } catch (syncError) {
@@ -311,13 +311,12 @@ export const useAuthOperations = ({
           }
           
           return {
-            recoveryPhrase: words,
             synced: false,
           };
         }
       } catch (error) {
         // CRITICAL: Never delete identity on error - it may have been successfully created
-        // Only log the error and let the user recover using their recovery phrase
+        // Only log the error and let the user recover using their backup file
         // Identity deletion should ONLY happen when explicitly requested by the user
         if (__DEV__ && logger) {
           logger('Error during identity creation (identity may still exist):', error);
@@ -330,7 +329,7 @@ export const useAuthOperations = ({
           await storage.setItem('oxy_identity_synced', 'false').catch(() => {});
           setIdentitySynced(false);
           if (__DEV__ && logger) {
-            logger('Identity was created but sync failed - user can sync later using recovery phrase');
+            logger('Identity was created but sync failed - user can sync later using backup file');
           }
         } else {
           // No identity exists - this was a generation failure, safe to clean up sync flag
@@ -342,7 +341,7 @@ export const useAuthOperations = ({
           defaultMessage: 'Failed to create identity',
           code: REGISTER_ERROR_CODE,
           onError,
-          setAuthError: (msg) => setAuthState({ error: msg }),
+          setAuthError: (msg: string) => setAuthState({ error: msg }),
           logger,
         });
         loginFailure(message);
@@ -405,6 +404,13 @@ export const useAuthOperations = ({
         // Sign in
         const user = await performSignIn(publicKey);
 
+        // Check if user has username - required for syncing
+        if (!user.username) {
+          const usernameError = new Error('USERNAME_REQUIRED');
+          (usernameError as any).code = 'USERNAME_REQUIRED';
+          throw usernameError;
+        }
+
         // TanStack Query will automatically retry any pending mutations
 
         return user;
@@ -413,7 +419,7 @@ export const useAuthOperations = ({
           defaultMessage: 'Failed to sync identity',
           code: REGISTER_ERROR_CODE,
           onError,
-          setAuthError: (msg) => setAuthState({ error: msg }),
+          setAuthError: (msg: string) => setAuthState({ error: msg }),
           logger,
         });
         loginFailure(message);
@@ -427,17 +433,68 @@ export const useAuthOperations = ({
   );
 
   /**
-   * Import identity from recovery phrase (offline-first)
+   * Import identity from backup file data (offline-first)
    */
   const importIdentity = useCallback(
-    async (phrase: string): Promise<{ synced: boolean }> => {
+    async (backupData: { encrypted: string; salt: string; iv: string; publicKey: string }, password: string): Promise<{ synced: boolean }> => {
       if (!storage) throw new Error('Storage not initialized');
 
+      // Validate arguments - ensure backupData is an object, not a string (old signature)
+      if (!backupData || typeof backupData !== 'object' || Array.isArray(backupData)) {
+        throw new Error('Invalid backup data. Please use the backup file import feature.');
+      }
+
+      if (!backupData.encrypted || !backupData.salt || !backupData.iv || !backupData.publicKey) {
+        throw new Error('Invalid backup data structure. Missing required fields.');
+      }
+
+      if (!password || typeof password !== 'string') {
+        throw new Error('Password is required for backup file import.');
+      }
+
       setAuthState({ isLoading: true, error: null });
 
       try {
-        // Restore identity from phrase (works offline)
-        const publicKey = await RecoveryPhraseService.restoreFromPhrase(phrase);
+        // Decrypt private key from backup data
+        const Crypto = await import('expo-crypto');
+        
+        // Convert hex strings to Uint8Array
+        const saltBytes = new Uint8Array(
+          backupData.salt.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16)) || []
+        );
+        const ivBytes = new Uint8Array(
+          backupData.iv.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16)) || []
+        );
+
+        // Derive key from password (same algorithm as EncryptedBackupGenerator)
+        const saltHex = Array.from(saltBytes).map(b => b.toString(16).padStart(2, '0')).join('');
+        let key = password + saltHex;
+        for (let i = 0; i < 10000; i++) {
+          key = await Crypto.digestStringAsync(
+            Crypto.CryptoDigestAlgorithm.SHA256,
+            key
+          );
+        }
+        const keyBytes = new Uint8Array(32);
+        for (let i = 0; i < 64 && i < key.length; i += 2) {
+          keyBytes[i / 2] = parseInt(key.substring(i, i + 2), 16);
+        }
+
+        // Decrypt private key (XOR decryption - same as encryption)
+        const encryptedBytes = Buffer.from(backupData.encrypted, 'base64');
+        const decryptedBytes = new Uint8Array(encryptedBytes.length);
+        for (let i = 0; i < encryptedBytes.length; i++) {
+          decryptedBytes[i] = encryptedBytes[i] ^ keyBytes[i % keyBytes.length] ^ ivBytes[i % ivBytes.length];
+        }
+        const privateKey = new TextDecoder().decode(decryptedBytes);
+
+        // Import the key pair
+        const publicKey = await KeyManager.importKeyPair(privateKey);
+
+        // Verify public key matches
+        if (publicKey !== backupData.publicKey) {
+          throw new Error('Backup file is corrupted or password is incorrect');
+        }
 
         // Mark as not synced
         await storage.setItem('oxy_identity_synced', 'false');
@@ -471,10 +528,10 @@ export const useAuthOperations = ({
         }
       } catch (error) {
         const message = handleAuthError(error, {
-          defaultMessage: 'Failed to import identity',
+          defaultMessage: 'Failed to import identity. Please check your password and backup file.',
           code: REGISTER_ERROR_CODE,
           onError,
-          setAuthError: (msg) => setAuthState({ error: msg }),
+          setAuthError: (msg: string) => setAuthState({ error: msg }),
           logger,
         });
         loginFailure(message);
@@ -508,7 +565,7 @@ export const useAuthOperations = ({
           defaultMessage: 'Sign in failed',
           code: LOGIN_ERROR_CODE,
           onError,
-          setAuthError: (msg) => setAuthState({ error: msg }),
+          setAuthError: (msg: string) => setAuthState({ error: msg }),
           logger,
         });
         loginFailure(message);
@@ -554,7 +611,7 @@ export const useAuthOperations = ({
           defaultMessage: 'Logout failed',
           code: LOGOUT_ERROR_CODE,
           onError,
-          setAuthError: (msg) => setAuthState({ error: msg }),
+          setAuthError: (msg: string) => setAuthState({ error: msg }),
           logger,
           status: isInvalid ? 401 : undefined,
         });
@@ -592,7 +649,7 @@ export const useAuthOperations = ({
         defaultMessage: 'Logout all failed',
         code: LOGOUT_ALL_ERROR_CODE,
         onError,
-        setAuthError: (msg) => setAuthState({ error: msg }),
+        setAuthError: (msg: string) => setAuthState({ error: msg }),
         logger,
       });
       throw error instanceof Error ? error : new Error('Logout all failed');

package/src/ui/context/hooks/useDeviceManagement.ts

@@ -2,7 +2,7 @@ import { useCallback } from 'react';
 import type { ApiError } from '../../../models/interfaces';
 import { DeviceManager } from '../../../utils/deviceManager';
 import type { OxyServices } from '../../../core';
-import { handleAuthError } from '../utils/errorHandlers';
+import { handleAuthError } from '../../utils/errorHandlers';
 
 export interface UseDeviceManagementOptions {
   oxyServices: OxyServices;

package/src/ui/context/hooks/useLanguageManagement.ts

@@ -7,8 +7,8 @@ import {
   normalizeLanguageCode,
   type LanguageMetadata,
 } from '../../../utils/languageUtils';
-import type { StorageInterface } from '../utils/storageHelpers';
-import { extractErrorMessage } from '../utils/errorHandlers';
+import type { StorageInterface } from '../../utils/storageHelpers';
+import { extractErrorMessage } from '../../utils/errorHandlers';
 
 export interface UseLanguageManagementOptions {
   storage: StorageInterface | null;

package/src/ui/context/hooks/useSessionManagement.ts

@@ -2,9 +2,9 @@ import { useCallback, useMemo, useRef, useState } from 'react';
 import type { ApiError, User } from '../../../models/interfaces';
 import type { ClientSession } from '../../../models/session';
 import { mergeSessions, normalizeAndSortSessions, sessionsArraysEqual } from '../../../utils/sessionUtils';
-import { fetchSessionsWithFallback, mapSessionsToClient, validateSessionBatch } from '../utils/sessionHelpers';
-import { getStorageKeys, type StorageInterface } from '../utils/storageHelpers';
-import { handleAuthError, isInvalidSessionError } from '../utils/errorHandlers';
+import { fetchSessionsWithFallback, mapSessionsToClient, validateSessionBatch } from '../../utils/sessionHelpers';
+import { getStorageKeys, type StorageInterface } from '../../utils/storageHelpers';
+import { handleAuthError, isInvalidSessionError } from '../../utils/errorHandlers';
 import type { OxyServices } from '../../../core';
 import type { QueryClient } from '@tanstack/react-query';
 import { clearQueryCache } from '../../hooks/queryClient';

package/src/ui/context/hooks/useStorage.ts

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import type { ApiError } from '../../../models/interfaces';
-import { createPlatformStorage, type StorageInterface } from '../utils/storageHelpers';
-import { extractErrorMessage } from '../utils/errorHandlers';
+import { createPlatformStorage, type StorageInterface } from '../../utils/storageHelpers';
+import { extractErrorMessage } from '../../utils/errorHandlers';
 
 export interface UseStorageOptions {
   onError?: (error: ApiError) => void;

package/src/ui/hooks/queries/useAccountQueries.ts

@@ -132,7 +132,7 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
   const targetUserId = userId || user?.id;
 
   return useQuery({
-    queryKey: queryKeys.privacy.settings(userId),
+    queryKey: queryKeys.privacy.settings(targetUserId),
     queryFn: async () => {
       if (!targetUserId) {
         throw new Error('User ID is required');

package/src/ui/hooks/queries/useServicesQueries.ts

@@ -2,7 +2,7 @@ import { useQuery } from '@tanstack/react-query';
 import type { ClientSession } from '../../../models/session';
 import { queryKeys } from './queryKeys';
 import { useOxy } from '../../context/OxyContext';
-import { fetchSessionsWithFallback, mapSessionsToClient } from '../../context/utils/sessionHelpers';
+import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sessionHelpers';
 
 /**
  * Get all active sessions for the current user

package/src/ui/hooks/useIdentityMutations.ts

@@ -8,7 +8,6 @@ import { useMutation, useQueryClient } from '@tanstack/react-query';
 import type { User } from '../../models/interfaces';
 
 export interface CreateIdentityResult {
-  recoveryPhrase: string[];
   synced: boolean;
 }
 
@@ -34,7 +33,7 @@ export function useCreateIdentity(
     },
     onError: (error) => {
       // Never delete identity on error - just log it
-      // User can recover using recovery phrase
+      // User can recover using backup file
       if (__DEV__) {
         console.warn('[useCreateIdentity] Identity creation error (identity may still exist):', error);
       }
@@ -45,16 +44,17 @@ export function useCreateIdentity(
 }
 
 /**
- * Hook for importing an identity from recovery phrase
+ * Hook for importing an identity from backup file
  * Never deletes identity on error - preserves user data
  */
 export function useImportIdentity(
-  importIdentityFn: (phrase: string) => Promise<ImportIdentityResult>
+  importIdentityFn: (backupData: { encrypted: string; salt: string; iv: string; publicKey: string }, password: string) => Promise<ImportIdentityResult>
 ) {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: importIdentityFn,
+    mutationFn: (variables: { backupData: { encrypted: string; salt: string; iv: string; publicKey: string }; password: string }) => 
+      importIdentityFn(variables.backupData, variables.password),
     onSuccess: (data) => {
       queryClient.invalidateQueries({ queryKey: ['user'] });
       queryClient.invalidateQueries({ queryKey: ['identity'] });
@@ -89,7 +89,7 @@ export function useSyncIdentity(
     },
     onError: (error) => {
       // Never delete identity on error - just log it
-      // User can retry sync later or use recovery phrase
+      // User can retry sync later or use backup file
       if (__DEV__) {
         console.warn('[useSyncIdentity] Sync failed, but identity is preserved:', error);
       }

package/src/ui/hooks/useSessionSocket.ts

@@ -1,6 +1,7 @@
 import { useEffect, useRef } from 'react';
 import io from 'socket.io-client';
 import { toast } from '../../lib/sonner';
+import { logger } from '../../utils/loggerUtils';
 
 interface UseSessionSocketProps {
   userId: string | null | undefined;
@@ -113,7 +114,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
             await clearSessionStateRef.current();
           } catch (error) {
             if (__DEV__) {
-              console.error('Failed to clear session state after session_removed:', error);
+              logger.error('Failed to clear session state after session_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
             }
           }
         } else {
@@ -121,7 +122,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
           refreshSessionsRef.current().catch((error) => {
             // Silently handle errors from refresh - they're expected if sessions were removed
             if (__DEV__) {
-              console.debug('Failed to refresh sessions after session_removed:', error);
+              logger.debug('Failed to refresh sessions after session_removed', { component: 'useSessionSocket' }, error as unknown);
             }
           });
         }
@@ -146,7 +147,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
             await clearSessionStateRef.current();
           } catch (error) {
             if (__DEV__) {
-              console.error('Failed to clear session state after device_removed:', error);
+              logger.error('Failed to clear session state after device_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
             }
           }
         } else {
@@ -154,7 +155,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
           refreshSessionsRef.current().catch((error) => {
             // Silently handle errors from refresh - they're expected if sessions were removed
             if (__DEV__) {
-              console.debug('Failed to refresh sessions after device_removed:', error);
+              logger.debug('Failed to refresh sessions after device_removed', { component: 'useSessionSocket' }, error as unknown);
             }
           });
         }
@@ -179,7 +180,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
             await clearSessionStateRef.current();
           } catch (error) {
             if (__DEV__) {
-              console.error('Failed to clear session state after sessions_removed:', error);
+              logger.error('Failed to clear session state after sessions_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
             }
           }
         } else {
@@ -187,7 +188,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
           refreshSessionsRef.current().catch((error) => {
             // Silently handle errors from refresh - they're expected if sessions were removed
             if (__DEV__) {
-              console.debug('Failed to refresh sessions after sessions_removed:', error);
+              logger.debug('Failed to refresh sessions after sessions_removed', { component: 'useSessionSocket' }, error as unknown);
             }
           });
         }
@@ -196,7 +197,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
         refreshSessionsRef.current().catch((error) => {
           // Log but don't throw - refresh errors shouldn't break the socket handler
           if (__DEV__) {
-            console.debug('Failed to refresh sessions after session_update:', error);
+            logger.debug('Failed to refresh sessions after session_update', { component: 'useSessionSocket' }, error as unknown);
           }
         });
         

package/src/ui/screens/AccountCenterScreen.tsx

@@ -102,9 +102,9 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                     <QuickActions
                         theme={normalizedTheme}
                         actions={useMemo(() => [
-                            { id: 'overview', icon: 'person-circle', iconColor: colors.iconSecurity, title: t('accountCenter.quickActions.overview') || 'Overview', onPress: () => navigate?.('AccountOverview') },
-                            { id: 'settings', icon: 'settings', iconColor: colors.iconData, title: t('accountCenter.quickActions.editProfile') || 'Edit Profile', onPress: () => navigate?.('EditProfile') },
-                            { id: 'sessions', icon: 'shield-checkmark', iconColor: colors.iconSecurity, title: t('accountCenter.quickActions.sessions') || 'Sessions', onPress: () => navigate?.('SessionManagement') },
+                            { id: 'overview', icon: 'account-circle', iconColor: colors.iconSecurity, title: t('accountCenter.quickActions.overview') || 'Overview', onPress: () => navigate?.('AccountOverview') },
+                            { id: 'settings', icon: 'cog', iconColor: colors.iconData, title: t('accountCenter.quickActions.editProfile') || 'Edit Profile', onPress: () => navigate?.('EditProfile') },
+                            { id: 'sessions', icon: 'shield-check', iconColor: colors.iconSecurity, title: t('accountCenter.quickActions.sessions') || 'Sessions', onPress: () => navigate?.('SessionManagement') },
                             { id: 'premium', icon: 'star', iconColor: colors.iconPayments, title: t('accountCenter.quickActions.premium') || 'Premium', onPress: () => navigate?.('PremiumSubscription') },
                             ...(user?.isPremium ? [{ id: 'billing', icon: 'card', iconColor: colors.iconPersonalInfo, title: t('accountCenter.quickActions.billing') || 'Billing', onPress: () => navigate?.('PaymentGateway') }] : []),
                             ...(sessions && sessions.length > 1 ? [{ id: 'switch', icon: 'swap-horizontal', iconColor: colors.iconStorage, title: t('accountCenter.quickActions.switch') || 'Switch', onPress: () => navigate?.('AccountSwitcher') }] : []),
@@ -119,7 +119,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                         items={useMemo(() => [
                             {
                                 id: 'overview',
-                                icon: 'person-circle',
+                                icon: 'account-circle',
                                 iconColor: colors.iconSecurity,
                                 title: t('accountCenter.items.accountOverview.title') || 'Account Overview',
                                 subtitle: t('accountCenter.items.accountOverview.subtitle') || 'Complete account information',
@@ -127,7 +127,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                             },
                             {
                                 id: 'settings',
-                                icon: 'settings',
+                                icon: 'cog',
                                 iconColor: colors.iconData,
                                 title: t('accountCenter.items.editProfile.title') || 'Edit Profile',
                                 subtitle: t('accountCenter.items.editProfile.subtitle') || 'Manage your profile and preferences',
@@ -135,7 +135,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                             },
                             {
                                 id: 'sessions',
-                                icon: 'shield-checkmark',
+                                icon: 'shield-check',
                                 iconColor: colors.iconSecurity,
                                 title: t('accountCenter.items.manageSessions.title') || 'Manage Sessions',
                                 subtitle: t('accountCenter.items.manageSessions.subtitle') || 'Security and active devices',
@@ -177,7 +177,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                             items={useMemo(() => [
                                 {
                                     id: 'switch',
-                                    icon: 'people',
+                                    icon: 'account-group',
                                     iconColor: colors.iconStorage,
                                     title: t('accountCenter.items.switchAccount.title') || 'Switch Account',
                                     subtitle: t('accountCenter.items.switchAccount.subtitle', { count: sessions.length }) || `${sessions.length} accounts available`,
@@ -185,7 +185,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                                 },
                                 {
                                     id: 'add',
-                                    icon: 'person-add',
+                                    icon: 'account-plus',
                                     iconColor: colors.iconPersonalInfo,
                                     title: t('accountCenter.items.addAccount.title') || 'Add Another Account',
                                     subtitle: t('accountCenter.items.addAccount.subtitle') || 'Sign in with a different account',
@@ -204,7 +204,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                             items={useMemo(() => [
                                 {
                                     id: 'add',
-                                    icon: 'person-add',
+                                    icon: 'account-plus',
                                     iconColor: colors.iconPersonalInfo,
                                     title: t('accountCenter.items.addAccount.title') || 'Add Another Account',
                                     subtitle: t('accountCenter.items.addAccount.subtitle') || 'Sign in with a different account',
@@ -222,7 +222,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                         items={useMemo(() => [
                             ...(Platform.OS !== 'web' ? [{
                                 id: 'notifications',
-                                icon: 'notifications',
+                                icon: 'bell',
                                 iconColor: colors.iconStorage,
                                 title: t('accountCenter.items.notifications.title') || 'Notifications',
                                 subtitle: t('accountCenter.items.notifications.subtitle') || 'Manage notification settings',
@@ -230,7 +230,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                             }] : []),
                             {
                                 id: 'language',
-                                icon: 'language',
+                                icon: 'translate',
                                 iconColor: colors.iconPersonalInfo,
                                 title: t('language.title') || 'Language',
                                 subtitle: t('language.subtitle') || 'Choose your preferred language',
@@ -246,7 +246,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                             },
                             {
                                 id: 'appinfo',
-                                icon: 'information-circle',
+                                icon: 'information',
                                 iconColor: '#8E8E93',
                                 title: t('accountCenter.items.appInfo.title') || 'App Information',
                                 subtitle: t('accountCenter.items.appInfo.subtitle') || 'Version and system details',
@@ -260,7 +260,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                 {/* Sign Out Section */}
                 <Section >
                     <GroupedItem
-                        icon="log-out"
+                        icon="logout"
                         iconColor={dangerColor}
                         title={isLoading ? (t('accountCenter.signingOut') || 'Signing out...') : (t('common.actions.signOut') || 'Sign Out')}