@oxyhq/services 5.17.5 → 5.17.8

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

@@ -1,7 +1,6 @@
 "use strict";
 
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { Platform } from 'react-native';
 import { OxyServices } from '../../core';
 import { toast } from '../../lib/sonner';
 import { useAuthStore } from '../stores/authStore';
@@ -18,7 +17,6 @@ import { showBottomSheet as globalShowBottomSheet } from '../navigation/bottomSh
 import { useQueryClient, useQuery } from '@tanstack/react-query';
 import { clearQueryCache } from '../hooks/queryClient';
 import { queryKeys } from '../hooks/queries/queryKeys';
-import { KeyManager } from '../../crypto';
 import { translate } from '../../i18n';
 import { updateAvatarVisibility, updateProfileWithAvatar } from '../utils/avatarUtils';
 import { useAccountStore } from '../stores/accountStore';
@@ -83,24 +81,14 @@ export const OxyProvider = ({
     error,
     loginSuccess,
     loginFailure,
-    logoutStore,
-    // Identity sync state and actions
-    isIdentitySyncedStore,
-    isSyncing,
-    setIdentitySynced,
-    setSyncing
+    logoutStore
   } = useAuthStore(useShallow(state => ({
     isAuthenticated: state.isAuthenticated,
     isLoading: state.isLoading,
     error: state.error,
     loginSuccess: state.loginSuccess,
     loginFailure: state.loginFailure,
-    logoutStore: state.logout,
-    // Identity sync state and actions
-    isIdentitySyncedStore: state.isIdentitySynced,
-    isSyncing: state.isSyncing,
-    setIdentitySynced: state.setIdentitySynced,
-    setSyncing: state.setSyncing
+    logoutStore: state.logout
   })));
   const [tokenReady, setTokenReady] = useState(true);
   const initializedRef = useRef(false);
@@ -123,45 +111,6 @@ export const OxyProvider = ({
     logger
   });
 
-  // Identity integrity check and auto-restore on startup
-  // Skip on web platform - identity storage is only available on native platforms
-  useEffect(() => {
-    if (!storage || !isStorageReady) return;
-    if (Platform.OS === 'web') return; // Identity operations are native-only
-
-    const checkAndRestoreIdentity = async () => {
-      try {
-        // Check if identity exists and verify integrity
-        const hasIdentity = await KeyManager.hasIdentity();
-        if (hasIdentity) {
-          const isValid = await KeyManager.verifyIdentityIntegrity();
-          if (!isValid) {
-            // Try to restore from backup
-            const restored = await 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 KeyManager.backupIdentity();
-          }
-        } else {
-          // No identity - try to restore from backup
-          const restored = await KeyManager.restoreIdentityFromBackup();
-          if (restored && __DEV__) {
-            logger('Identity restored from backup on startup');
-          }
-        }
-      } catch (error) {
-        if (__DEV__) {
-          logger('Error during identity integrity check', error);
-        }
-        // Don't block app startup - user can recover with backup file
-      }
-    };
-    checkAndRestoreIdentity();
-  }, [storage, isStorageReady, logger]);
-
   // Offline queuing is now handled by TanStack Query mutations
   // No need for custom offline queue
 
@@ -229,15 +178,9 @@ export const OxyProvider = ({
   });
   const user = userData ?? null;
   const {
-    createIdentity,
-    importIdentity: importIdentityBase,
     signIn,
     logout,
-    logoutAll,
-    hasIdentity,
-    getPublicKey,
-    isIdentitySynced,
-    syncIdentity: syncIdentityBase
+    logoutAll
   } = useAuthOperations({
     oxyServices,
     storage,
@@ -255,29 +198,10 @@ export const OxyProvider = ({
     loginFailure,
     logoutStore,
     setAuthState,
-    setIdentitySynced,
-    setSyncing,
     logger
   });
 
-  // syncIdentity - TanStack Query handles offline mutations automatically
-  const syncIdentity = useCallback(() => syncIdentityBase(), [syncIdentityBase]);
-
-  // Wrapper for importIdentity to handle legacy calls gracefully
-  const importIdentity = useCallback(async (backupData, password) => {
-    // 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.');
-    }
-
-    // Validate that password is provided
-    if (!password || typeof password !== 'string') {
-      throw new Error('Password is required for backup file import.');
-    }
-    return importIdentityBase(backupData, password);
-  }, [importIdentityBase]);
-
-  // Clear all account data when identity is lost (for accounts app)
+  // Clear all account data when logging out (for accounts app)
   // In accounts app, identity = account, so losing identity means losing everything
   const clearAllAccountData = useCallback(async () => {
     // Clear TanStack Query cache (in-memory)
@@ -295,19 +219,6 @@ export const OxyProvider = ({
     // Clear session state (sessions, activeSessionId, storage)
     await clearSessionState();
 
-    // Clear identity sync state from storage
-    if (storage) {
-      try {
-        await storage.removeItem('oxy_identity_synced');
-      } catch (error) {
-        logger('Failed to clear identity sync state', error);
-      }
-    }
-
-    // Reset auth store identity sync state
-    useAuthStore.getState().setIdentitySynced(false);
-    useAuthStore.getState().setSyncing(false);
-
     // Reset account store
     useAccountStore.getState().reset();
 
@@ -315,162 +226,50 @@ export const OxyProvider = ({
     oxyServices.clearCache();
   }, [queryClient, storage, clearSessionState, logger, oxyServices]);
 
-  // Transfer code management functions (must be defined before deleteIdentityAndClearAccount)
-  const getAllPendingTransfers = useCallback(() => {
-    const pending = [];
-    transferCodesRef.current.forEach((data, transferId) => {
-      if (data.state === 'pending') {
-        pending.push({
-          transferId,
-          data
-        });
-      }
-    });
-    return pending;
-  }, []);
-  const getActiveTransferId = useCallback(() => {
-    return activeTransferIdRef.current;
-  }, []);
-
-  // Delete identity and clear all account data
-  // In accounts app, deleting identity means losing the account completely
-  const deleteIdentityAndClearAccount = useCallback(async (skipBackup = false, force = false, userConfirmed = false) => {
-    // CRITICAL: Check for active transfers before deletion (unless force is true)
-    // This prevents accidental identity loss during transfer
-    if (!force) {
-      const pendingTransfers = getAllPendingTransfers();
-      if (pendingTransfers.length > 0) {
-        const activeTransferId = getActiveTransferId();
-        const hasActiveTransfer = activeTransferId && pendingTransfers.some(t => t.transferId === activeTransferId);
-        if (hasActiveTransfer) {
-          throw new Error('Cannot delete identity: An active identity transfer is in progress. ' + 'Please wait for the transfer to complete or cancel it first. ' + 'If you proceed, you may lose access to your identity permanently.');
-        }
-      }
-    }
-
-    // First, clear all account data
-    await clearAllAccountData();
-
-    // Then delete the identity keys
-    await 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
+  // Network reconnect - TanStack Query automatically retries mutations on reconnect
+  // Network reconnect - TanStack Query automatically retries mutations on reconnect
   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);
+        checkNetworkStatus();
+      }, 30000); // Check every 30 seconds
     };
-    const checkNetworkAndSync = async () => {
+    const checkNetworkStatus = 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;
-        }
+        await oxyServices.healthCheck();
 
-        // If we were offline and now we're online, sync identity if needed
+        // If we were offline and now we're online
         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__) {
-                  loggerUtil.debug('Sync skipped - username required', {
-                    component: 'OxyContext',
-                    method: 'checkNetworkAndSync'
-                  }, syncError);
-                }
-                // Don't log or show error - username will be set later
-              } else if (!isTimeoutOrNetworkError(syncError)) {
-                // Only log unexpected errors - timeouts/network issues are expected when offline
-                logger('Error syncing identity on reconnect', syncError);
-              } else if (__DEV__) {
-                loggerUtil.debug('Identity sync timeout (expected when offline)', {
-                  component: 'OxyContext',
-                  method: 'checkNetworkAndSync'
-                }, syncError);
-              }
-            }
-          }
-
+          logger('Network reconnected');
           // 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;
+        if (!wasOffline && __DEV__) {
+          logger('Network appears offline');
         }
+        wasOffline = true;
       } finally {
-        // Always schedule next check (will use updated interval)
         scheduleNextCheck();
       }
     };
 
     // Check immediately
-    checkNetworkAndSync();
+    checkNetworkStatus();
     return () => {
       if (checkTimeout) {
         clearTimeout(checkTimeout);
       }
     };
-  }, [oxyServices, storage, syncIdentity, logger]);
+  }, [oxyServices, storage, logger]);
   const {
     getDeviceSessions,
     logoutAllDeviceSessions,
@@ -579,171 +378,6 @@ export const OxyProvider = ({
 
   // 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 = useRef(new Map());
-  const activeTransferIdRef = useRef(null);
-  const TRANSFER_CODES_STORAGE_KEY = `${storageKeyPrefix}_transfer_codes`;
-  const ACTIVE_TRANSFER_STORAGE_KEY = `${storageKeyPrefix}_active_transfer_id`;
-
-  // Clear stale transfer codes on startup
-  // Transfers are ephemeral and should not persist across app restarts
-  useEffect(() => {
-    if (!storage || !isStorageReady) return;
-    const clearStaleTransfers = async () => {
-      try {
-        // Clear any stored transfer codes - they're only valid during active transfer sessions
-        await storage.removeItem(TRANSFER_CODES_STORAGE_KEY);
-        await storage.removeItem(ACTIVE_TRANSFER_STORAGE_KEY);
-        if (__DEV__) {
-          logger('Cleared stale transfer codes on startup');
-        }
-      } catch (error) {
-        if (__DEV__) {
-          logger('Failed to clear stale transfer codes', error);
-        }
-      }
-    };
-    clearStaleTransfers();
-  }, [storage, isStorageReady, logger, storageKeyPrefix]);
-
-  // Persist transfer codes to storage whenever they change
-  const persistTransferCodes = 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)
-  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 = 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 = useCallback(transferId => {
-    return transferCodesRef.current.get(transferId) || null;
-  }, []);
-  const updateTransferState = 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 = 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 = useCallback(() => refreshSessions(userId || undefined), [refreshSessions, userId]);
   const handleSessionRemoved = useCallback(sessionId => {
     trackRemovedSession(sessionId);
@@ -752,143 +386,6 @@ export const OxyProvider = ({
     toast.info('You have been signed out remotely.');
     logout().catch(remoteError => logger('Failed to process remote sign out', remoteError));
   }, [logger, logout]);
-  const handleIdentityTransferComplete = 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
-        });
-        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) + '...'
-        });
-        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
-        });
-        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)
-        });
-        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 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 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
-        });
-        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);
-      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]);
   useSessionSocket({
     userId,
     activeSessionId,
@@ -898,10 +395,8 @@ export const OxyProvider = ({
     clearSessionState,
     baseURL: oxyServices.getBaseURL(),
     getAccessToken: () => oxyServices.getAccessToken(),
-    getTransferCode: getTransferCode,
     onRemoteSignOut: handleRemoteSignOut,
-    onSessionRemoved: handleSessionRemoved,
-    onIdentityTransferComplete: handleIdentityTransferComplete
+    onSessionRemoved: handleSessionRemoved
   });
   const switchSessionForContext = useCallback(async sessionId => {
     await switchSession(sessionId);
@@ -935,7 +430,6 @@ export const OxyProvider = ({
             await updateProfileWithAvatar({
               avatar: file.id
             }, oxyServices, activeSessionId, queryClient, {
-              syncIdentity,
               deviceId: currentDeviceId || undefined
             });
             toast.success(translate(currentLanguage, 'editProfile.toasts.avatarUpdated') || 'Avatar updated');
@@ -945,7 +439,7 @@ export const OxyProvider = ({
         }
       }
     });
-  }, [oxyServices, currentLanguage, showBottomSheetForContext, activeSessionId, queryClient, syncIdentity]);
+  }, [oxyServices, currentLanguage, showBottomSheetForContext, activeSessionId, queryClient]);
   const contextValue = useMemo(() => ({
     user,
     sessions,
@@ -960,24 +454,7 @@ export const OxyProvider = ({
     currentLanguageMetadata,
     currentLanguageName,
     currentNativeLanguageName,
-    createIdentity,
-    importIdentity,
     signIn,
-    hasIdentity,
-    getPublicKey,
-    isIdentitySynced,
-    syncIdentity,
-    deleteIdentityAndClearAccount,
-    storeTransferCode,
-    getTransferCode,
-    clearTransferCode,
-    getAllPendingTransfers,
-    getActiveTransferId,
-    updateTransferState,
-    identitySyncState: {
-      isSynced: isIdentitySyncedStore ?? true,
-      isSyncing: isSyncing ?? false
-    },
     logout,
     logoutAll,
     switchSession: switchSessionForContext,
@@ -993,7 +470,7 @@ export const OxyProvider = ({
     useFollow: useFollowHook,
     showBottomSheet: showBottomSheetForContext,
     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]);
+  }), [activeSessionId, currentDeviceId, signIn, 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__*/_jsx(OxyContext.Provider, {
     value: contextValue,
     children: children