@oxyhq/services 5.16.25 → 5.16.27

package/src/ui/context/OxyContext.tsx

@@ -34,6 +34,8 @@ import { translate } from '../../i18n';
 import { updateAvatarVisibility, updateProfileWithAvatar } from '../utils/avatarUtils';
 import { useAccountStore } from '../stores/accountStore';
 import { logger as loggerUtil } from '../../utils/loggerUtils';
+import { useTransferStore, useTransferCodesForPersistence } from '../stores/transferStore';
+import { useCheckPendingTransfers } from '../hooks/useTransferQueries';
 
 export interface OxyContextState {
   user: User | null;
@@ -59,9 +61,12 @@ export interface OxyContextState {
   isIdentitySynced: () => Promise<boolean>;
   syncIdentity: () => Promise<User>;
   deleteIdentityAndClearAccount: (skipBackup?: boolean, force?: boolean, userConfirmed?: boolean) => Promise<void>;
-  storeTransferCode: (transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => void;
-  getTransferCode: (transferId: string) => { code: string; sourceDeviceId: string | null; publicKey: string; timestamp: number } | null;
-  clearTransferCode: (transferId: string) => void;
+  storeTransferCode: (transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => Promise<void>;
+  getTransferCode: (transferId: string) => { code: string; sourceDeviceId: string | null; publicKey: string; timestamp: number; state: 'pending' | 'completed' | 'failed' } | null;
+  clearTransferCode: (transferId: string) => Promise<void>;
+  getAllPendingTransfers: () => Array<{ transferId: string; data: { code: string; sourceDeviceId: string | null; publicKey: string; timestamp: number; state: 'pending' | 'completed' | 'failed' } }>;
+  getActiveTransferId: () => string | null;
+  updateTransferState: (transferId: string, state: 'pending' | 'completed' | 'failed') => Promise<void>;
 
   // Identity sync state (reactive, from Zustand store)
   identitySyncState: {
@@ -384,6 +389,23 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     oxyServices.clearCache();
   }, [queryClient, storage, clearSessionState, logger, oxyServices]);
 
+  // Extract Zustand store functions early (before they're used in callbacks)
+  const getAllPendingTransfersStore = useTransferStore((state) => state.getAllPendingTransfers);
+  const getActiveTransferIdStore = useTransferStore((state) => state.getActiveTransferId);
+  const storeTransferCodeStore = useTransferStore((state) => state.storeTransferCode);
+  const getTransferCodeStore = useTransferStore((state) => state.getTransferCode);
+  const updateTransferStateStore = useTransferStore((state) => state.updateTransferState);
+  const clearTransferCodeStore = useTransferStore((state) => state.clearTransferCode);
+
+  // Transfer code management functions (must be defined before deleteIdentityAndClearAccount)
+  const getAllPendingTransfers = useCallback(() => {
+    return getAllPendingTransfersStore();
+  }, [getAllPendingTransfersStore]);
+
+  const getActiveTransferId = useCallback(() => {
+    return getActiveTransferIdStore();
+  }, [getActiveTransferIdStore]);
+
   // Delete identity and clear all account data
   // In accounts app, deleting identity means losing the account completely
   const deleteIdentityAndClearAccount = useCallback(async (
@@ -391,12 +413,30 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     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: { transferId: string; data: any }) => 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]);
+  }, [clearAllAccountData, getAllPendingTransfers, getActiveTransferId]);
 
   // Network reconnect sync - TanStack Query automatically retries mutations on reconnect
   // We only need to sync identity if it's not synced
@@ -474,6 +514,10 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
                 loggerUtil.debug('Identity sync timeout (expected when offline)', { component: 'OxyContext', method: 'checkNetworkAndSync' }, syncError as unknown);
               }
             }
+
+            // Check for pending transfers that may have completed while offline
+            // This is handled by useCheckPendingTransfers hook which runs automatically
+            // when authenticated and online
           }
           
           // TanStack Query will automatically retry pending mutations
@@ -515,7 +559,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         clearTimeout(checkTimeout);
       }
     };
-  }, [oxyServices, storage, syncIdentity, logger]);
+  }, [oxyServices, storage, syncIdentity, logger, hasIdentity, isAuthenticated]);
 
   const { getDeviceSessions, logoutAllDeviceSessions, updateDeviceName } = useDeviceManagement({
     oxyServices,
@@ -634,51 +678,110 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   // The JWT token's userId field contains the MongoDB ObjectId
   const userId = oxyServices.getCurrentUserId() || user?.id;
 
-  // Store transfer codes in memory for verification
-  // Map: transferId -> { code, sourceDeviceId, publicKey, timestamp }
-  const transferCodesRef = useRef<Map<string, { code: string; sourceDeviceId: string | null; publicKey: string; timestamp: number }>>(new Map());
+  // Use Zustand store for transfer state management
+  const TRANSFER_CODES_STORAGE_KEY = `${storageKeyPrefix}_transfer_codes`;
+  const ACTIVE_TRANSFER_STORAGE_KEY = `${storageKeyPrefix}_active_transfer_id`;
+  const isRestored = useTransferStore((state) => state.isRestored);
+  const restoreFromStorage = useTransferStore((state) => state.restoreFromStorage);
+  const markRestored = useTransferStore((state) => state.markRestored);
+  const cleanupExpired = useTransferStore((state) => state.cleanupExpired);
 
-  // Cleanup old transfer codes (older than 15 minutes)
+  // Load transfer codes from storage on startup (only once)
   useEffect(() => {
-    const cleanup = setInterval(() => {
-      const now = Date.now();
-      const fifteenMinutes = 15 * 60 * 1000;
-      transferCodesRef.current.forEach((value, key) => {
-        if (now - value.timestamp > fifteenMinutes) {
-          transferCodesRef.current.delete(key);
-          if (__DEV__) {
-            logger('Cleaned up expired transfer code', { transferId: key });
-          }
+    if (!storage || !isStorageReady || isRestored) return;
+
+    const loadTransferCodes = async () => {
+      try {
+        // Load transfer codes
+        const storedCodes = await storage.getItem(TRANSFER_CODES_STORAGE_KEY);
+        const storedActiveTransferId = await storage.getItem(ACTIVE_TRANSFER_STORAGE_KEY);
+        
+        const parsedCodes = storedCodes ? JSON.parse(storedCodes) : {};
+        const activeTransferId = storedActiveTransferId || null;
+        
+        // Restore to Zustand store (store handles validation and expiration)
+        restoreFromStorage(parsedCodes, activeTransferId);
+        markRestored();
+        
+        if (__DEV__ && Object.keys(parsedCodes).length > 0) {
+          logger('Restored transfer codes from storage', { 
+            count: Object.keys(parsedCodes).length,
+            hasActiveTransfer: !!activeTransferId,
+          });
         }
-      });
+      } catch (error) {
+        if (__DEV__) {
+          logger('Failed to load transfer codes from storage', error);
+        }
+        // Mark as restored even on error to prevent retries
+        markRestored();
+      }
+    };
+
+    loadTransferCodes();
+  }, [storage, isStorageReady, isRestored, restoreFromStorage, markRestored, logger, storageKeyPrefix]);
+
+  // Persist transfer codes to storage whenever store changes
+  const { transferCodes, activeTransferId } = useTransferCodesForPersistence();
+  useEffect(() => {
+    if (!storage || !isStorageReady || !isRestored) return;
+
+    const persistTransferCodes = async () => {
+      try {
+        await storage.setItem(TRANSFER_CODES_STORAGE_KEY, JSON.stringify(transferCodes));
+        
+        if (activeTransferId) {
+          await storage.setItem(ACTIVE_TRANSFER_STORAGE_KEY, activeTransferId);
+        } else {
+          await storage.removeItem(ACTIVE_TRANSFER_STORAGE_KEY);
+        }
+      } catch (error) {
+        if (__DEV__) {
+          logger('Failed to persist transfer codes', error);
+        }
+      }
+    };
+
+    persistTransferCodes();
+  }, [transferCodes, activeTransferId, storage, isStorageReady, isRestored, logger]);
+
+  // Cleanup expired transfer codes (every minute)
+  useEffect(() => {
+    const cleanup = setInterval(() => {
+      cleanupExpired();
     }, 60000); // Check every minute
 
     return () => clearInterval(cleanup);
-  }, [logger]);
-
-  // Transfer code management functions
-  const storeTransferCode = useCallback((transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => {
-    transferCodesRef.current.set(transferId, {
-      code,
-      sourceDeviceId,
-      publicKey,
-      timestamp: Date.now(),
-    });
+  }, [cleanupExpired]);
+
+  // Transfer code management functions using Zustand store
+  const storeTransferCode = useCallback(async (transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => {
+    storeTransferCodeStore(transferId, code, sourceDeviceId, publicKey);
+    
     if (__DEV__) {
       logger('Stored transfer code', { transferId, sourceDeviceId, publicKey: publicKey.substring(0, 16) + '...' });
     }
-  }, [logger]);
+  }, [logger, storeTransferCodeStore]);
 
   const getTransferCode = useCallback((transferId: string) => {
-    return transferCodesRef.current.get(transferId) || null;
-  }, []);
+    return getTransferCodeStore(transferId);
+  }, [getTransferCodeStore]);
+
+  const updateTransferState = useCallback(async (transferId: string, state: 'pending' | 'completed' | 'failed') => {
+    updateTransferStateStore(transferId, state);
+    
+    if (__DEV__) {
+      logger('Updated transfer state', { transferId, state });
+    }
+  }, [logger, updateTransferStateStore]);
 
-  const clearTransferCode = useCallback((transferId: string) => {
-    transferCodesRef.current.delete(transferId);
+  const clearTransferCode = useCallback(async (transferId: string) => {
+    clearTransferCodeStore(transferId);
+    
     if (__DEV__) {
       logger('Cleared transfer code', { transferId });
     }
-  }, [logger]);
+  }, [logger, clearTransferCodeStore]);
 
   const refreshSessionsWithUser = useCallback(
     () => refreshSessions(userId),
@@ -697,6 +800,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     logout().catch((remoteError) => logger('Failed to process remote sign out', remoteError));
   }, [logger, logout]);
 
+  // Check pending transfers when authenticated and online using TanStack Query
+  const { data: pendingTransferResults } = useCheckPendingTransfers();
+
   const handleIdentityTransferComplete = useCallback(
     async (data: { transferId: string; sourceDeviceId: string; publicKey: string; transferCode?: string; completedAt: string }) => {
       try {
@@ -789,6 +895,11 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
           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,
@@ -796,8 +907,31 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         });
 
         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);
-          clearTransferCode(data.transferId);
+          
+          // 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,
@@ -806,6 +940,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
           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) {
@@ -813,7 +948,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         toast.error(error?.message || 'Failed to remove identity from this device. Please try again manually from Security Settings.');
       }
     },
-    [deleteIdentityAndClearAccount, logger, getTransferCode, clearTransferCode, currentDeviceId, activeSessionId],
+    [deleteIdentityAndClearAccount, logger, getTransferCode, clearTransferCode, updateTransferState, currentDeviceId, activeSessionId, oxyServices],
   );
 
   useSessionSocket({
@@ -907,6 +1042,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     storeTransferCode,
     getTransferCode,
     clearTransferCode,
+    getAllPendingTransfers,
+    getActiveTransferId,
+    updateTransferState,
     identitySyncState: {
       isSynced: isIdentitySyncedStore ?? true,
       isSyncing: isSyncing ?? false,
@@ -940,6 +1078,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     storeTransferCode,
     getTransferCode,
     clearTransferCode,
+    getAllPendingTransfers,
+    getActiveTransferId,
+    updateTransferState,
     isIdentitySyncedStore,
     isSyncing,
     currentLanguage,

package/src/ui/hooks/useTransferQueries.ts

@@ -0,0 +1,154 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { useOxy } from '../context/OxyContext';
+import { useTransferStore } from '../stores/transferStore';
+
+/**
+ * Query keys for transfer-related queries
+ */
+export const transferQueryKeys = {
+  all: ['transfers'] as const,
+  completion: (transferId: string) => ['transfers', 'completion', transferId] as const,
+  pending: () => ['transfers', 'pending'] as const,
+};
+
+/**
+ * Hook to check if a transfer was completed
+ * Only runs when authenticated and transferId is provided
+ */
+export const useCheckTransferCompletion = (transferId: string | null, enabled: boolean = true) => {
+  const { oxyServices, isAuthenticated } = useOxy();
+  
+  return useQuery({
+    queryKey: transferId ? transferQueryKeys.completion(transferId) : ['transfers', 'completion', 'null'],
+    queryFn: async () => {
+      if (!transferId || !oxyServices) {
+        return null;
+      }
+
+      try {
+        const response = await oxyServices.makeRequest<{
+          completed: boolean;
+          transferId?: string;
+          sourceDeviceId?: string;
+          publicKey?: string;
+          transferCode?: string;
+          completedAt?: string;
+        }>(
+          'GET',
+          `/api/identity/check-transfer/${transferId}`,
+          undefined,
+          { cache: false }
+        );
+
+        return response;
+      } catch (error: any) {
+        // Handle 401 errors gracefully - don't throw, just return null
+        if (error?.status === 401 || error?.message?.includes('401') || error?.message?.includes('authentication')) {
+          if (__DEV__) {
+            console.warn('[useCheckTransferCompletion] Authentication required, skipping check');
+          }
+          return null;
+        }
+        throw error;
+      }
+    },
+    enabled: enabled && !!transferId && isAuthenticated && !!oxyServices,
+    staleTime: 30 * 1000, // 30 seconds - completion status doesn't change frequently
+    gcTime: 5 * 60 * 1000, // 5 minutes
+    retry: (failureCount, error: any) => {
+      // Don't retry on 401 errors
+      if (error?.status === 401 || error?.message?.includes('401')) {
+        return false;
+      }
+      return failureCount < 2;
+    },
+    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 5000),
+  });
+};
+
+/**
+ * Hook to check all pending transfers for completion
+ * Used when app comes back online
+ */
+export const useCheckPendingTransfers = () => {
+  const { oxyServices, isAuthenticated } = useOxy();
+  const getAllPendingTransfers = useTransferStore((state) => state.getAllPendingTransfers);
+  const pendingTransfers = getAllPendingTransfers();
+  
+  return useQuery({
+    queryKey: [...transferQueryKeys.pending(), pendingTransfers.map(t => t.transferId).join(',')],
+    queryFn: async () => {
+      if (!oxyServices || pendingTransfers.length === 0) {
+        return [];
+      }
+
+      const results: Array<{
+        transferId: string;
+        completed: boolean;
+        data?: {
+          transferId?: string;
+          sourceDeviceId?: string;
+          publicKey?: string;
+          transferCode?: string;
+          completedAt?: string;
+        };
+      }> = [];
+
+      // Check each pending transfer
+      for (const { transferId, data } of pendingTransfers) {
+        try {
+          const response = await oxyServices.makeRequest<{
+            completed: boolean;
+            transferId?: string;
+            sourceDeviceId?: string;
+            publicKey?: string;
+            transferCode?: string;
+            completedAt?: string;
+          }>(
+            'GET',
+            `/api/identity/check-transfer/${transferId}`,
+            undefined,
+            { cache: false }
+          );
+
+          if (response.completed && response.publicKey === data.publicKey) {
+            results.push({
+              transferId,
+              completed: true,
+              data: response,
+            });
+          } else {
+            results.push({
+              transferId,
+              completed: false,
+            });
+          }
+        } catch (error: any) {
+          // Handle 401 errors gracefully - skip this transfer
+          if (error?.status === 401 || error?.message?.includes('401') || error?.message?.includes('authentication')) {
+            if (__DEV__) {
+              console.warn(`[useCheckPendingTransfers] Authentication required for transfer ${transferId}, skipping`);
+            }
+            results.push({
+              transferId,
+              completed: false,
+            });
+            continue;
+          }
+          // For other errors, mark as not completed
+          results.push({
+            transferId,
+            completed: false,
+          });
+        }
+      }
+
+      return results;
+    },
+    enabled: isAuthenticated && !!oxyServices && pendingTransfers.length > 0,
+    staleTime: 30 * 1000, // 30 seconds
+    gcTime: 5 * 60 * 1000, // 5 minutes
+    retry: false, // Don't retry - we'll check again on next reconnect
+  });
+};
+

package/src/ui/stores/transferStore.ts

@@ -0,0 +1,201 @@
+import { create } from 'zustand';
+import { useShallow } from 'zustand/react/shallow';
+
+export interface TransferCodeData {
+  code: string;
+  sourceDeviceId: string | null;
+  publicKey: string;
+  timestamp: number;
+  state: 'pending' | 'completed' | 'failed';
+}
+
+export interface TransferState {
+  // Transfer codes map: transferId -> TransferCodeData
+  transferCodes: Record<string, TransferCodeData>;
+  
+  // Active transfer ID (only one active transfer at a time)
+  activeTransferId: string | null;
+  
+  // Restoration flag to prevent duplicate restorations
+  isRestored: boolean;
+  
+  // Actions
+  storeTransferCode: (transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => void;
+  getTransferCode: (transferId: string) => TransferCodeData | null;
+  clearTransferCode: (transferId: string) => void;
+  updateTransferState: (transferId: string, state: 'pending' | 'completed' | 'failed') => void;
+  getAllPendingTransfers: () => Array<{ transferId: string; data: TransferCodeData }>;
+  getActiveTransferId: () => string | null;
+  setActiveTransferId: (transferId: string | null) => void;
+  restoreFromStorage: (codes: Record<string, TransferCodeData>, activeTransferId: string | null) => void;
+  markRestored: () => void;
+  cleanupExpired: () => void;
+  reset: () => void;
+}
+
+const FIFTEEN_MINUTES = 15 * 60 * 1000;
+
+const initialState = {
+  transferCodes: {} as Record<string, TransferCodeData>,
+  activeTransferId: null as string | null,
+  isRestored: false,
+};
+
+export const useTransferStore = create<TransferState>((set, get) => ({
+  ...initialState,
+  
+  storeTransferCode: (transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => {
+    set((state) => ({
+      transferCodes: {
+        ...state.transferCodes,
+        [transferId]: {
+          code,
+          sourceDeviceId,
+          publicKey,
+          timestamp: Date.now(),
+          state: 'pending',
+        },
+      },
+      activeTransferId: transferId,
+    }));
+  },
+  
+  getTransferCode: (transferId: string) => {
+    const state = get();
+    return state.transferCodes[transferId] || null;
+  },
+  
+  clearTransferCode: (transferId: string) => {
+    set((state) => {
+      const { [transferId]: removed, ...rest } = state.transferCodes;
+      const newActiveTransferId = state.activeTransferId === transferId ? null : state.activeTransferId;
+      return {
+        transferCodes: rest,
+        activeTransferId: newActiveTransferId,
+      };
+    });
+  },
+  
+  updateTransferState: (transferId: string, newState: 'pending' | 'completed' | 'failed') => {
+    set((state) => {
+      const existing = state.transferCodes[transferId];
+      if (!existing) {
+        return state;
+      }
+      
+      const updated = {
+        ...existing,
+        state: newState,
+      };
+      
+      // Clear active transfer if completed or failed
+      const newActiveTransferId = 
+        (newState === 'completed' || newState === 'failed') && state.activeTransferId === transferId
+          ? null
+          : state.activeTransferId;
+      
+      return {
+        transferCodes: {
+          ...state.transferCodes,
+          [transferId]: updated,
+        },
+        activeTransferId: newActiveTransferId,
+      };
+    });
+  },
+  
+  getAllPendingTransfers: () => {
+    const state = get();
+    const pending: Array<{ transferId: string; data: TransferCodeData }> = [];
+    
+    Object.entries(state.transferCodes).forEach(([transferId, data]) => {
+      if (data.state === 'pending') {
+        pending.push({ transferId, data });
+      }
+    });
+    
+    return pending;
+  },
+  
+  getActiveTransferId: () => {
+    return get().activeTransferId;
+  },
+  
+  setActiveTransferId: (transferId: string | null) => {
+    set({ activeTransferId: transferId });
+  },
+  
+  restoreFromStorage: (codes: Record<string, TransferCodeData>, activeTransferId: string | null) => {
+    const now = Date.now();
+    const validCodes: Record<string, TransferCodeData> = {};
+    
+    // Only restore non-expired pending transfers
+    Object.entries(codes).forEach(([transferId, data]) => {
+      if (data.state === 'pending' && (now - data.timestamp) < FIFTEEN_MINUTES) {
+        validCodes[transferId] = data;
+      }
+    });
+    
+    // Verify active transfer is still valid
+    let validActiveTransferId = activeTransferId;
+    if (activeTransferId && (!validCodes[activeTransferId] || validCodes[activeTransferId].state !== 'pending')) {
+      validActiveTransferId = null;
+    }
+    
+    set({
+      transferCodes: validCodes,
+      activeTransferId: validActiveTransferId,
+      isRestored: true,
+    });
+  },
+  
+  markRestored: () => {
+    set({ isRestored: true });
+  },
+  
+  cleanupExpired: () => {
+    const now = Date.now();
+    set((state) => {
+      const validCodes: Record<string, TransferCodeData> = {};
+      let newActiveTransferId = state.activeTransferId;
+      
+      Object.entries(state.transferCodes).forEach(([transferId, data]) => {
+        const age = now - data.timestamp;
+        if (age < FIFTEEN_MINUTES) {
+          validCodes[transferId] = data;
+        } else if (transferId === state.activeTransferId) {
+          newActiveTransferId = null;
+        }
+      });
+      
+      return {
+        transferCodes: validCodes,
+        activeTransferId: newActiveTransferId,
+      };
+    });
+  },
+  
+  reset: () => {
+    set(initialState);
+  },
+}));
+
+/**
+ * Hook to get transfer codes for persistence
+ */
+export const useTransferCodesForPersistence = () => {
+  return useTransferStore(
+    useShallow((state) => ({
+      transferCodes: state.transferCodes,
+      activeTransferId: state.activeTransferId,
+    }))
+  );
+};
+
+/**
+ * Hook to check if store has been restored
+ */
+export const useTransferStoreRestored = () => {
+  return useTransferStore((state) => state.isRestored);
+};
+