@oxyhq/services 5.17.7 → 5.17.9

package/src/ui/context/OxyContext.tsx

@@ -27,7 +27,7 @@ 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, type BackupData } from '../../crypto';
+import type { BackupData } from '../../crypto';
 import { translate } from '../../i18n';
 import { updateAvatarVisibility, updateProfileWithAvatar } from '../utils/avatarUtils';
 import { useAccountStore } from '../stores/accountStore';
@@ -74,31 +74,6 @@ const loadUseFollowHook = (): UseFollowHook => {
   }
 };
 
-// Shared storage key for identity cache - used by accounts app for instant routing
-// Uses expo-secure-store for consistency with identity storage (KeyManager)
-const IDENTITY_CACHE_KEY = 'oxy_identity_exists_cache';
-
-// Helper to update identity cache in SecureStore
-const updateIdentityCache = async (exists: boolean): Promise<void> => {
-  if (Platform.OS === 'web') return;
-  try {
-    const SecureStore = await import('expo-secure-store');
-    await SecureStore.setItemAsync(IDENTITY_CACHE_KEY, exists ? 'true' : 'false');
-  } catch {
-    // Silently fail - cache is just an optimization
-  }
-};
-
-const clearIdentityCache = async (): Promise<void> => {
-  if (Platform.OS === 'web') return;
-  try {
-    const SecureStore = await import('expo-secure-store');
-    await SecureStore.deleteItemAsync(IDENTITY_CACHE_KEY);
-  } catch {
-    // Silently fail
-  }
-};
-
 export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   children,
   oxyServices: providedOxyServices,
@@ -123,29 +98,23 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
   const {
     isAuthenticated,
+    isOnline,
     isLoading,
     error,
+    setOnline,
     loginSuccess,
     loginFailure,
     logoutStore,
-    // Identity sync state and actions
-    isIdentitySyncedStore,
-    isSyncing,
-    setIdentitySynced,
-    setSyncing,
   } = useAuthStore(
     useShallow((state: AuthState) => ({
       isAuthenticated: state.isAuthenticated,
+      isOnline: state.isOnline,
       isLoading: state.isLoading,
       error: state.error,
+      setOnline: state.setOnline,
       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,
     })),
   );
 
@@ -167,52 +136,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
   const { storage, isReady: isStorageReady } = useStorage({ onError, 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
-
   const {
     currentLanguage,
     metadata: currentLanguageMetadata,
@@ -274,15 +197,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   const user = userData ?? null;
 
   const {
-    createIdentity,
-    importIdentity: importIdentityBase,
-    signIn,
+    completeSignIn,
     logout,
     logoutAll,
-    hasIdentity,
-    getPublicKey,
-    isIdentitySynced,
-    syncIdentity: syncIdentityBase,
   } = useAuthOperations({
     oxyServices,
     storage,
@@ -300,48 +217,10 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     loginFailure,
     logoutStore,
     setAuthState,
-    setIdentitySynced,
-    setSyncing,
     logger,
   });
 
-  // syncIdentity - TanStack Query handles offline mutations automatically
-  const syncIdentity = useCallback(() => syncIdentityBase(), [syncIdentityBase]);
-
-  // Wrapper for createIdentity to update identity cache
-  const wrappedCreateIdentity = useCallback(
-    async (): Promise<{ synced: boolean }> => {
-      const result = await createIdentity();
-      // Update cache for instant routing on next app launch
-      updateIdentityCache(true);
-      return result;
-    },
-    [createIdentity]
-  );
-
-  // Wrapper for importIdentity to handle legacy calls and update cache
-  const importIdentity = useCallback(
-    async (backupData: BackupData | string, password?: string): Promise<{ synced: boolean }> => {
-      // 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.');
-      }
-
-      const result = await importIdentityBase(backupData, password);
-      // Update cache for instant routing on next app launch
-      updateIdentityCache(true);
-      return result;
-    },
-    [importIdentityBase]
-  );
-
-  // Clear all account data when identity is lost (for accounts app)
-  // In accounts app, identity = account, so losing identity means losing everything
+  // Clear all cached data and storage on logout
   const clearAllAccountData = useCallback(async (): Promise<void> => {
     // Clear TanStack Query cache (in-memory)
     queryClient.clear();
@@ -358,19 +237,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     // 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();
 
@@ -378,174 +244,63 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     oxyServices.clearCache();
   }, [queryClient, storage, clearSessionState, logger, oxyServices]);
 
-  // Transfer code management functions (must be defined before deleteIdentityAndClearAccount)
-  const getAllPendingTransfers = useCallback(() => {
-    const pending: Array<{ transferId: string; data: TransferCodeData }> = [];
-    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: boolean = false,
-    force: boolean = false,
-    userConfirmed: boolean = false
-  ): Promise<void> => {
-    // 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);
-
-    // Clear identity cache for instant routing on next app launch
-    clearIdentityCache();
-  }, [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 state monitoring - updates authStore.isOnline
+  // When offline: isAuthenticated becomes false automatically
+  // When reconnect: isOnline set to true, allowing re-authentication
   useEffect(() => {
     if (!storage) return;
 
     let wasOffline = false;
     let checkTimeout: NodeJS.Timeout | null = 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');
-        });
+        await oxyServices.healthCheck();
 
-        // 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 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: any) {
-              // 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 as unknown);
-                }
-                // 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 as unknown);
-              }
-            }
-          }
-
+          logger('Network reconnected - setting online state');
+          setOnline(true);
           // TanStack Query will automatically retry pending mutations
-          // Reset flag immediately after processing (whether logged or not)
+          // Session management will handle token refresh if needed
           wasOffline = false;
+        } else {
+          // We're online and were already online
+          setOnline(true);
         }
       } 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) {
+          if (__DEV__) {
+            logger('Network appears offline - suspending authentication');
+          }
+          setOnline(false); // This will set isAuthenticated to false
         }
+        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, setOnline]);
 
   const { getDeviceSessions, logoutAllDeviceSessions, updateDeviceName } = useDeviceManagement({
     oxyServices,
@@ -662,183 +417,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   // Get userId from JWT token (MongoDB ObjectId) for socket room matching
   const userId = oxyServices.getCurrentUserId();
 
-  // Transfer code storage interface
-  interface TransferCodeData {
-    code: string;
-    sourceDeviceId: string | null;
-    publicKey: string;
-    timestamp: number;
-    state: 'pending' | 'completed' | 'failed';
-  }
-
-  // Store transfer codes in memory for verification (also persisted to storage)
-  // Map: transferId -> TransferCodeData
-  const transferCodesRef = useRef<Map<string, TransferCodeData>>(new Map());
-  const activeTransferIdRef = useRef<string | null>(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: Record<string, TransferCodeData> = {};
-      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: string, code: string, sourceDeviceId: string | null, publicKey: string) => {
-    const transferData: TransferCodeData = {
-      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: string) => {
-    return transferCodesRef.current.get(transferId) || null;
-  }, []);
-
-  const updateTransferState = useCallback(async (transferId: string, state: 'pending' | 'completed' | 'failed') => {
-    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: string) => {
-    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],
@@ -856,154 +434,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     logout().catch((remoteError) => logger('Failed to process remote sign out', remoteError));
   }, [logger, logout]);
 
-  const handleIdentityTransferComplete = useCallback(
-    async (data: { transferId: string; sourceDeviceId: string; publicKey: string; transferCode?: string; completedAt: string }) => {
-      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: any) {
-          logger('Error during identity deletion', deleteError);
-          await updateTransferState(data.transferId, 'failed');
-          throw deleteError;
-        }
-      } catch (error: any) {
-        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,
@@ -1013,10 +443,8 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     clearSessionState,
     baseURL: oxyServices.getBaseURL(),
     getAccessToken: () => oxyServices.getAccessToken(),
-    getTransferCode: getTransferCode,
     onRemoteSignOut: handleRemoteSignOut,
     onSessionRemoved: handleSessionRemoved,
-    onIdentityTransferComplete: handleIdentityTransferComplete,
   });
 
   const switchSessionForContext = useCallback(
@@ -1058,7 +486,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
               oxyServices,
               activeSessionId,
               queryClient,
-              { syncIdentity, deviceId: currentDeviceId || undefined }
+              { deviceId: currentDeviceId || undefined }
             );
 
             toast.success(translate(currentLanguage, 'editProfile.toasts.avatarUpdated') || 'Avatar updated');
@@ -1068,7 +496,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         },
       },
     });
-  }, [oxyServices, currentLanguage, showBottomSheetForContext, activeSessionId, queryClient, syncIdentity]);
+  }, [oxyServices, currentLanguage, showBottomSheetForContext, activeSessionId, queryClient]);
 
   const contextValue: OxyContextState = useMemo(() => ({
     user,
@@ -1084,24 +512,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     currentLanguageMetadata,
     currentLanguageName,
     currentNativeLanguageName,
-    createIdentity: wrappedCreateIdentity,
-    importIdentity,
-    signIn,
-    hasIdentity,
-    getPublicKey,
-    isIdentitySynced,
-    syncIdentity,
-    deleteIdentityAndClearAccount,
-    storeTransferCode,
-    getTransferCode,
-    clearTransferCode,
-    getAllPendingTransfers,
-    getActiveTransferId,
-    updateTransferState,
-    identitySyncState: {
-      isSynced: isIdentitySyncedStore ?? true,
-      isSyncing: isSyncing ?? false,
-    },
+    completeSignIn,
     logout,
     logoutAll,
     switchSession: switchSessionForContext,
@@ -1120,22 +531,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   }), [
     activeSessionId,
     currentDeviceId,
-    wrappedCreateIdentity,
-    importIdentity,
-    signIn,
-    hasIdentity,
-    getPublicKey,
-    isIdentitySynced,
-    syncIdentity,
-    deleteIdentityAndClearAccount,
-    storeTransferCode,
-    getTransferCode,
-    clearTransferCode,
-    getAllPendingTransfers,
-    getActiveTransferId,
-    updateTransferState,
-    isIdentitySyncedStore,
-    isSyncing,
+    completeSignIn,
     currentLanguage,
     currentLanguageMetadata,
     currentLanguageName,