@oxyhq/services 5.16.43 → 5.17.0

package/lib/commonjs/ui/context/OxyContext.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useOxy = exports.default = exports.OxyProvider = exports.OxyContextProvider = void 0;
 var _react = require("react");
+var _reactNative = require("react-native");
 var _core = require("../../core");
 var _sonner = require("../../lib/sonner");
 var _authStore = require("../stores/authStore");
@@ -12,20 +13,48 @@ var _shallow = require("zustand/react/shallow");
 var _useSessionSocket = require("../hooks/useSessionSocket");
 var _useStorage = require("../hooks/useStorage");
 var _useLanguageManagement = require("../hooks/useLanguageManagement");
+var _useSessionManagement = require("../hooks/useSessionManagement");
+var _useAuthOperations = require("./hooks/useAuthOperations");
+var _useDeviceManagement = require("../hooks/useDeviceManagement");
 var _storageHelpers = require("../utils/storageHelpers");
 var _errorHandlers = require("../utils/errorHandlers");
 var _bottomSheetManager = require("../navigation/bottomSheetManager");
 var _reactQuery = require("@tanstack/react-query");
+var _queries = require("../hooks/queries");
 var _queryClient = require("../hooks/queryClient");
-var _identitySession = require("../../core/identity-session");
+var _crypto = require("../../crypto");
+var _i18n = require("../../i18n");
+var _avatarUtils = require("../utils/avatarUtils");
 var _accountStore = require("../stores/accountStore");
-var _transferStore = require("../stores/transferStore");
-var _useTransferQueries = require("../hooks/useTransferQueries");
-var _useTransferCodesPersistence = require("../hooks/useTransferCodesPersistence");
-var _useIdentityTransfer = require("../hooks/useIdentityTransfer");
-var _useAvatarPicker = require("../hooks/useAvatarPicker");
+var _loggerUtils = require("../../utils/loggerUtils");
 var _jsxRuntime = require("react/jsx-runtime");
 const OxyContext = /*#__PURE__*/(0, _react.createContext)(null);
+let cachedUseFollowHook = null;
+const loadUseFollowHook = () => {
+  if (cachedUseFollowHook) {
+    return cachedUseFollowHook;
+  }
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const {
+      useFollow
+    } = require('../hooks/useFollow');
+    cachedUseFollowHook = useFollow;
+    return cachedUseFollowHook;
+  } catch (error) {
+    if (__DEV__) {
+      _loggerUtils.logger.warn('useFollow hook is not available. Please import useFollow from @oxyhq/services directly.', {
+        component: 'OxyContext',
+        method: 'loadUseFollowHook'
+      }, error);
+    }
+    const fallback = () => {
+      throw new Error('useFollow hook is only available in the UI bundle. Import it from @oxyhq/services.');
+    };
+    cachedUseFollowHook = fallback;
+    return cachedUseFollowHook;
+  }
+};
 const OxyProvider = ({
   children,
   oxyServices: providedOxyServices,
@@ -48,8 +77,7 @@ const OxyProvider = ({
   }
   const oxyServices = oxyServicesRef.current;
   const {
-    user,
-    isAuthenticated: isAuthenticatedFromStore,
+    isAuthenticated,
     isLoading,
     error,
     loginSuccess,
@@ -61,7 +89,6 @@ const OxyProvider = ({
     setIdentitySynced,
     setSyncing
   } = (0, _authStore.useAuthStore)((0, _shallow.useShallow)(state => ({
-    user: state.user,
     isAuthenticated: state.isAuthenticated,
     isLoading: state.isLoading,
     error: state.error,
@@ -75,6 +102,7 @@ const OxyProvider = ({
     setSyncing: state.setSyncing
   })));
   const [tokenReady, setTokenReady] = (0, _react.useState)(true);
+  const initializedRef = (0, _react.useRef)(false);
   const setAuthState = _authStore.useAuthStore.setState;
   const logger = (0, _react.useCallback)((message, err) => {
     if (__DEV__) {
@@ -94,29 +122,48 @@ const OxyProvider = ({
     logger
   });
 
-  // Initialize Identity Session Core
-  const [identityCore, setIdentityCore] = (0, _react.useState)(null);
-  const [isCoreInitialized, setIsCoreInitialized] = (0, _react.useState)(false);
+  // Identity integrity check and auto-restore on startup
+  // Skip on web platform - identity storage is only available on native platforms
   (0, _react.useEffect)(() => {
-    let mounted = true;
-    const initCore = async () => {
+    if (!storage || !isStorageReady) return;
+    if (_reactNative.Platform.OS === 'web') return; // Identity operations are native-only
+
+    const checkAndRestoreIdentity = async () => {
       try {
-        const core = await (0, _identitySession.createIdentitySessionCore)(oxyServices.getBaseURL() || baseURL);
-        if (mounted) {
-          setIdentityCore(core);
-          setIsCoreInitialized(true);
+        // Check if identity exists and verify integrity
+        const hasIdentity = await _crypto.KeyManager.hasIdentity();
+        if (hasIdentity) {
+          const isValid = await _crypto.KeyManager.verifyIdentityIntegrity();
+          if (!isValid) {
+            // Try to restore from backup
+            const restored = await _crypto.KeyManager.restoreIdentityFromBackup();
+            if (__DEV__) {
+              logger(restored ? 'Identity restored from backup successfully' : 'Identity integrity check failed - user may need to restore from backup file');
+            }
+          } else {
+            // Identity is valid - ensure backup is up to date
+            await _crypto.KeyManager.backupIdentity();
+          }
+        } else {
+          // No identity - try to restore from backup
+          const restored = await _crypto.KeyManager.restoreIdentityFromBackup();
+          if (restored && __DEV__) {
+            logger('Identity restored from backup on startup');
+          }
         }
       } catch (error) {
         if (__DEV__) {
-          logger('Failed to initialize identity session core', error);
+          logger('Error during identity integrity check', error);
         }
+        // Don't block app startup - user can recover with backup file
       }
     };
-    initCore();
-    return () => {
-      mounted = false;
-    };
-  }, [oxyServices, baseURL, logger]);
+    checkAndRestoreIdentity();
+  }, [storage, isStorageReady, logger]);
+
+  // Offline queuing is now handled by TanStack Query mutations
+  // No need for custom offline queue
+
   const {
     currentLanguage,
     metadata: currentLanguageMetadata,
@@ -131,112 +178,79 @@ const OxyProvider = ({
     logger
   });
   const queryClient = (0, _reactQuery.useQueryClient)();
+  const {
+    sessions,
+    activeSessionId,
+    setActiveSessionId,
+    updateSessions,
+    switchSession,
+    refreshSessions,
+    clearSessionState,
+    saveActiveSessionId,
+    trackRemovedSession
+  } = (0, _useSessionManagement.useSessionManagement)({
+    oxyServices,
+    storage,
+    storageKeyPrefix,
+    loginSuccess,
+    logoutStore,
+    applyLanguagePreference,
+    onAuthStateChange,
+    onError,
+    setAuthError: message => setAuthState({
+      error: message
+    }),
+    logger,
+    setTokenReady,
+    queryClient
+  });
 
-  // Session state management using core
-  const [sessions, setSessions] = (0, _react.useState)([]);
-  const [activeSessionId, setActiveSessionId] = (0, _react.useState)(null);
-
-  // Load sessions from core
-  const loadSessionsFromCore = (0, _react.useCallback)(async () => {
-    if (!identityCore || !isCoreInitialized) return;
-    try {
-      const coreSessions = await identityCore.getAllSessions();
-      const activeId = await identityCore.getActiveSessionId();
-
-      // Convert core sessions to ClientSession format
-      const clientSessions = coreSessions.map(s => ({
-        deviceInfo: s.deviceInfo,
-        sessionId: s.sessionId,
-        deviceId: s.deviceId,
-        userId: s.userId,
-        expiresAt: s.expiresAt,
-        lastActive: s.lastActive,
-        isCurrent: s.isCurrent || false
-      }));
-      setSessions(clientSessions);
-      setActiveSessionId(activeId);
-    } catch (error) {
-      if (__DEV__) {
-        logger('Failed to load sessions from core', error);
-      }
-    }
-  }, [identityCore, isCoreInitialized, logger]);
-
-  // Load sessions when core is initialized
-  (0, _react.useEffect)(() => {
-    if (isCoreInitialized) {
-      loadSessionsFromCore();
-    }
-  }, [isCoreInitialized, loadSessionsFromCore]);
+  // Get current user from query (no persistent cache - always fetch fresh)
+  // Services never caches profile - always fetch from backend
+  const {
+    data: userData
+  } = (0, _queries.useCurrentUser)({
+    enabled: isAuthenticated && !!activeSessionId
+  });
+  const user = userData ?? null;
+  const {
+    createIdentity,
+    importIdentity: importIdentityBase,
+    signIn,
+    logout,
+    logoutAll,
+    hasIdentity,
+    getPublicKey,
+    isIdentitySynced,
+    syncIdentity: syncIdentityBase
+  } = (0, _useAuthOperations.useAuthOperations)({
+    oxyServices,
+    storage,
+    sessions,
+    activeSessionId,
+    setActiveSessionId,
+    updateSessions,
+    saveActiveSessionId,
+    clearSessionState,
+    switchSession,
+    applyLanguagePreference,
+    onAuthStateChange,
+    onError,
+    loginSuccess,
+    loginFailure,
+    logoutStore,
+    setAuthState,
+    setIdentitySynced,
+    setSyncing,
+    logger
+  });
 
-  // Subscribe to core events
-  (0, _react.useEffect)(() => {
-    if (!identityCore || !isCoreInitialized) return;
-    const unsubscribe = identityCore.subscribe(event => {
-      if (event.type === 'session:created' || event.type === 'session:refreshed' || event.type === 'session:invalidated' || event.type === 'session:all-invalidated') {
-        loadSessionsFromCore();
-      }
-    });
-    return unsubscribe;
-  }, [identityCore, isCoreInitialized, loadSessionsFromCore]);
-
-  // Identity operations using core
-  const hasIdentity = (0, _react.useCallback)(async () => {
-    if (!identityCore || !isCoreInitialized) return false;
-    return await identityCore.hasIdentity();
-  }, [identityCore, isCoreInitialized]);
-  const getPublicKey = (0, _react.useCallback)(async () => {
-    if (!identityCore || !isCoreInitialized) return null;
-    return await identityCore.getPublicKey();
-  }, [identityCore, isCoreInitialized]);
-  const isIdentitySynced = (0, _react.useCallback)(async () => {
-    if (!storage) return false;
-    const synced = await storage.getItem('oxy_identity_synced');
-    return synced === 'true';
-  }, [storage]);
-  const createIdentity = (0, _react.useCallback)(async username => {
-    if (!identityCore || !isCoreInitialized) {
-      throw new Error('Identity core not initialized');
-    }
-    setSyncing(true);
-    try {
-      // Create identity using core
-      const identity = await identityCore.createIdentity(username);
+  // syncIdentity - TanStack Query handles offline mutations automatically
+  const syncIdentity = (0, _react.useCallback)(() => syncIdentityBase(), [syncIdentityBase]);
 
-      // Try to register with backend
-      let synced = false;
-      try {
-        const {
-          signature,
-          publicKey,
-          timestamp
-        } = await identityCore.createRegistrationSignature();
-        const result = await oxyServices.register(publicKey, signature, timestamp, username);
-        if (result?.user) {
-          loginSuccess(result.user);
-          synced = true;
-          await storage?.setItem('oxy_identity_synced', 'true');
-          setIdentitySynced(true);
-        }
-      } catch (error) {
-        // Registration failed (likely offline) - identity still created locally
-        if (__DEV__) {
-          logger('Failed to register identity with backend (offline mode)', error);
-        }
-      }
-      return {
-        synced
-      };
-    } finally {
-      setSyncing(false);
-    }
-  }, [identityCore, isCoreInitialized, oxyServices, storage, loginSuccess, setIdentitySynced, setSyncing, logger]);
+  // Wrapper for importIdentity to handle legacy calls gracefully
   const importIdentity = (0, _react.useCallback)(async (backupData, password) => {
-    if (!identityCore || !isCoreInitialized) {
-      throw new Error('Identity core not initialized');
-    }
-
-    // Handle legacy calls with single string argument
+    // Handle legacy calls with single string argument (old recovery phrase signature)
     if (typeof backupData === 'string') {
       throw new Error('Recovery phrase import is no longer supported. Please use backup file import or QR code transfer instead.');
     }
@@ -245,279 +259,63 @@ const OxyProvider = ({
     if (!password || typeof password !== 'string') {
       throw new Error('Password is required for backup file import.');
     }
-    setSyncing(true);
-    try {
-      // Import identity using core
-      const identity = await identityCore.importIdentity(backupData, password);
-
-      // Try to register with backend if not already registered
-      let synced = false;
-      try {
-        const {
-          signature,
-          publicKey,
-          timestamp
-        } = await identityCore.createRegistrationSignature();
-        const result = await oxyServices.register(publicKey, signature, timestamp);
-        if (result?.user) {
-          loginSuccess(result.user);
-          synced = true;
-          await storage?.setItem('oxy_identity_synced', 'true');
-          setIdentitySynced(true);
-        }
-      } catch (error) {
-        // Check if user already exists (409 conflict)
-        if (error?.status === 409) {
-          // User already registered - try to sign in instead
-          try {
-            await signIn();
-            synced = true;
-            await storage?.setItem('oxy_identity_synced', 'true');
-            setIdentitySynced(true);
-          } catch (signInError) {
-            if (__DEV__) {
-              logger('Failed to sign in after import', signInError);
-            }
-          }
-        } else if (__DEV__) {
-          logger('Failed to register identity with backend (offline mode)', error);
-        }
-      }
-      return {
-        synced
-      };
-    } finally {
-      setSyncing(false);
-    }
-  }, [identityCore, isCoreInitialized, oxyServices, storage, loginSuccess, setIdentitySynced, setSyncing, logger]);
-  const syncIdentity = (0, _react.useCallback)(async username => {
-    if (!identityCore || !isCoreInitialized) {
-      throw new Error('Identity core not initialized');
-    }
-    const publicKey = await identityCore.getPublicKey();
-    if (!publicKey) {
-      throw new Error('No identity found');
-    }
-    setSyncing(true);
-    try {
-      const {
-        signature,
-        publicKey: pk,
-        timestamp
-      } = await identityCore.createRegistrationSignature();
-      const result = await oxyServices.register(pk, signature, timestamp, username);
-      if (result?.user) {
-        loginSuccess(result.user);
-        await storage?.setItem('oxy_identity_synced', 'true');
-        setIdentitySynced(true);
-        return result.user;
-      }
-      throw new Error('Registration failed');
-    } catch (error) {
-      // Check if user already exists (409 conflict) - try to sign in
-      if (error?.status === 409) {
-        const user = await signIn();
-        await storage?.setItem('oxy_identity_synced', 'true');
-        setIdentitySynced(true);
-        return user;
-      }
-      throw error;
-    } finally {
-      setSyncing(false);
-    }
-  }, [identityCore, isCoreInitialized, oxyServices, storage, loginSuccess, setIdentitySynced, setSyncing]);
-  const signIn = (0, _react.useCallback)(async deviceName => {
-    if (!identityCore || !isCoreInitialized) {
-      throw new Error('Identity core not initialized');
-    }
-    setAuthState({
-      isLoading: true
-    });
-    try {
-      // Create session using core
-      const session = await identityCore.createSession(deviceName);
-
-      // Get user from OxyServices
-      const user = await oxyServices.getUserBySession(session.sessionId);
-      if (!user) {
-        throw new Error('Failed to get user data');
-      }
-
-      // Set token in OxyServices
-      if (session.accessToken) {
-        oxyServices.setTokens(session.accessToken, session.refreshToken || undefined);
-      }
+    return importIdentityBase(backupData, password);
+  }, [importIdentityBase]);
 
-      // Update state
-      loginSuccess(user);
-      await loadSessionsFromCore();
-      onAuthStateChange?.(user);
-      await applyLanguagePreference(user);
-      setTokenReady(true);
-      return user;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      loginFailure(errorMessage);
-      throw error;
-    } finally {
-      setAuthState({
-        isLoading: false
-      });
-    }
-  }, [identityCore, isCoreInitialized, oxyServices, loginSuccess, loginFailure, setAuthState, loadSessionsFromCore, onAuthStateChange, applyLanguagePreference, setTokenReady]);
-
-  // Session management functions
-  const clearSessionState = (0, _react.useCallback)(async () => {
-    setSessions([]);
-    setActiveSessionId(null);
-    logoutStore();
-    onAuthStateChange?.(null);
-
-    // Clear TanStack Query cache
+  // Clear all account data when identity is lost (for accounts app)
+  // In accounts app, identity = account, so losing identity means losing everything
+  const clearAllAccountData = (0, _react.useCallback)(async () => {
+    // Clear TanStack Query cache (in-memory)
     queryClient.clear();
 
-    // Clear persisted query cache and session storage
+    // Clear persisted query cache
     if (storage) {
       try {
         await (0, _queryClient.clearQueryCache)(storage);
-        await storage.removeItem(storageKeys.activeSessionId);
-        await storage.removeItem(storageKeys.sessionIds);
-        await storage.removeItem('oxy_identity_synced').catch(() => {});
       } catch (error) {
-        if (__DEV__) {
-          logger('Failed to clear session storage', error);
-        }
-      }
-    }
-  }, [logoutStore, onAuthStateChange, queryClient, storage, storageKeys, logger]);
-  const logout = (0, _react.useCallback)(async targetSessionId => {
-    if (!identityCore || !isCoreInitialized) return;
-    try {
-      await identityCore.invalidateSession(targetSessionId);
-      await loadSessionsFromCore();
-      await clearSessionState();
-      setTokenReady(false);
-    } catch (error) {
-      if (__DEV__) {
-        logger('Failed to logout', error);
-      }
-    }
-  }, [identityCore, isCoreInitialized, loadSessionsFromCore, clearSessionState, setTokenReady, logger]);
-  const logoutAll = (0, _react.useCallback)(async () => {
-    if (!identityCore || !isCoreInitialized) return;
-    try {
-      await identityCore.invalidateAllSessions();
-      await loadSessionsFromCore();
-      await clearSessionState();
-      setTokenReady(false);
-    } catch (error) {
-      if (__DEV__) {
-        logger('Failed to logout all', error);
+        logger('Failed to clear persisted query cache', error);
       }
     }
-  }, [identityCore, isCoreInitialized, loadSessionsFromCore, clearSessionState, setTokenReady, logger]);
-  const switchSession = (0, _react.useCallback)(async sessionId => {
-    if (!identityCore || !isCoreInitialized) {
-      throw new Error('Identity core not initialized');
-    }
-    try {
-      // Validate session
-      const validation = await oxyServices.validateSession(sessionId, {
-        useHeaderValidation: true
-      });
-      if (!validation?.valid || !validation.user) {
-        throw new Error('Session is invalid or expired');
-      }
-      const user = validation.user;
 
-      // Get token for this session
-      await oxyServices.getTokenBySession(sessionId);
-
-      // Update active session in core
-      const sessionManager = identityCore.getSessionManager();
-      await sessionManager.setActiveSessionId(sessionId);
-
-      // Update local state
-      setActiveSessionId(sessionId);
-      loginSuccess(user);
-      await applyLanguagePreference(user);
-      onAuthStateChange?.(user);
-      setTokenReady(true);
-      await loadSessionsFromCore();
-      return user;
-    } catch (error) {
-      if ((0, _errorHandlers.isInvalidSessionError)(error)) {
-        // Remove invalid session from list
-        setSessions(prev => prev.filter(s => s.sessionId !== sessionId));
-        if (sessionId === activeSessionId) {
-          await clearSessionState();
-        }
-      }
-      throw error;
-    }
-  }, [identityCore, isCoreInitialized, oxyServices, loginSuccess, applyLanguagePreference, onAuthStateChange, setTokenReady, loadSessionsFromCore, activeSessionId, clearSessionState]);
-  const refreshSessions = (0, _react.useCallback)(async () => {
-    if (!identityCore || !isCoreInitialized || !activeSessionId) return;
-    try {
-      // Refresh current session
-      await identityCore.refreshSession();
-
-      // Reload sessions from core
-      await loadSessionsFromCore();
-    } catch (error) {
-      if ((0, _errorHandlers.isInvalidSessionError)(error)) {
-        await clearSessionState();
-      } else if (__DEV__) {
-        logger('Failed to refresh sessions', error);
-      }
-    }
-  }, [identityCore, isCoreInitialized, activeSessionId, loadSessionsFromCore, clearSessionState, logger]);
-
-  // Device management functions
-  const getDeviceSessions = (0, _react.useCallback)(async () => {
-    if (!activeSessionId) throw new Error('No active session');
-    return await oxyServices.getDeviceSessions(activeSessionId);
-  }, [activeSessionId, oxyServices]);
-  const logoutAllDeviceSessions = (0, _react.useCallback)(async () => {
-    if (!activeSessionId) throw new Error('No active session');
-    await oxyServices.logoutAllDeviceSessions(activeSessionId);
+    // Clear session state (sessions, activeSessionId, storage)
     await clearSessionState();
-  }, [activeSessionId, oxyServices, clearSessionState]);
-  const updateDeviceName = (0, _react.useCallback)(async deviceName => {
-    if (!identityCore || !isCoreInitialized || !activeSessionId) {
-      throw new Error('Identity core not initialized or no active session');
-    }
-    await oxyServices.updateDeviceName(activeSessionId, deviceName);
 
-    // Update device name in core
-    const deviceManager = identityCore.getDeviceManager();
-    await deviceManager.updateDeviceName(deviceName);
-  }, [identityCore, isCoreInitialized, activeSessionId, oxyServices]);
-  (0, _useTransferCodesPersistence.useTransferCodesPersistence)(storageKeyPrefix);
-  const clearAllAccountData = (0, _react.useCallback)(async () => {
-    if (__DEV__) logger('Clearing all account data - identity changed or lost');
-    queryClient.clear();
-    await clearSessionState();
+    // Clear identity sync state from storage
     if (storage) {
       try {
-        await (0, _queryClient.clearQueryCache)(storage);
         await storage.removeItem('oxy_identity_synced');
       } catch (error) {
-        logger('Failed to clear persisted data', error);
+        logger('Failed to clear identity sync state', error);
       }
     }
+
+    // Reset auth store identity sync state
     _authStore.useAuthStore.getState().setIdentitySynced(false);
     _authStore.useAuthStore.getState().setSyncing(false);
+
+    // Reset account store
     _accountStore.useAccountStore.getState().reset();
-    _transferStore.useTransferStore.getState().clearAll();
+
+    // Clear HTTP service cache
     oxyServices.clearCache();
-    identityCore?.getIdentityManager().invalidateCache();
-  }, [queryClient, storage, clearSessionState, logger, oxyServices, identityCore]);
+  }, [queryClient, storage, clearSessionState, logger, oxyServices]);
 
-  // Get transfer store functions (used in deleteIdentityAndClearAccount)
-  const getAllPendingTransfers = (0, _transferStore.useTransferStore)(state => state.getAllPendingTransfers);
-  const getActiveTransferId = (0, _transferStore.useTransferStore)(state => state.getActiveTransferId);
-  const getTransferCode = (0, _transferStore.useTransferStore)(state => state.getTransferCode);
+  // Transfer code management functions (must be defined before deleteIdentityAndClearAccount)
+  const getAllPendingTransfers = (0, _react.useCallback)(() => {
+    const pending = [];
+    transferCodesRef.current.forEach((data, transferId) => {
+      if (data.state === 'pending') {
+        pending.push({
+          transferId,
+          data
+        });
+      }
+    });
+    return pending;
+  }, []);
+  const getActiveTransferId = (0, _react.useCallback)(() => {
+    return activeTransferIdRef.current;
+  }, []);
 
   // Delete identity and clear all account data
   // In accounts app, deleting identity means losing the account completely
@@ -539,112 +337,636 @@ const OxyProvider = ({
     await clearAllAccountData();
 
     // Then delete the identity keys
-    if (identityCore) {
-      await identityCore.deleteIdentity(skipBackup, force, userConfirmed);
-    } else {
-      throw new Error('Identity core not initialized');
-    }
-  }, [clearAllAccountData, identityCore, getAllPendingTransfers, getActiveTransferId]);
+    await _crypto.KeyManager.deleteIdentity(skipBackup, force, userConfirmed);
+  }, [clearAllAccountData, getAllPendingTransfers, getActiveTransferId]);
+
+  // Network reconnect sync - TanStack Query automatically retries mutations on reconnect
+  // We only need to sync identity if it's not synced
+  (0, _react.useEffect)(() => {
+    if (!storage) return;
+    let wasOffline = false;
+    let checkTimeout = null;
+    let lastReconnectionLog = 0;
+    const RECONNECTION_LOG_DEBOUNCE_MS = 5000; // 5 seconds
+
+    // Circuit breaker and exponential backoff state
+    const stateRef = {
+      consecutiveFailures: 0,
+      currentInterval: 10000,
+      // Start with 10 seconds
+      baseInterval: 10000,
+      // Base interval in milliseconds
+      maxInterval: 60000,
+      // Maximum interval (60 seconds)
+      maxFailures: 5 // Circuit breaker threshold
+    };
+    const scheduleNextCheck = () => {
+      if (checkTimeout) {
+        clearTimeout(checkTimeout);
+      }
+      checkTimeout = setTimeout(() => {
+        checkNetworkAndSync();
+      }, stateRef.currentInterval);
+    };
+    const checkNetworkAndSync = async () => {
+      try {
+        // Try a lightweight health check to see if we're online
+        await oxyServices.healthCheck().catch(() => {
+          wasOffline = true;
+          throw new Error('Health check failed');
+        });
+
+        // Health check succeeded - reset circuit breaker and backoff
+        if (stateRef.consecutiveFailures > 0) {
+          stateRef.consecutiveFailures = 0;
+          stateRef.currentInterval = stateRef.baseInterval;
+        }
+
+        // If we were offline and now we're online, sync identity if needed
+        if (wasOffline) {
+          const now = Date.now();
+          const timeSinceLastLog = now - lastReconnectionLog;
+          if (timeSinceLastLog >= RECONNECTION_LOG_DEBOUNCE_MS) {
+            logger('Network reconnected, checking identity sync...');
+            lastReconnectionLog = now;
+
+            // Sync identity first (if not synced)
+            try {
+              const hasIdentityValue = await hasIdentity();
+              if (hasIdentityValue) {
+                // Check sync status directly - sync if not explicitly 'true'
+                // undefined = not synced yet, 'false' = explicitly not synced, 'true' = synced
+                const syncStatus = await storage.getItem('oxy_identity_synced');
+                if (syncStatus !== 'true') {
+                  await syncIdentity();
+                }
+              }
+            } catch (syncError) {
+              // Skip sync silently if username is required (expected when offline onboarding)
+              if (syncError?.code === 'USERNAME_REQUIRED' || syncError?.message === 'USERNAME_REQUIRED') {
+                if (__DEV__) {
+                  _loggerUtils.logger.debug('Sync skipped - username required', {
+                    component: 'OxyContext',
+                    method: 'checkNetworkAndSync'
+                  }, syncError);
+                }
+                // Don't log or show error - username will be set later
+              } else if (!(0, _errorHandlers.isTimeoutOrNetworkError)(syncError)) {
+                // Only log unexpected errors - timeouts/network issues are expected when offline
+                logger('Error syncing identity on reconnect', syncError);
+              } else if (__DEV__) {
+                _loggerUtils.logger.debug('Identity sync timeout (expected when offline)', {
+                  component: 'OxyContext',
+                  method: 'checkNetworkAndSync'
+                }, syncError);
+              }
+            }
+          }
+
+          // TanStack Query will automatically retry pending mutations
+          // Reset flag immediately after processing (whether logged or not)
+          wasOffline = false;
+        }
+      } catch (error) {
+        // Network check failed - we're offline
+        wasOffline = true;
+
+        // Increment failure count and apply exponential backoff
+        stateRef.consecutiveFailures++;
+
+        // Calculate new interval with exponential backoff, capped at maxInterval
+        const backoffMultiplier = Math.min(Math.pow(2, stateRef.consecutiveFailures - 1), stateRef.maxInterval / stateRef.baseInterval);
+        stateRef.currentInterval = Math.min(stateRef.baseInterval * backoffMultiplier, stateRef.maxInterval);
+
+        // If we hit the circuit breaker threshold, use max interval
+        if (stateRef.consecutiveFailures >= stateRef.maxFailures) {
+          stateRef.currentInterval = stateRef.maxInterval;
+        }
+      } finally {
+        // Always schedule next check (will use updated interval)
+        scheduleNextCheck();
+      }
+    };
+
+    // Check immediately
+    checkNetworkAndSync();
+    return () => {
+      if (checkTimeout) {
+        clearTimeout(checkTimeout);
+      }
+    };
+  }, [oxyServices, storage, syncIdentity, logger]);
+  const {
+    getDeviceSessions,
+    logoutAllDeviceSessions,
+    updateDeviceName
+  } = (0, _useDeviceManagement.useDeviceManagement)({
+    oxyServices,
+    activeSessionId,
+    onError,
+    clearSessionState,
+    logger
+  });
+  const useFollowHook = loadUseFollowHook();
   const restoreSessionsFromStorage = (0, _react.useCallback)(async () => {
-    if (!identityCore || !isCoreInitialized) return;
+    if (!storage) {
+      return;
+    }
     setTokenReady(false);
     try {
-      await loadSessionsFromCore();
-      const activeId = await identityCore.getActiveSessionId();
-      if (!activeId) {
-        setTokenReady(true);
-        return;
-      }
-      try {
-        await switchSession(activeId);
-      } catch (switchError) {
-        if ((0, _errorHandlers.isTimeoutOrNetworkError)(switchError)) {
+      const storedSessionIdsJson = await storage.getItem(storageKeys.sessionIds);
+      const storedSessionIds = storedSessionIdsJson ? JSON.parse(storedSessionIdsJson) : [];
+      const storedActiveSessionId = await storage.getItem(storageKeys.activeSessionId);
+      const validSessions = [];
+      if (storedSessionIds.length > 0) {
+        for (const sessionId of storedSessionIds) {
           try {
-            const validation = await oxyServices.validateSession(activeId, {
-              useHeaderValidation: false
+            const validation = await oxyServices.validateSession(sessionId, {
+              useHeaderValidation: true
             });
             if (validation?.valid && validation.user) {
-              loginSuccess(validation.user);
+              const now = new Date();
+              validSessions.push({
+                sessionId,
+                deviceId: '',
+                expiresAt: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+                lastActive: now.toISOString(),
+                userId: validation.user.id?.toString() ?? '',
+                isCurrent: sessionId === storedActiveSessionId
+              });
+            }
+          } catch (validationError) {
+            // Silently handle expected errors (invalid sessions, timeouts, network issues) during restoration
+            // Only log unexpected errors
+            if (!(0, _errorHandlers.isInvalidSessionError)(validationError) && !(0, _errorHandlers.isTimeoutOrNetworkError)(validationError)) {
+              logger('Session validation failed during init', validationError);
+            } else if (__DEV__ && (0, _errorHandlers.isTimeoutOrNetworkError)(validationError)) {
+              // Only log timeouts in dev mode for debugging
+              _loggerUtils.logger.debug('Session validation timeout (expected when offline)', {
+                component: 'OxyContext',
+                method: 'restoreSessionsFromStorage'
+              }, validationError);
             }
-          } catch {
-            // Offline - will sync when online
           }
-        } else if ((0, _errorHandlers.isInvalidSessionError)(switchError)) {
-          await identityCore.invalidateSession(activeId);
-          await loadSessionsFromCore();
+        }
+        if (validSessions.length > 0) {
+          updateSessions(validSessions, {
+            merge: false
+          });
+        }
+      }
+      if (storedActiveSessionId) {
+        try {
+          await switchSession(storedActiveSessionId);
+        } catch (switchError) {
+          // Silently handle expected errors (invalid sessions, timeouts, network issues)
+          if ((0, _errorHandlers.isInvalidSessionError)(switchError)) {
+            await storage.removeItem(storageKeys.activeSessionId);
+            updateSessions(validSessions.filter(session => session.sessionId !== storedActiveSessionId), {
+              merge: false
+            });
+            // Don't log expected session errors during restoration
+          } else if ((0, _errorHandlers.isTimeoutOrNetworkError)(switchError)) {
+            // Timeout/network error - non-critical, don't block
+            if (__DEV__) {
+              _loggerUtils.logger.debug('Active session validation timeout (expected when offline)', {
+                component: 'OxyContext',
+                method: 'restoreSessionsFromStorage'
+              }, switchError);
+            }
+          } else {
+            // Only log unexpected errors
+            logger('Active session validation error', switchError);
+          }
         }
       }
     } catch (error) {
-      if (__DEV__) logger('Failed to restore sessions from storage', error);
+      if (__DEV__) {
+        _loggerUtils.logger.error('Auth init error', error instanceof Error ? error : new Error(String(error)), {
+          component: 'OxyContext',
+          method: 'restoreSessionsFromStorage'
+        });
+      }
       await clearSessionState();
     } finally {
       setTokenReady(true);
     }
-  }, [identityCore, isCoreInitialized, loadSessionsFromCore, switchSession, loginSuccess, clearSessionState, oxyServices, logger]);
-
-  // Restore sessions when core is initialized
+  }, [clearSessionState, logger, oxyServices, storage, storageKeys.activeSessionId, storageKeys.sessionIds, switchSession, updateSessions]);
   (0, _react.useEffect)(() => {
-    if (isCoreInitialized) {
-      void restoreSessionsFromStorage();
+    if (!storage || initializedRef.current) {
+      return;
     }
-  }, [isCoreInitialized, restoreSessionsFromStorage]);
+    initializedRef.current = true;
+    void restoreSessionsFromStorage();
+  }, [restoreSessionsFromStorage, storage]);
   const activeSession = activeSessionId ? sessions.find(session => session.sessionId === activeSessionId) : undefined;
   const currentDeviceId = activeSession?.deviceId ?? null;
 
-  // Compute isAuthenticated from actual session state, not just auth store
-  // This ensures UI shows correct state even if loginSuccess wasn't called during restoration
-  const computedIsAuthenticated = (0, _react.useMemo)(() => {
-    return isAuthenticatedFromStore || !!(activeSessionId && sessions.length > 0 && user);
-  }, [isAuthenticatedFromStore, activeSessionId, sessions.length, user]);
-  const userId = oxyServices.getCurrentUserId() || user?.id;
-  (0, _useTransferQueries.useCheckPendingTransfers)(oxyServices, computedIsAuthenticated);
-  const {
-    handleIdentityTransferComplete
-  } = (0, _useIdentityTransfer.useIdentityTransfer)({
-    identityCore,
-    currentDeviceId,
-    activeSessionId,
-    getPublicKey,
-    deleteIdentityAndClearAccount,
-    logger
-  });
+  // Get userId from JWT token (MongoDB ObjectId) for socket room matching
+  const userId = oxyServices.getCurrentUserId();
+
+  // Transfer code storage interface
+
+  // Store transfer codes in memory for verification (also persisted to storage)
+  // Map: transferId -> TransferCodeData
+  const transferCodesRef = (0, _react.useRef)(new Map());
+  const activeTransferIdRef = (0, _react.useRef)(null);
+  const TRANSFER_CODES_STORAGE_KEY = `${storageKeyPrefix}_transfer_codes`;
+  const ACTIVE_TRANSFER_STORAGE_KEY = `${storageKeyPrefix}_active_transfer_id`;
+
+  // Load transfer codes from storage on startup
+  (0, _react.useEffect)(() => {
+    if (!storage || !isStorageReady) return;
+    const loadTransferCodes = async () => {
+      try {
+        // Load transfer codes
+        const storedCodes = await storage.getItem(TRANSFER_CODES_STORAGE_KEY);
+        if (storedCodes) {
+          const parsed = JSON.parse(storedCodes);
+          const now = Date.now();
+          const fifteenMinutes = 15 * 60 * 1000;
+
+          // Only restore non-expired pending transfers
+          Object.entries(parsed).forEach(([transferId, data]) => {
+            if (data.state === 'pending' && now - data.timestamp < fifteenMinutes) {
+              transferCodesRef.current.set(transferId, data);
+              if (__DEV__) {
+                logger('Restored pending transfer from storage', {
+                  transferId
+                });
+              }
+            }
+          });
+        }
+
+        // Load active transfer ID
+        const activeTransferId = await storage.getItem(ACTIVE_TRANSFER_STORAGE_KEY);
+        if (activeTransferId) {
+          // Verify it's still valid
+          const transferData = transferCodesRef.current.get(activeTransferId);
+          if (transferData && transferData.state === 'pending') {
+            activeTransferIdRef.current = activeTransferId;
+            if (__DEV__) {
+              logger('Restored active transfer ID from storage', {
+                transferId: activeTransferId
+              });
+            }
+          } else {
+            // Clear invalid active transfer
+            await storage.removeItem(ACTIVE_TRANSFER_STORAGE_KEY);
+          }
+        }
+      } catch (error) {
+        if (__DEV__) {
+          logger('Failed to load transfer codes from storage', error);
+        }
+      }
+    };
+    loadTransferCodes();
+  }, [storage, isStorageReady, logger, storageKeyPrefix]);
+
+  // Persist transfer codes to storage whenever they change
+  const persistTransferCodes = (0, _react.useCallback)(async () => {
+    if (!storage) return;
+    try {
+      const codesToStore = {};
+      transferCodesRef.current.forEach((value, key) => {
+        codesToStore[key] = value;
+      });
+      await storage.setItem(TRANSFER_CODES_STORAGE_KEY, JSON.stringify(codesToStore));
+    } catch (error) {
+      if (__DEV__) {
+        logger('Failed to persist transfer codes', error);
+      }
+    }
+  }, [storage, logger]);
+
+  // Cleanup old transfer codes (older than 15 minutes)
+  (0, _react.useEffect)(() => {
+    const cleanup = setInterval(async () => {
+      const now = Date.now();
+      const fifteenMinutes = 15 * 60 * 1000;
+      let needsPersist = false;
+      transferCodesRef.current.forEach((value, key) => {
+        if (now - value.timestamp > fifteenMinutes) {
+          transferCodesRef.current.delete(key);
+          needsPersist = true;
+          if (__DEV__) {
+            logger('Cleaned up expired transfer code', {
+              transferId: key
+            });
+          }
+        }
+      });
+
+      // Clear active transfer if it was deleted
+      if (activeTransferIdRef.current && !transferCodesRef.current.has(activeTransferIdRef.current)) {
+        activeTransferIdRef.current = null;
+        if (storage) {
+          try {
+            await storage.removeItem(ACTIVE_TRANSFER_STORAGE_KEY);
+          } catch (error) {
+            // Ignore storage errors
+          }
+        }
+      }
+      if (needsPersist) {
+        await persistTransferCodes();
+      }
+    }, 60000); // Check every minute
+
+    return () => clearInterval(cleanup);
+  }, [logger, persistTransferCodes, storage]);
+
+  // Transfer code management functions
+  const storeTransferCode = (0, _react.useCallback)(async (transferId, code, sourceDeviceId, publicKey) => {
+    const transferData = {
+      code,
+      sourceDeviceId,
+      publicKey,
+      timestamp: Date.now(),
+      state: 'pending'
+    };
+    transferCodesRef.current.set(transferId, transferData);
+    activeTransferIdRef.current = transferId;
+
+    // Persist to storage
+    await persistTransferCodes();
+    if (storage) {
+      try {
+        await storage.setItem(ACTIVE_TRANSFER_STORAGE_KEY, transferId);
+      } catch (error) {
+        if (__DEV__) {
+          logger('Failed to persist active transfer ID', error);
+        }
+      }
+    }
+    if (__DEV__) {
+      logger('Stored transfer code', {
+        transferId,
+        sourceDeviceId,
+        publicKey: publicKey.substring(0, 16) + '...'
+      });
+    }
+  }, [logger, persistTransferCodes, storage]);
+  const getTransferCode = (0, _react.useCallback)(transferId => {
+    return transferCodesRef.current.get(transferId) || null;
+  }, []);
+  const updateTransferState = (0, _react.useCallback)(async (transferId, state) => {
+    const transferData = transferCodesRef.current.get(transferId);
+    if (transferData) {
+      transferData.state = state;
+      transferCodesRef.current.set(transferId, transferData);
+
+      // Clear active transfer if completed or failed
+      if (state === 'completed' || state === 'failed') {
+        if (activeTransferIdRef.current === transferId) {
+          activeTransferIdRef.current = null;
+          if (storage) {
+            try {
+              await storage.removeItem(ACTIVE_TRANSFER_STORAGE_KEY);
+            } catch (error) {
+              // Ignore storage errors
+            }
+          }
+        }
+      }
+      await persistTransferCodes();
+      if (__DEV__) {
+        logger('Updated transfer state', {
+          transferId,
+          state
+        });
+      }
+    }
+  }, [logger, persistTransferCodes, storage]);
+  const clearTransferCode = (0, _react.useCallback)(async transferId => {
+    transferCodesRef.current.delete(transferId);
+    if (activeTransferIdRef.current === transferId) {
+      activeTransferIdRef.current = null;
+      if (storage) {
+        try {
+          await storage.removeItem(ACTIVE_TRANSFER_STORAGE_KEY);
+        } catch (error) {
+          // Ignore storage errors
+        }
+      }
+    }
+    await persistTransferCodes();
+    if (__DEV__) {
+      logger('Cleared transfer code', {
+        transferId
+      });
+    }
+  }, [logger, persistTransferCodes, storage]);
+  const refreshSessionsWithUser = (0, _react.useCallback)(() => refreshSessions(userId || undefined), [refreshSessions, userId]);
+  const handleSessionRemoved = (0, _react.useCallback)(sessionId => {
+    trackRemovedSession(sessionId);
+  }, [trackRemovedSession]);
+  const handleRemoteSignOut = (0, _react.useCallback)(() => {
+    _sonner.toast.info('You have been signed out remotely.');
+    logout().catch(remoteError => logger('Failed to process remote sign out', remoteError));
+  }, [logger, logout]);
+  const handleIdentityTransferComplete = (0, _react.useCallback)(async data => {
+    try {
+      logger('Received identity transfer complete notification', {
+        transferId: data.transferId,
+        sourceDeviceId: data.sourceDeviceId,
+        currentDeviceId,
+        hasActiveSession: activeSessionId !== null,
+        publicKey: data.publicKey.substring(0, 16) + '...'
+      });
+      const storedTransfer = getTransferCode(data.transferId);
+      if (!storedTransfer) {
+        logger('Transfer code not found for transferId', {
+          transferId: data.transferId
+        });
+        _sonner.toast.error('Transfer verification failed: Code not found. Identity will not be deleted.');
+        return;
+      }
+
+      // Verify publicKey matches first (most important check)
+      const publicKeyMatches = data.publicKey === storedTransfer.publicKey;
+      if (!publicKeyMatches) {
+        logger('Public key mismatch for transfer', {
+          transferId: data.transferId,
+          receivedPublicKey: data.publicKey.substring(0, 16) + '...',
+          storedPublicKey: storedTransfer.publicKey.substring(0, 16) + '...'
+        });
+        _sonner.toast.error('Transfer verification failed: Public key mismatch. Identity will not be deleted.');
+        return;
+      }
+
+      // Verify deviceId matches - very lenient since publicKey is the critical check
+      // If publicKey matches, we allow deletion even if deviceId doesn't match exactly
+      // This handles cases where deviceId might not be available or slightly different
+      const deviceIdMatches =
+      // Exact match
+      data.sourceDeviceId && data.sourceDeviceId === currentDeviceId ||
+      // Stored sourceDeviceId matches current deviceId
+      storedTransfer.sourceDeviceId && storedTransfer.sourceDeviceId === currentDeviceId;
+
+      // If publicKey matches, we're very lenient with deviceId - only warn but don't block
+      if (!deviceIdMatches && publicKeyMatches) {
+        logger('Device ID mismatch for transfer, but publicKey matches - proceeding with deletion', {
+          transferId: data.transferId,
+          receivedDeviceId: data.sourceDeviceId,
+          storedDeviceId: storedTransfer.sourceDeviceId,
+          currentDeviceId,
+          hasActiveSession: activeSessionId !== null
+        });
+        // Proceed with deletion - publicKey match is the critical verification
+      } else if (!deviceIdMatches && !publicKeyMatches) {
+        // Both don't match - this is suspicious, block deletion
+        logger('Device ID and publicKey mismatch for transfer', {
+          transferId: data.transferId,
+          receivedDeviceId: data.sourceDeviceId,
+          currentDeviceId
+        });
+        _sonner.toast.error('Transfer verification failed: Device and key mismatch. Identity will not be deleted.');
+        return;
+      }
+
+      // Verify transfer code matches (if provided)
+      // Transfer code is optional - if not provided, we still proceed if publicKey matches
+      if (data.transferCode) {
+        const codeMatches = data.transferCode.toUpperCase() === storedTransfer.code.toUpperCase();
+        if (!codeMatches) {
+          logger('Transfer code mismatch, but publicKey matches - proceeding with deletion', {
+            transferId: data.transferId,
+            receivedCode: data.transferCode,
+            storedCode: storedTransfer.code.substring(0, 2) + '****'
+          });
+          // Don't block - publicKey match is sufficient, code mismatch might be due to user error
+          // Log warning but proceed
+        }
+      }
+
+      // Check if transfer is too old (safety timeout - 10 minutes)
+      const transferAge = Date.now() - storedTransfer.timestamp;
+      const tenMinutes = 10 * 60 * 1000;
+      if (transferAge > tenMinutes) {
+        logger('Transfer confirmation received too late', {
+          transferId: data.transferId,
+          age: transferAge,
+          ageMinutes: Math.round(transferAge / 60000)
+        });
+        _sonner.toast.error('Transfer verification failed: Confirmation received too late. Identity will not be deleted.');
+        clearTransferCode(data.transferId);
+        return;
+      }
+
+      // NOTE: Target device verification already happened server-side when notifyTransferComplete was called
+      // The server verified that the target device is authenticated and has the matching public key
+      // Additional client-side verification is not necessary and would require source device authentication
+      // which may not be available. The existing checks (public key match, transfer code, device ID) are sufficient.
+
+      logger('All transfer verifications passed, deleting identity from source device', {
+        transferId: data.transferId,
+        sourceDeviceId: data.sourceDeviceId,
+        publicKey: data.publicKey.substring(0, 16) + '...'
+      });
+      try {
+        // Verify identity still exists before deletion (safety check)
+        const identityStillExists = await _crypto.KeyManager.hasIdentity();
+        if (!identityStillExists) {
+          logger('Identity already deleted - skipping deletion', {
+            transferId: data.transferId
+          });
+          await updateTransferState(data.transferId, 'completed');
+          await clearTransferCode(data.transferId);
+          return;
+        }
+        await deleteIdentityAndClearAccount(false, false, true);
+
+        // Verify identity was actually deleted
+        const identityDeleted = !(await _crypto.KeyManager.hasIdentity());
+        if (!identityDeleted) {
+          logger('Identity deletion failed - identity still exists', {
+            transferId: data.transferId
+          });
+          await updateTransferState(data.transferId, 'failed');
+          throw new Error('Identity deletion failed - identity still exists');
+        }
+        await updateTransferState(data.transferId, 'completed');
+        await clearTransferCode(data.transferId);
+        logger('Identity successfully deleted and transfer code cleared', {
+          transferId: data.transferId
+        });
+        _sonner.toast.success('Identity successfully transferred and removed from this device');
+      } catch (deleteError) {
+        logger('Error during identity deletion', deleteError);
+        await updateTransferState(data.transferId, 'failed');
+        throw deleteError;
+      }
+    } catch (error) {
+      logger('Failed to delete identity after transfer', error);
+      _sonner.toast.error(error?.message || 'Failed to remove identity from this device. Please try again manually from Security Settings.');
+    }
+  }, [deleteIdentityAndClearAccount, logger, getTransferCode, clearTransferCode, updateTransferState, currentDeviceId, activeSessionId, oxyServices]);
   (0, _useSessionSocket.useSessionSocket)({
     userId,
     activeSessionId,
     currentDeviceId,
-    refreshSessions,
+    refreshSessions: refreshSessionsWithUser,
     logout,
     clearSessionState,
     baseURL: oxyServices.getBaseURL(),
     getAccessToken: () => oxyServices.getAccessToken(),
     getTransferCode: getTransferCode,
-    onRemoteSignOut: () => {
-      _sonner.toast.info('You have been signed out remotely.');
-      logout().catch(err => logger('Failed to process remote sign out', err));
-    },
-    onSessionRemoved: sessionId => {
-      setSessions(prev => prev.filter(s => s.sessionId !== sessionId));
-      if (sessionId === activeSessionId) {
-        setActiveSessionId(null);
-      }
-    },
+    onRemoteSignOut: handleRemoteSignOut,
+    onSessionRemoved: handleSessionRemoved,
     onIdentityTransferComplete: handleIdentityTransferComplete
   });
-  const {
-    openAvatarPicker
-  } = (0, _useAvatarPicker.useAvatarPicker)({
-    oxyServices,
-    currentLanguage,
-    activeSessionId,
-    queryClient,
-    syncIdentity
-  });
+  const switchSessionForContext = (0, _react.useCallback)(async sessionId => {
+    await switchSession(sessionId);
+  }, [switchSession]);
+
+  // Create showBottomSheet function that uses the global function
+  const showBottomSheetForContext = (0, _react.useCallback)(screenOrConfig => {
+    (0, _bottomSheetManager.showBottomSheet)(screenOrConfig);
+  }, []);
+
+  // Create openAvatarPicker function
+  const openAvatarPicker = (0, _react.useCallback)(() => {
+    showBottomSheetForContext({
+      screen: 'FileManagement',
+      props: {
+        selectMode: true,
+        multiSelect: false,
+        disabledMimeTypes: ['video/', 'audio/', 'application/pdf'],
+        afterSelect: 'none',
+        // Don't navigate away - stay on current screen
+        onSelect: async file => {
+          if (!file.contentType.startsWith('image/')) {
+            _sonner.toast.error((0, _i18n.translate)(currentLanguage, 'editProfile.toasts.selectImage') || 'Please select an image file');
+            return;
+          }
+          try {
+            // Update file visibility to public for avatar
+            await (0, _avatarUtils.updateAvatarVisibility)(file.id, oxyServices, 'OxyContext');
+
+            // Update user profile (handles query invalidation and accountStore update)
+            await (0, _avatarUtils.updateProfileWithAvatar)({
+              avatar: file.id
+            }, oxyServices, activeSessionId, queryClient, {
+              syncIdentity,
+              deviceId: currentDeviceId || undefined
+            });
+            _sonner.toast.success((0, _i18n.translate)(currentLanguage, 'editProfile.toasts.avatarUpdated') || 'Avatar updated');
+          } catch (e) {
+            _sonner.toast.error(e.message || (0, _i18n.translate)(currentLanguage, 'editProfile.toasts.updateAvatarFailed') || 'Failed to update avatar');
+          }
+        }
+      }
+    });
+  }, [oxyServices, currentLanguage, showBottomSheetForContext, activeSessionId, queryClient, syncIdentity]);
   const contextValue = (0, _react.useMemo)(() => ({
     user,
     sessions,
     activeSessionId,
     currentDeviceId,
-    isAuthenticated: computedIsAuthenticated,
+    isAuthenticated,
     isLoading,
     isTokenReady: tokenReady,
     isStorageReady,
@@ -661,15 +983,21 @@ const OxyProvider = ({
     isIdentitySynced,
     syncIdentity,
     deleteIdentityAndClearAccount,
+    storeTransferCode,
+    getTransferCode,
+    clearTransferCode,
+    getAllPendingTransfers,
+    getActiveTransferId,
+    updateTransferState,
     identitySyncState: {
       isSynced: isIdentitySyncedStore ?? true,
       isSyncing: isSyncing ?? false
     },
     logout,
     logoutAll,
-    switchSession,
+    switchSession: switchSessionForContext,
     removeSession: logout,
-    refreshSessions,
+    refreshSessions: refreshSessionsWithUser,
     setLanguage,
     getDeviceSessions,
     logoutAllDeviceSessions,
@@ -677,9 +1005,10 @@ const OxyProvider = ({
     clearSessionState,
     clearAllAccountData,
     oxyServices,
-    showBottomSheet: _bottomSheetManager.showBottomSheet,
+    useFollow: useFollowHook,
+    showBottomSheet: showBottomSheetForContext,
     openAvatarPicker
-  }), [activeSessionId, currentDeviceId, createIdentity, importIdentity, signIn, hasIdentity, getPublicKey, isIdentitySynced, syncIdentity, deleteIdentityAndClearAccount, isIdentitySyncedStore, isSyncing, currentLanguage, currentLanguageMetadata, currentLanguageName, currentNativeLanguageName, error, getDeviceSessions, computedIsAuthenticated, isLoading, logout, logoutAll, logoutAllDeviceSessions, oxyServices, refreshSessions, sessions, setLanguage, switchSession, tokenReady, isStorageReady, updateDeviceName, clearAllAccountData, user, openAvatarPicker]);
+  }), [activeSessionId, currentDeviceId, createIdentity, importIdentity, signIn, hasIdentity, getPublicKey, isIdentitySynced, syncIdentity, deleteIdentityAndClearAccount, storeTransferCode, getTransferCode, clearTransferCode, getAllPendingTransfers, getActiveTransferId, updateTransferState, isIdentitySyncedStore, isSyncing, currentLanguage, currentLanguageMetadata, currentLanguageName, currentNativeLanguageName, error, getDeviceSessions, isAuthenticated, isLoading, logout, logoutAll, logoutAllDeviceSessions, oxyServices, refreshSessionsWithUser, sessions, setLanguage, switchSessionForContext, tokenReady, isStorageReady, updateDeviceName, clearAllAccountData, useFollowHook, user, showBottomSheetForContext, openAvatarPicker]);
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(OxyContext.Provider, {
     value: contextValue,
     children: children