@oxyhq/services 5.16.33 → 5.16.34

package/src/crypto/signatureService.ts

@@ -3,77 +3,25 @@
  * 
  * Handles signing and verification of messages using ECDSA secp256k1.
  * Used for authenticating requests and proving identity ownership.
+ * 
+ * Note: This service handles SIGNING (requires private key access via KeyManager).
+ * For VERIFICATION, use @oxyhq/shared SignatureService instead.
  */
 
 import { ec as EC } from 'elliptic';
 import { KeyManager } from './keyManager';
-
-// Lazy import for expo-crypto
-let ExpoCrypto: typeof import('expo-crypto') | null = null;
+import {
+  buildAuthMessage,
+  buildRegistrationMessage,
+  buildRequestMessage,
+  getCryptoAdapter,
+  type SignedMessage,
+} from '@oxyhq/shared';
 
 const ec = new EC('secp256k1');
 
-/**
- * Check if we're in a React Native environment
- */
-function isReactNative(): boolean {
-  return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-}
-
-/**
- * Check if we're in a Node.js environment
- */
-function isNodeJS(): boolean {
-  return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-}
-
-/**
- * Initialize expo-crypto module
- */
-async function initExpoCrypto(): Promise<typeof import('expo-crypto')> {
-  if (!ExpoCrypto) {
-    ExpoCrypto = await import('expo-crypto');
-  }
-  return ExpoCrypto;
-}
-
-/**
- * Compute SHA-256 hash of a string
- */
-async function sha256(message: string): Promise<string> {
-  // In React Native, always use expo-crypto
-  if (isReactNative() || !isNodeJS()) {
-    const Crypto = await initExpoCrypto();
-    return Crypto.digestStringAsync(
-      Crypto.CryptoDigestAlgorithm.SHA256,
-      message
-    );
-  }
-  
-  // In Node.js, use Node's crypto module
-  // Use Function constructor to prevent Metro bundler from statically analyzing this require
-  // This ensures the require is only evaluated in Node.js runtime, not during Metro bundling
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    const getCrypto = new Function('return require("crypto")');
-    const crypto = getCrypto();
-    return crypto.createHash('sha256').update(message).digest('hex');
-  } catch (error) {
-    // Fallback to expo-crypto if Node crypto fails
-    const Crypto = await initExpoCrypto();
-    return Crypto.digestStringAsync(
-      Crypto.CryptoDigestAlgorithm.SHA256,
-      message
-    );
-  }
-}
-
-export interface SignedMessage {
-  message: string;
-  signature: string;
-  publicKey: string;
-  timestamp: number;
-}
+// Re-export shared types
+export type { SignedMessage } from '@oxyhq/shared';
 
 export interface AuthChallenge {
   challenge: string;
@@ -84,39 +32,23 @@ export interface AuthChallenge {
 export class SignatureService {
   /**
    * Generate a random challenge string (for offline use)
-   * Uses expo-crypto in React Native, crypto.randomBytes in Node.js
+   * Uses shared crypto adapter
    */
   static async generateChallenge(): Promise<string> {
-    if (isReactNative() || !isNodeJS()) {
-      // Use expo-crypto for React Native (expo-random is deprecated)
-      const Crypto = await initExpoCrypto();
-      const randomBytes = await Crypto.getRandomBytesAsync(32);
-      return Array.from(randomBytes)
-        .map((b: number) => b.toString(16).padStart(2, '0'))
-        .join('');
-    }
-    
-    // Node.js fallback
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-implied-eval
-      const getCrypto = new Function('return require("crypto")');
-      const crypto = getCrypto();
-      return crypto.randomBytes(32).toString('hex');
-    } catch (error) {
-      // Fallback to expo-crypto if Node crypto fails
-      const Crypto = await initExpoCrypto();
-      const randomBytes = await Crypto.getRandomBytesAsync(32);
-      return Array.from(randomBytes)
-        .map((b: number) => b.toString(16).padStart(2, '0'))
-        .join('');
-    }
+    const adapter = await getCryptoAdapter();
+    const randomBytes = await adapter.randomBytes(32);
+    return Array.from(randomBytes)
+      .map((b: number) => b.toString(16).padStart(2, '0'))
+      .join('');
   }
 
   /**
    * Hash a message using SHA-256
+   * Uses shared crypto adapter
    */
   static async hashMessage(message: string): Promise<string> {
-    return sha256(message);
+    const adapter = await getCryptoAdapter();
+    return adapter.sha256(message);
   }
 
   /**
@@ -129,7 +61,8 @@ export class SignatureService {
       throw new Error('No identity found. Please create or import an identity first.');
     }
 
-    const messageHash = await sha256(message);
+    const adapter = await getCryptoAdapter();
+    const messageHash = await adapter.sha256(message);
     const signature = keyPair.sign(messageHash);
     return signature.toDER('hex');
   }
@@ -140,45 +73,19 @@ export class SignatureService {
    */
   static async signWithKey(message: string, privateKey: string): Promise<string> {
     const keyPair = ec.keyFromPrivate(privateKey);
-    const messageHash = await sha256(message);
+    const adapter = await getCryptoAdapter();
+    const messageHash = await adapter.sha256(message);
     const signature = keyPair.sign(messageHash);
     return signature.toDER('hex');
   }
 
   /**
    * Verify a signature against a message and public key
+   * Uses shared SignatureService for verification
    */
   static async verify(message: string, signature: string, publicKey: string): Promise<boolean> {
-    try {
-      const key = ec.keyFromPublic(publicKey, 'hex');
-      const messageHash = await sha256(message);
-      return key.verify(messageHash, signature);
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Synchronous verification (for Node.js backend)
-   * Uses crypto module directly for hashing
-   * Note: This method should only be used in Node.js environments
-   */
-  static verifySync(message: string, signature: string, publicKey: string): boolean {
-    try {
-      if (!isNodeJS()) {
-        // In React Native, use async verify instead
-        throw new Error('verifySync should only be used in Node.js. Use verify() in React Native.');
-      }
-      // Use Function constructor to prevent Metro bundler from statically analyzing this require
-      // eslint-disable-next-line @typescript-eslint/no-implied-eval
-      const getCrypto = new Function('return require("crypto")');
-      const crypto = getCrypto();
-      const key = ec.keyFromPublic(publicKey, 'hex');
-      const messageHash = crypto.createHash('sha256').update(message).digest('hex');
-      return key.verify(messageHash, signature);
-    } catch {
-      return false;
-    }
+    const { SignatureService: SharedSignatureService } = await import('@oxyhq/shared');
+    return SharedSignatureService.verify(message, signature, publicKey);
   }
 
   /**
@@ -205,22 +112,23 @@ export class SignatureService {
   /**
    * Verify a signed message object
    * Checks both signature validity and timestamp freshness
+   * Uses shared SignatureService for verification
    */
   static async verifySignedMessage(
     signedMessage: SignedMessage,
     maxAgeMs: number = 5 * 60 * 1000 // 5 minutes default
   ): Promise<boolean> {
+    const { SignatureService: SharedSignatureService, isTimestampFresh } = await import('@oxyhq/shared');
     const { message, signature, publicKey, timestamp } = signedMessage;
 
     // Check timestamp freshness
-    const now = Date.now();
-    if (now - timestamp > maxAgeMs) {
+    if (!isTimestampFresh(timestamp, maxAgeMs)) {
       return false;
     }
 
     // Verify signature
     const messageWithTimestamp = `${message}:${timestamp}`;
-    return SignatureService.verify(messageWithTimestamp, signature, publicKey);
+    return SharedSignatureService.verify(messageWithTimestamp, signature, publicKey);
   }
 
   /**
@@ -234,7 +142,7 @@ export class SignatureService {
     }
 
     const timestamp = Date.now();
-    const message = `auth:${publicKey}:${challenge}:${timestamp}`;
+    const message = buildAuthMessage(publicKey, challenge, timestamp);
     const signature = await SignatureService.sign(message);
 
     return {
@@ -246,22 +154,22 @@ export class SignatureService {
 
   /**
    * Verify a challenge response
+   * Uses shared SignatureService for verification
    */
   static async verifyChallengeResponse(
     originalChallenge: string,
     response: AuthChallenge,
     maxAgeMs: number = 5 * 60 * 1000
   ): Promise<boolean> {
+    const { SignatureService: SharedSignatureService } = await import('@oxyhq/shared');
     const { challenge: signature, publicKey, timestamp } = response;
-
-    // Check timestamp freshness
-    const now = Date.now();
-    if (now - timestamp > maxAgeMs) {
-      return false;
-    }
-
-    const message = `auth:${publicKey}:${originalChallenge}:${timestamp}`;
-    return SignatureService.verify(message, signature, publicKey);
+    return SharedSignatureService.verifyChallengeResponse(
+      publicKey,
+      originalChallenge,
+      signature,
+      timestamp,
+      maxAgeMs
+    );
   }
 
   /**
@@ -276,7 +184,7 @@ export class SignatureService {
     }
 
     const timestamp = Date.now();
-    const message = `oxy:register:${publicKey}:${timestamp}`;
+    const message = buildRegistrationMessage(publicKey, timestamp);
     const signature = await SignatureService.sign(message);
 
     return {
@@ -301,13 +209,7 @@ export class SignatureService {
     }
 
     const timestamp = Date.now();
-    
-    // Create canonical string representation
-    const sortedKeys = Object.keys(data).sort();
-    const canonicalParts = sortedKeys.map(key => `${key}:${JSON.stringify(data[key])}`);
-    const canonicalString = canonicalParts.join('|');
-    
-    const message = `request:${publicKey}:${timestamp}:${canonicalString}`;
+    const message = buildRequestMessage(publicKey, timestamp, data);
     const signature = await SignatureService.sign(message);
 
     return {

package/src/index.ts

@@ -49,10 +49,9 @@ export {
 export type { LanguageMetadata } from './utils/languageUtils';
 
 // Type exports
+// Note: User and LoginResponse should be imported from @oxyhq/shared
 export type {
   OxyConfig,
-  User,
-  LoginResponse,
   Notification,
   Wallet,
   Transaction,

package/src/models/interfaces.ts

@@ -1,3 +1,12 @@
+/**
+ * Services Package Interfaces
+ * 
+ * Package-specific interfaces. For shared models (User, Session, etc.),
+ * import directly from @oxyhq/shared:
+ * 
+ * import { User, LoginResponse, Session } from '@oxyhq/shared';
+ */
+
 export interface OxyConfig {
   baseURL: string;
   cloudURL?: string;
@@ -21,66 +30,8 @@ export interface OxyConfig {
   onRequestError?: (url: string, method: string, error: Error) => void;
 }
 
-/**
- * User Model
- * 
- * IMPORTANT: 
- * - id: Public key (ECDSA secp256k1 public key, 130 hex characters) - CANONICAL USER IDENTITY
- * - publicKey: Same as id (kept for backward compatibility and explicit clarity)
- * 
- * publicKey is the canonical user identity across the ecosystem because it's:
- * - Globally unique
- * - Local-first (stored in Accounts app)
- * - Avoids device-bound artifacts
- * 
- * MongoDB _id remains internal to backend only and is not exposed in the User interface.
- * Backend may use MongoDB ObjectId internally for database operations, but client always uses publicKey.
- */
-export interface User {
-  id: string;           // Public key - CANONICAL USER IDENTITY (130 hex chars for secp256k1)
-  publicKey: string;    // Same as id (kept for backward compatibility)
-  username: string;
-  email?: string;
-  // Avatar file id (asset id)
-  avatar?: string;
-  // Privacy and security settings
-  privacySettings?: {
-    [key: string]: unknown;
-  };
-  name?: {
-    first?: string;
-    last?: string;
-    full?: string; // virtual, not stored in DB, returned by API
-    [key: string]: unknown;
-  };
-  bio?: string;
-  karma?: number;
-  location?: string;
-  website?: string;
-  createdAt?: string;
-  updatedAt?: string;
-  links?: Array<{
-    title?: string;
-    description?: string;
-    image?: string;
-    link: string;
-  }>;
-  // Social counts
-  _count?: {
-    followers?: number;
-    following?: number;
-  };
-  accountExpiresAfterInactivityDays?: number | null; // Days of inactivity before account expires (null = never expire)
-  [key: string]: unknown;
-}
-
-export interface LoginResponse {
-  accessToken?: string;
-  refreshToken?: string;
-  token?: string; // For backwards compatibility
-  user: User;
-  message?: string;
-}
+// Note: User and LoginResponse are in @oxyhq/shared
+// Import them directly: import { User, LoginResponse } from '@oxyhq/shared';
 
 export interface Notification {
   id: string;
@@ -153,17 +104,8 @@ export interface TransactionResponse {
   transaction: Transaction;
 }
 
-export interface PaginationInfo {
-  total: number;
-  limit: number;
-  offset: number;
-  hasMore: boolean;
-}
-
-export interface SearchProfilesResponse {
-  data: User[];
-  pagination: PaginationInfo;
-}
+// Note: PaginationInfo and SearchProfilesResponse are in @oxyhq/shared
+// Import them directly: import { PaginationInfo, SearchProfilesResponse } from '@oxyhq/shared';
 
 export interface KarmaRule {
   id: string;
@@ -376,8 +318,6 @@ export interface AssetUrlResponse {
 
 export interface AssetDeleteSummary {
   fileId: string;
-  wouldDelete: boolean;
-  affectedApps: string[];
   remainingLinks: number;
   variants: string[];
 }
@@ -495,6 +435,7 @@ export interface AssetUploadProgress {
 }
 
 // Device Session interfaces
+// Note: User type should be imported from @oxyhq/shared
 export interface DeviceSession {
   sessionId: string;
   deviceId: string;
@@ -503,7 +444,13 @@ export interface DeviceSession {
   lastActive: string;
   expiresAt: string;
   isCurrent: boolean;
-  user?: User;
+  user?: {
+    id: string;
+    publicKey: string;
+    username: string;
+    avatar?: string;
+    [key: string]: unknown;
+  }; // Partial User - import full User type from @oxyhq/shared if needed
   createdAt?: string;
 }
 

package/src/models/session.ts

@@ -2,17 +2,15 @@
  * Client Session Model
  * 
  * IMPORTANT:
- * - publicKey: Canonical user identity (ECDSA secp256k1 public key) - PRIMARY IDENTIFIER
- * - userId: MongoDB ObjectId (kept for backward compatibility, but publicKey is canonical)
- * - Sessions are bound to the local identity (publicKey) stored in Accounts app
+ * - userId: MongoDB ObjectId (24 hex characters), never publicKey
+ * - Used for session management and user identification
  */
 export interface ClientSession {
   sessionId: string;
   deviceId: string;
   expiresAt: string;
   lastActive: string;
-  publicKey: string;  // Canonical user identity - PRIMARY IDENTIFIER
-  userId?: string;     // MongoDB ObjectId (internal backend reference, optional for compatibility)
+  userId?: string;  // MongoDB ObjectId - PRIMARY IDENTIFIER (never publicKey)
   isCurrent?: boolean;
 }
 

package/src/ui/context/OxyContext.tsx

@@ -11,7 +11,8 @@ import {
 } from 'react';
 import { Platform } from 'react-native';
 import { OxyServices } from '../../core';
-import type { User, ApiError } from '../../models/interfaces';
+import type { ApiError } from '../../models/interfaces';
+import type { User } from '@oxyhq/shared';
 import type { ClientSession } from '../../models/session';
 import { toast } from '../../lib/sonner';
 import { useAuthStore, type AuthState } from '../stores/authStore';
@@ -222,7 +223,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         // CRITICAL: Invalidate cache on app startup to ensure fresh state check
         // This prevents stale cache from previous session from showing incorrect state
         KeyManager.invalidateCache();
-
+        
         // Check if identity exists and verify integrity
         const hasIdentity = await KeyManager.hasIdentity();
         if (hasIdentity) {
@@ -421,7 +422,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
       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. ' +
@@ -485,11 +486,11 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         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();
@@ -520,7 +521,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
             // This is handled by useCheckPendingTransfers hook which runs automatically
             // when authenticated and online
           }
-
+          
           // TanStack Query will automatically retry pending mutations
           // Reset flag immediately after processing (whether logged or not)
           wasOffline = false;
@@ -580,22 +581,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     setTokenReady(false);
 
     try {
-      // CRITICAL: Get current local identity (publicKey) before restoring sessions
-      // Sessions must belong to the current local identity stored in Accounts app
-      let currentPublicKey: string | null = null;
-      try {
-        if (Platform.OS !== 'web') {
-          // Only check identity on native platforms (web doesn't have local identity)
-          // KeyManager is already imported at the top of the file
-          currentPublicKey = await KeyManager.getPublicKey();
-        }
-      } catch (identityError) {
-        if (__DEV__) {
-          logger('Failed to get current local identity during session restoration', identityError);
-        }
-        // Continue without identity check if it fails (e.g., on web platform)
-      }
-
       const storedSessionIdsJson = await storage.getItem(storageKeys.sessionIds);
       const storedSessionIds: string[] = storedSessionIdsJson ? JSON.parse(storedSessionIdsJson) : [];
       const storedActiveSessionId = await storage.getItem(storageKeys.activeSessionId);
@@ -608,25 +593,12 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
             const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation: true });
             if (validation?.valid && validation.user) {
               const now = new Date();
-              // user.id is now publicKey (canonical identity)
-              const sessionPublicKey = validation.user.publicKey || validation.user.id || '';
-
-              // IDENTITY BINDING: Only restore sessions that match current local identity
-              // If we have a current local identity, filter out sessions that don't match
-              if (currentPublicKey && sessionPublicKey !== currentPublicKey) {
-                if (__DEV__) {
-                  logger(`Skipping session ${sessionId.substring(0, 8)}... - belongs to different identity (${sessionPublicKey.substring(0, 16)}... vs ${currentPublicKey.substring(0, 16)}...)`);
-                }
-                continue; // Skip this session - it belongs to a different identity
-              }
-
               validSessions.push({
                 sessionId,
                 deviceId: '',
                 expiresAt: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
                 lastActive: now.toISOString(),
-                publicKey: sessionPublicKey, // Canonical user identity
-                userId: validation.user.id?.toString(), // Optional MongoDB ObjectId for backward compatibility
+                userId: validation.user.id?.toString() ?? '',
                 isCurrent: sessionId === storedActiveSessionId,
               });
             }
@@ -644,13 +616,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
         if (validSessions.length > 0) {
           updateSessions(validSessions, { merge: false });
-        } else if (currentPublicKey && storedSessionIds.length > 0) {
-          // All sessions were filtered out due to identity mismatch - clear stored sessions
-          if (__DEV__) {
-            logger('All stored sessions belong to different identity - clearing session storage');
-          }
-          await storage.removeItem(storageKeys.sessionIds);
-          await storage.removeItem(storageKeys.activeSessionId);
         }
       }
 
@@ -762,9 +727,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     return isAuthenticatedFromStore || isAuthenticatedFromSessions;
   }, [isAuthenticatedFromStore, isAuthenticatedFromSessions]);
 
-  // Get userId from JWT token for socket room matching
-  // Note: JWT token may contain MongoDB ObjectId internally, but user.id is publicKey (canonical identity)
-  // Socket rooms may need internal mapping from publicKey to MongoDB ObjectId if backend requires it
+  // Get userId from JWT token (MongoDB ObjectId) for socket room matching
+  // user.id is set to publicKey for compatibility, but socket rooms use MongoDB ObjectId
+  // The JWT token's userId field contains the MongoDB ObjectId
   const userId = oxyServices.getCurrentUserId() || user?.id;
 
   // Use Zustand store for transfer state management
@@ -784,16 +749,16 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         // 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', {
+          logger('Restored transfer codes from storage', { 
             count: Object.keys(parsedCodes).length,
             hasActiveTransfer: !!activeTransferId,
           });
@@ -818,7 +783,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     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 {
@@ -846,7 +811,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   // 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) + '...' });
     }
@@ -858,7 +823,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
   const updateTransferState = useCallback(async (transferId: string, state: 'pending' | 'completed' | 'failed') => {
     updateTransferStateStore(transferId, state);
-
+    
     if (__DEV__) {
       logger('Updated transfer state', { transferId, state });
     }
@@ -866,7 +831,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
   const clearTransferCode = useCallback(async (transferId: string) => {
     clearTransferCodeStore(transferId);
-
+    
     if (__DEV__) {
       logger('Cleared transfer code', { transferId });
     }
@@ -908,7 +873,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         const storedTransfer = getTransferCode(data.transferId);
 
         if (!storedTransfer) {
-          logger('Transfer code not found for transferId', {
+          logger('Transfer code not found for transferId', { 
             transferId: data.transferId,
           });
           toast.error('Transfer verification failed: Code not found. Identity will not be deleted.');
@@ -930,7 +895,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         // 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 =
+        const deviceIdMatches = 
           // Exact match
           (data.sourceDeviceId && data.sourceDeviceId === currentDeviceId) ||
           // Stored sourceDeviceId matches current deviceId
@@ -1010,7 +975,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
           }
 
           await deleteIdentityAndClearAccount(false, false, true);
-
+          
           // Verify identity was actually deleted
           const identityDeleted = !(await KeyManager.hasIdentity());
           if (!identityDeleted) {