Backup & Restore

// From src/state/backups/backups.ts
enum CloudBackupState {
  Initializing = 'initializing',
  Syncing = 'syncing',
  Fetching = 'fetching',
  Ready = 'ready',
  NotAvailable = 'not_available',
  InProgress = 'in_progress',
  Error = 'error',
  Success = 'success',
}

interface BackupsStore {
  status: CloudBackupState;
  backups: CloudBackups;
  mostRecentBackup: BackupFile | undefined;
  password: string;
  
  syncAndFetchBackups: () => Promise<{ success: boolean }>;
  setBackups: (backups: CloudBackups) => void;
}

interface BackupFile {
  isDirectory: boolean;
  isFile: boolean;
  lastModified: string;  // ISO timestamp
  name: string;          // backup_${timestamp}.json
  path: string;          // Cloud storage path
  size: number;          // File size in bytes
  uri: string;           // Cloud URI
}

interface BackupUserData {
  wallets: AllRainbowWallets; // All wallet data
}

// From src/model/backup.ts
const encryptAndSaveDataToCloud = async (
  data: Record<string, unknown>,
  password: string,
  filename: string
) => {
  // 1. Encrypt data with AES-256
  const encryptedData = await encryptor.encrypt(
    password, 
    JSON.stringify(data)
  );
  
  // 2. Normalize filename for platform
  const backupFilename = IS_ANDROID 
    ? normalizeAndroidBackupFilename(filename) 
    : filename;
  
  // 3. Write to local storage first
  const path = `${RNFS.DocumentDirectoryPath}/${backupFilename}`;
  await RNFS.writeFile(path, encryptedData, 'utf8');
  
  // 4. Upload to cloud storage
  const sourceUri = { path };
  const destinationPath = `${REMOTE_BACKUP_WALLET_DIR}/${backupFilename}`;
  const mimeType = 'application/json';
  
  await RNCloudFs.copyToCloud({
    sourcePath: sourceUri,
    targetPath: destinationPath,
    mimeType,
    scope: 'hidden',
  });
  
  // 5. Clean up local file
  await RNFS.unlink(path);
  
  return filename;
};

const getDataFromCloud = async (
  backupPassword: BackupPassword,
  filename: string
) => {
  // 1. Fetch encrypted backup from cloud
  const path = `${REMOTE_BACKUP_WALLET_DIR}/${filename}`;
  const encryptedData = await RNCloudFs.getFromCloud({
    path,
    scope: 'hidden',
  });
  
  if (!encryptedData) {
    throw new Error(CLOUD_BACKUP_ERRORS.ERROR_GETTING_ENCRYPTED_DATA);
  }
  
  // 2. Decrypt with user password
  let decryptedData;
  try {
    decryptedData = await encryptor.decrypt(
      backupPassword,
      encryptedData
    );
  } catch (error) {
    throw new Error(CLOUD_BACKUP_ERRORS.ERROR_DECRYPTING_DATA);
  }
  
  // 3. Parse and validate
  const parsedData = JSON.parse(decryptedData);
  
  return parsedData;
};

// PIN must be 4 digits
const PIN_REGEX = /^\d{4}$/;

const createPINBackup = async (pin: string) => {
  // Validate PIN format
  if (!PIN_REGEX.test(pin)) {
    throw new Error('PIN must be 4 digits');
  }
  
  // Authenticate and create PIN
  await maybeAuthenticateWithPINAndCreateIfNeeded(pin);
  
  // Use PIN as encryption password
  await encryptAndSaveDataToCloud(walletData, pin, filename);
};

// From src/state/wallets/walletsStore.ts
setWalletBackedUp: (
  id: RainbowWallet['id'],
  method: RainbowWallet['backupType'],
  backupFile?: RainbowWallet['backupFile']
) => {
  const { wallets } = get();
  const wallet = wallets[id];
  
  if (!wallet) return;
  
  const updatedWallet = {
    ...wallet,
    backedUp: true,
    backupDate: Date.now(),
    backupFile,
    backupType: method,
  };
  
  saveAllWallets({
    ...wallets,
    [id]: updatedWallet,
  });
}

enum WalletBackupTypes {
  cloud = 'cloud',        // iCloud/Google Drive
  manual = 'manual',      // Seed phrase recorded
}

syncAndFetchBackups: async (retryOnFailure = true, retryCount = 0) => {
  const { status } = get();
  
  // Don't sync if already syncing
  if (returnEarlyIfLockedStates.includes(status)) {
    return { success: false };
  }
  
  set({ status: CloudBackupState.Syncing });
  
  try {
    // Sync cloud storage state
    if (IS_ANDROID) {
      await syncCloud();
    }
    
    set({ status: CloudBackupState.Fetching });
    
    // Fetch all backups
    const backups = await fetchAllBackups();
    
    // Find most recent
    const mostRecentBackup = getMostRecentCloudBackup(backups.files);
    
    set({
      backups,
      mostRecentBackup,
      status: CloudBackupState.Ready,
    });
    
    return { success: true };
  } catch (error) {
    // Retry logic
    if (retryOnFailure && retryCount < MAX_RETRIES) {
      await new Promise(resolve => setTimeout(resolve, 1000));
      return syncAndFetchBackups(true, retryCount + 1);
    }
    
    set({ status: CloudBackupState.Error });
    return { success: false };
  }
}

export const CLOUD_BACKUP_ERRORS = {
  ERROR_DECRYPTING_DATA: 'Error decrypting data',
  ERROR_GETTING_ENCRYPTED_DATA: 'Error getting encrypted data!',
  GENERAL_ERROR: 'Backup failed',
  INTEGRITY_CHECK_FAILED: 'Backup integrity check failed',
  KEYCHAIN_ACCESS_ERROR: "Couldn't read items from keychain",
  NO_BACKUPS_FOUND: 'No backups found',
  SPECIFIC_BACKUP_NOT_FOUND: 'No backup found with that name',
  MISSING_PIN: 'The PIN code you entered is invalid',
  WRONG_PIN: 'The PIN code you entered is wrong',
};

// Android-specific features
export async function getGoogleAccountUserData(): Promise<GoogleDriveUserData> {
  if (!IS_ANDROID) return;
  
  return RNCloudFs.getCurrentlySignedInUserData({ checkPermissions: true });
}

export async function logoutFromGoogleDrive() {
  IS_ANDROID && RNCloudFs.logout();
}