Support restore from RN app

Bitkit.xcodeproj/project.pbxproj

@@ -92,6 +92,7 @@
 				Services/GeoService.swift,
 				Services/LightningService.swift,
 				Services/MigrationsService.swift,
+				Services/RNBackupClient.swift,
 				Services/ServiceQueue.swift,
 				Services/VssStoreIdProvider.swift,
 				Utilities/Crypto.swift,

Bitkit/AppScene.swift

@@ -248,16 +248,18 @@ struct AppScene: View {
 
         if wallet.isRestoringWallet {
             Task {
-                await BackupService.shared.performFullRestoreFromLatestBackup()
+                await restoreFromMostRecentBackup()
 
                 await MainActor.run {
                     widgets.loadSavedWidgets()
                     widgets.objectWillChange.send()
                 }
+
+                await startWallet()
             }
+        } else {
+            Task { await startWallet() }
         }
-
-        Task { await startWallet() }
     }
 
     private func startWallet() async {
@@ -332,6 +334,44 @@ struct AppScene: View {
         }
     }
 
+    private func restoreFromMostRecentBackup() async {
+        guard let mnemonicData = try? Keychain.load(key: .bip39Mnemonic(index: 0)),
+              let mnemonic = String(data: mnemonicData, encoding: .utf8)
+        else { return }
+
+        let passphrase: String? = {
+            guard let data = try? Keychain.load(key: .bip39Passphrase(index: 0)) else { return nil }
+            return String(data: data, encoding: .utf8)
+        }()
+
+        // Check for RN backup and get its timestamp
+        let hasRNBackup = await MigrationsService.shared.hasRNRemoteBackup(mnemonic: mnemonic, passphrase: passphrase)
+        let rnTimestamp: UInt64? = await hasRNBackup ? (try? RNBackupClient.shared.getLatestBackupTimestamp()) : nil
+
+        // Get VSS backup timestamp
+        let vssTimestamp = 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
+        }()
+
+        if shouldRestoreRN {
+            do {
+                try await MigrationsService.shared.restoreFromRNRemoteBackup(mnemonic: mnemonic, passphrase: passphrase)
+            } catch {
+                Logger.error("RN remote backup restore failed: \(error)", context: "AppScene")
+                // Fall back to VSS
+                await BackupService.shared.performFullRestoreFromLatestBackup()
+            }
+        } else {
+            await BackupService.shared.performFullRestoreFromLatestBackup()
+        }
+    }
+
     private func handleNodeLifecycleChange(_ state: NodeLifecycleState) {
         if state == .initializing {
             walletIsInitializing = true

Bitkit/Constants/Env.swift

@@ -204,6 +204,20 @@ enum Env {
         }
     }
 
+    static var rnBackupServerHost: String {
+        switch network {
+        case .bitcoin: "https://blocktank.synonym.to/backups-ldk"
+        default: "https://bitkit.stag0.blocktank.to/backups-ldk"
+        }
+    }
+
+    static var rnBackupServerPubKey: String {
+        switch network {
+        case .bitcoin: "0236efd76e37f96cf2dced9d52ff84c97e5b3d4a75e7d494807291971783f38377"
+        default: "02c03b8b8c1b5500b622646867d99bf91676fac0f38e2182c91a9ff0d053a21d6d"
+        }
+    }
+
     static var blockExplorerUrl: String {
         switch network {
         case .bitcoin: "https://mempool.space"

Bitkit/Services/CoreService.swift

@@ -352,15 +352,16 @@ class ActivityService {
         let value = payment.amountSats ?? 0
 
         // Determine confirmation status from payment's txStatus
-        // Ensure confirmTimestamp is at least equal to paymentTimestamp when confirmed
-        // This handles cases where payment.latestUpdateTimestamp is more recent than blockTimestamp
-        let (isConfirmed, confirmedTimestamp): (Bool, UInt64?) =
-            if case let .onchain(_, txStatus) = payment.kind,
-            case let .confirmed(_, _, blockTimestamp) = txStatus {
-                (true, max(blockTimestamp, paymentTimestamp))
-            } else {
-                (false, nil)
-            }
+        var blockTimestamp: UInt64?
+        let isConfirmed: Bool
+        if case let .onchain(_, txStatus) = payment.kind,
+           case let .confirmed(_, _, bts) = txStatus
+        {
+            isConfirmed = true
+            blockTimestamp = bts
+        } else {
+            isConfirmed = false
+        }
 
         // Extract existing activity data
         let existingOnchain: OnchainActivity? = {
@@ -412,6 +413,12 @@ class ActivityService {
         // Build and save the activity
         let finalDoesExist = isConfirmed ? true : doesExist
 
+        let activityTimestamp: UInt64 = if existingActivity == nil, let bts = blockTimestamp, bts < paymentTimestamp {
+            bts
+        } else {
+            existingOnchain?.timestamp ?? paymentTimestamp
+        }
+
         let onchain = OnchainActivity(
             id: payment.id,
             txType: payment.direction == .outbound ? .sent : .received,
@@ -421,12 +428,12 @@ class ActivityService {
             feeRate: feeRate,
             address: address,
             confirmed: isConfirmed,
-            timestamp: paymentTimestamp,
+            timestamp: activityTimestamp,
             isBoosted: isBoosted,
             boostTxIds: boostTxIds,
             isTransfer: isTransfer,
             doesExist: finalDoesExist,
-            confirmTimestamp: confirmedTimestamp,
+            confirmTimestamp: blockTimestamp,
             channelId: channelId,
             transferTxId: transferTxId,
             createdAt: UInt64(payment.creationTime.timeIntervalSince1970),