@oxyhq/services 5.16.18 → 5.16.20

package/src/crypto/recoveryPhrase.ts

@@ -1,166 +0,0 @@
-/**
- * Recovery Phrase Service - BIP39 Mnemonic Generation
- * 
- * Handles generation and restoration of recovery phrases (mnemonic seeds)
- * for backing up and restoring user identities.
- * 
- * Note: This module requires the polyfill to be loaded first (done via crypto/index.ts)
- */
-
-import * as bip39 from 'bip39';
-import { KeyManager } from './keyManager';
-
-/**
- * Convert Uint8Array or array-like to hexadecimal string
- * Works in both Node.js and React Native without depending on Buffer
- */
-function toHex(data: Uint8Array | ArrayLike<number>): string {
-  // Convert to array of numbers if needed
-  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-  return Array.from(bytes)
-    .map(b => b.toString(16).padStart(2, '0'))
-    .join('');
-}
-
-export interface RecoveryPhraseResult {
-  phrase: string;
-  words: string[];
-  publicKey: string;
-}
-
-export class RecoveryPhraseService {
-  /**
-   * Generate a new identity with a recovery phrase
-   * Returns the mnemonic phrase (should only be shown once to the user)
-   */
-  static async generateIdentityWithRecovery(): Promise<RecoveryPhraseResult> {
-    // Generate 128-bit entropy for 12-word mnemonic
-    const mnemonic = bip39.generateMnemonic(128);
-    
-    // Derive private key from mnemonic
-    // Using the seed directly as the private key (simplified approach)
-    const seed = await bip39.mnemonicToSeed(mnemonic);
-    
-    // Use first 32 bytes of seed as private key
-    const seedSlice = seed.subarray ? seed.subarray(0, 32) : seed.slice(0, 32);
-    const privateKeyHex = toHex(seedSlice);
-    
-    // Import the derived key pair
-    const publicKey = await KeyManager.importKeyPair(privateKeyHex);
-
-    return {
-      phrase: mnemonic,
-      words: mnemonic.split(' '),
-      publicKey,
-    };
-  }
-
-  /**
-   * Generate a 24-word recovery phrase for higher security
-   */
-  static async generateIdentityWithRecovery24(): Promise<RecoveryPhraseResult> {
-    // Generate 256-bit entropy for 24-word mnemonic
-    const mnemonic = bip39.generateMnemonic(256);
-    
-    const seed = await bip39.mnemonicToSeed(mnemonic);
-    const seedSlice = seed.subarray ? seed.subarray(0, 32) : seed.slice(0, 32);
-    const privateKeyHex = toHex(seedSlice);
-    const publicKey = await KeyManager.importKeyPair(privateKeyHex);
-
-    return {
-      phrase: mnemonic,
-      words: mnemonic.split(' '),
-      publicKey,
-    };
-  }
-
-  /**
-   * Restore an identity from a recovery phrase
-   */
-  static async restoreFromPhrase(phrase: string): Promise<string> {
-    // Normalize and validate the phrase
-    const normalizedPhrase = phrase.trim().toLowerCase();
-    
-    if (!bip39.validateMnemonic(normalizedPhrase)) {
-      throw new Error('Invalid recovery phrase. Please check the words and try again.');
-    }
-
-    // Derive the same private key from the mnemonic
-    const seed = await bip39.mnemonicToSeed(normalizedPhrase);
-    const seedSlice = seed.subarray ? seed.subarray(0, 32) : seed.slice(0, 32);
-    const privateKeyHex = toHex(seedSlice);
-    
-    // Import and store the key pair
-    const publicKey = await KeyManager.importKeyPair(privateKeyHex);
-
-    return publicKey;
-  }
-
-  /**
-   * Validate a recovery phrase without importing it
-   */
-  static validatePhrase(phrase: string): boolean {
-    const normalizedPhrase = phrase.trim().toLowerCase();
-    return bip39.validateMnemonic(normalizedPhrase);
-  }
-
-  /**
-   * Get the word list for autocomplete/validation
-   */
-  static getWordList(): string[] {
-    return bip39.wordlists.english;
-  }
-
-  /**
-   * Check if a word is valid in the BIP39 word list
-   */
-  static isValidWord(word: string): boolean {
-    return bip39.wordlists.english.includes(word.toLowerCase());
-  }
-
-  /**
-   * Get suggestions for a partial word
-   */
-  static getSuggestions(partial: string, limit: number = 5): string[] {
-    const lowerPartial = partial.toLowerCase();
-    return bip39.wordlists.english
-      .filter((word: string) => word.startsWith(lowerPartial))
-      .slice(0, limit);
-  }
-
-  /**
-   * Derive the public key from a phrase without storing
-   * Useful for verification before importing
-   */
-  static async derivePublicKeyFromPhrase(phrase: string): Promise<string> {
-    const normalizedPhrase = phrase.trim().toLowerCase();
-    
-    if (!bip39.validateMnemonic(normalizedPhrase)) {
-      throw new Error('Invalid recovery phrase');
-    }
-
-    const seed = await bip39.mnemonicToSeed(normalizedPhrase);
-    const seedSlice = seed.subarray ? seed.subarray(0, 32) : seed.slice(0, 32);
-    const privateKeyHex = toHex(seedSlice);
-    
-    return KeyManager.derivePublicKey(privateKeyHex);
-  }
-
-  /**
-   * Convert a phrase to its word array
-   */
-  static phraseToWords(phrase: string): string[] {
-    return phrase.trim().toLowerCase().split(/\s+/);
-  }
-
-  /**
-   * Convert a word array to a phrase string
-   */
-  static wordsToPhrase(words: string[]): string {
-    return words.map(w => w.toLowerCase().trim()).join(' ');
-  }
-}
-
-export default RecoveryPhraseService;
-
-

package/src/types/bip39.d.ts

@@ -1,32 +0,0 @@
-declare module 'bip39' {
-  export interface Wordlist {
-    [index: number]: string;
-    length: number;
-    getWord(index: number): string;
-    getWordIndex(word: string): number;
-  }
-
-  export const wordlists: {
-    english: string[];
-    chinese_simplified: string[];
-    chinese_traditional: string[];
-    french: string[];
-    italian: string[];
-    japanese: string[];
-    korean: string[];
-    spanish: string[];
-  };
-
-  // Use Uint8Array instead of Buffer for React Native compatibility
-  // In Node.js, Buffer extends Uint8Array so this is compatible
-  export function generateMnemonic(strength?: number, rng?: (size: number) => Uint8Array, wordlist?: string[]): string;
-  export function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
-  export function mnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;
-  export function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): string;
-  export function entropyToMnemonic(entropy: string, wordlist?: string[]): string;
-  export function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean;
-  export function mnemonicToSeedHex(mnemonic: string, passphrase?: string): Promise<string>;
-  export function mnemonicToSeedHexSync(mnemonic: string, passphrase?: string): string;
-}
-
-

package/src/ui/hooks/useIdentityMutations.ts

@@ -1,115 +0,0 @@
-/**
- * TanStack Query mutations for identity operations
- * Provides offline-first mutations for identity creation, import, and sync
- * Never deletes identity on errors - preserves user data
- */
-
-import { useMutation, useQueryClient } from '@tanstack/react-query';
-import type { User } from '../../models/interfaces';
-
-export interface CreateIdentityResult {
-  recoveryPhrase: string[];
-  synced: boolean;
-}
-
-export interface ImportIdentityResult {
-  synced: boolean;
-}
-
-/**
- * Hook for creating a new identity with offline support
- * Never deletes identity on error - preserves user data
- */
-export function useCreateIdentity(
-  createIdentityFn: () => Promise<CreateIdentityResult>
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: createIdentityFn,
-    onSuccess: (data) => {
-      // Invalidate user queries to refetch after identity creation
-      queryClient.invalidateQueries({ queryKey: ['user'] });
-      queryClient.invalidateQueries({ queryKey: ['identity'] });
-    },
-    onError: (error) => {
-      // Never delete identity on error - just log it
-      // User can recover using recovery phrase
-      if (__DEV__) {
-        console.warn('[useCreateIdentity] Identity creation error (identity may still exist):', error);
-      }
-    },
-    retry: false, // Don't retry identity creation
-    networkMode: 'offlineFirst',
-  });
-}
-
-/**
- * Hook for importing an identity from recovery phrase
- * Never deletes identity on error - preserves user data
- */
-export function useImportIdentity(
-  importIdentityFn: (phrase: string) => Promise<ImportIdentityResult>
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: importIdentityFn,
-    onSuccess: (data) => {
-      queryClient.invalidateQueries({ queryKey: ['user'] });
-      queryClient.invalidateQueries({ queryKey: ['identity'] });
-    },
-    onError: (error) => {
-      // Never delete identity on error - just log it
-      if (__DEV__) {
-        console.warn('[useImportIdentity] Identity import error (identity may still exist):', error);
-      }
-    },
-    retry: false,
-    networkMode: 'offlineFirst',
-  });
-}
-
-/**
- * Hook for syncing identity with server
- * Never deletes identity on error - only logs and allows retry
- */
-export function useSyncIdentity(
-  syncIdentityFn: () => Promise<User>
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: syncIdentityFn,
-    onSuccess: (user) => {
-      // Update user cache
-      queryClient.setQueryData(['user', 'current'], user);
-      queryClient.invalidateQueries({ queryKey: ['user'] });
-      queryClient.invalidateQueries({ queryKey: ['identity'] });
-    },
-    onError: (error) => {
-      // Never delete identity on error - just log it
-      // User can retry sync later or use recovery phrase
-      if (__DEV__) {
-        console.warn('[useSyncIdentity] Sync failed, but identity is preserved:', error);
-      }
-    },
-    retry: (failureCount, error: any) => {
-      // Retry up to 2 times for sync operations
-      // Don't retry if it's a network error - user can retry when online
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const isNetworkError = 
-        errorMessage.includes('Network') ||
-        errorMessage.includes('Failed to fetch') ||
-        error?.code === 'NETWORK_ERROR';
-      
-      if (isNetworkError) {
-        return false; // Don't retry network errors - user will retry when online
-      }
-      
-      return failureCount < 2;
-    },
-    networkMode: 'offlineFirst',
-  });
-}
-