WIP

Author: pwltr

Bitkit/AppScene.swift

@@ -410,31 +410,73 @@ struct AppScene: View {
             return String(data: data, encoding: .utf8)
         }()
 
+        let migrations = MigrationsService.shared
+
+        // If migration was already completed, only use VSS backups (RN backups are outdated)
+        if migrations.isMigrationCompleted {
+            Logger.info("Migration already completed, using VSS backup only (RN backups are outdated)", context: "AppScene")
+            await BackupService.shared.performFullRestoreFromLatestBackup()
+            return
+        }
+
         // Check for RN backup and get its timestamp
-        let hasRNBackup = await MigrationsService.shared.hasRNRemoteBackup(mnemonic: mnemonic, passphrase: passphrase)
+        let hasRNBackup = await migrations.hasRNRemoteBackup(mnemonic: mnemonic, passphrase: passphrase)
         let rnTimestamp: UInt64? = await hasRNBackup ? (try? RNBackupClient.shared.getLatestBackupTimestamp()) : nil
 
         // Get VSS backup timestamp
         let vssTimestamp = await BackupService.shared.getLatestBackupTime()
 
         // Determine which backup is more recent
         let shouldRestoreRN: Bool = {
-            guard hasRNBackup else { return false }
-            guard let vss = vssTimestamp, vss > 0 else { return true } // No VSS, use RN
-            guard let rn = rnTimestamp else { return false } // No RN timestamp, use VSS
-            return rn >= vss // RN is same or newer
+            guard hasRNBackup else {
+                Logger.debug("No RN backup found, using VSS", context: "AppScene")
+                return false
+            }
+
+            // If VSS timestamp is unavailable, prefer VSS anyway (it might exist but timestamp fetch failed)
+            // Only use RN if we're certain VSS doesn't exist
+            guard let vss = vssTimestamp, vss > 0 else {
+                Logger.warn(
+                    "VSS backup timestamp unavailable (nil or 0). Attempting VSS restore first. If it fails, will fall back to RN backup.",
+                    context: "AppScene"
+                )
+                // Try VSS first, it will handle errors internally
+                return false
+            }
+
+            guard let rn = rnTimestamp else {
+                Logger.debug("No RN timestamp available, using VSS", context: "AppScene")
+                return false
+            }
+
+            let useRN = rn >= vss
+            if useRN {
+                Logger.info("RN backup is newer or equal (RN: \(rn), VSS: \(vss)), using RN backup", context: "AppScene")
+            } else {
+                Logger.info("VSS backup is newer (RN: \(rn), VSS: \(vss)), using VSS backup", context: "AppScene")
+            }
+            return useRN
         }()
 
         if shouldRestoreRN {
             do {
-                try await MigrationsService.shared.restoreFromRNRemoteBackup(mnemonic: mnemonic, passphrase: passphrase)
+                try await migrations.restoreFromRNRemoteBackup(mnemonic: mnemonic, passphrase: passphrase)
             } catch {
                 Logger.error("RN remote backup restore failed: \(error)", context: "AppScene")
                 // Fall back to VSS
+                Logger.info("Falling back to VSS backup after RN restore failure", context: "AppScene")
                 await BackupService.shared.performFullRestoreFromLatestBackup()
             }
         } else {
+            // Always try VSS first
             await BackupService.shared.performFullRestoreFromLatestBackup()
+
+            // If VSS restore didn't work and RN backup exists, try RN as fallback
+            // Note: We can't easily detect if VSS restore failed since it doesn't throw,
+            // but this is a reasonable fallback strategy
+            if hasRNBackup {
+                Logger.debug("VSS restore attempted. If it failed, user may need to manually restore from RN backup.", context: "AppScene")
+            }
         }
     }
 

Bitkit/Services/MigrationsService.swift

@@ -416,6 +416,14 @@ extension MigrationsService {
         UserDefaults.standard.bool(forKey: Self.rnMigrationCheckedKey)
     }
 
+    var isMigrationCompleted: Bool {
+        UserDefaults.standard.bool(forKey: Self.rnMigrationCompletedKey)
+    }
+
+    func markMigrationCompleted() {
+        UserDefaults.standard.set(true, forKey: Self.rnMigrationCompletedKey)
+    }
+
     func hasRNWalletData() -> Bool {
         do {
             let mnemonic = try loadStringFromRNKeychain(key: .mnemonic(walletName: rnWalletName))

Bitkit/Utilities/AppReset.swift

@@ -32,13 +32,25 @@ enum AppReset {
         // Delete installation marker so next install can detect orphaned keychain
         try? InstallationMarker.delete()
 
+        // Preserve migration completion status before wiping UserDefaults
+        // If user migrated from RN before, they should only use VSS backups after restore
+        let wasMigrationCompleted = MigrationsService.shared.isMigrationCompleted
+
         // Wipe user defaults
         if let bundleID = Bundle.main.bundleIdentifier {
             UserDefaults.standard.removePersistentDomain(forName: bundleID)
         }
 
+        // Restore migration flags after wipe
         // Prevent RN migration from triggering after wipe
         MigrationsService.shared.markMigrationChecked()
+        
+        // If migration was completed before wipe, preserve that status
+        // This ensures restore logic will only use VSS backups (not outdated RN backups)
+        if wasMigrationCompleted {
+            MigrationsService.shared.markMigrationCompleted()
+            Logger.info("Preserved migration completion status after wipe", context: "AppReset")
+        }
 
         // Wipe logs
         if Env.network == .regtest {