Merge pull request #462 from synonymdev/fix/reimport-channel-monitor

fix: recover orphaned channel monitors from RN migration

Author: jvsena42

Bitkit/Services/CoreService.swift

@@ -1005,6 +1005,11 @@ class ActivityService {
         }
     }
 
+    /// Checks if an on-chain activity exists for a given txid (e.g., a sweep tx has been synced)
+    func hasOnchainActivityForTxid(txid: String) async -> Bool {
+        await (try? getOnchainActivityByTxId(txid: txid)) != nil
+    }
+
     /// Checks if an on-chain activity exists for a given channel (e.g., close tx has been synced)
     func hasOnchainActivityForChannel(channelId: String) async -> Bool {
         guard let activities = try? await get(filter: .onchain, limit: 50, sortDirection: .desc) else {

Bitkit/Services/MigrationsService.swift

@@ -336,6 +336,7 @@ class MigrationsService: ObservableObject {
     private static let rnPendingChannelMigrationKey = "rnPendingChannelMigration"
     private static let rnPendingBlocktankOrderIdsKey = "rnPendingBlocktankOrderIds"
     private static let rnDidAttemptPeerRecoveryKey = "rnDidAttemptMigrationPeerRecovery"
+    private static let rnChannelRecoveryCheckedKey = "rnChannelRecoveryChecked"
     private static let didCleanupInvalidTransfersKey = "didCleanupInvalidMigrationTransfers"
 
     @Published var isShowingMigrationLoading = false {
@@ -434,6 +435,12 @@ class MigrationsService: ObservableObject {
         set { UserDefaults.standard.set(newValue, forKey: Self.rnDidAttemptPeerRecoveryKey) }
     }
 
+    /// True after we've checked for orphaned channel monitors (so we don't retry every node start if all succeeded).
+    var isChannelRecoveryChecked: Bool {
+        get { UserDefaults.standard.bool(forKey: Self.rnChannelRecoveryCheckedKey) }
+        set { UserDefaults.standard.set(newValue, forKey: Self.rnChannelRecoveryCheckedKey) }
+    }
+
     /// True if the user completed RN migration (local or remote).
     var rnMigrationCompleted: Bool {
         UserDefaults.standard.bool(forKey: Self.rnMigrationCompletedKey)
@@ -1998,13 +2005,16 @@ extension MigrationsService {
         return nil
     }
 
-    private func fetchRNRemoteLdkData() async {
+    /// Fetches channel manager and monitors from RN remote backup.
+    /// Returns `true` if all monitors were successfully retrieved (or none exist), `false` if some failed.
+    @discardableResult
+    func fetchRNRemoteLdkData() async -> Bool {
         do {
             let files = try await RNBackupClient.shared.listFiles(fileGroup: "ldk")
 
             guard let managerData = try? await RNBackupClient.shared.retrieve(label: "channel_manager", fileGroup: "ldk") else {
                 Logger.debug("No channel_manager found in remote LDK backup", context: "Migration")
-                return
+                return true
             }
 
             let expectedCount = files.channel_monitors.count
@@ -2046,8 +2056,11 @@ extension MigrationsService {
                 )
                 Logger.info("Prepared \(monitors.count)/\(expectedCount) channel monitors for migration", context: "Migration")
             }
+
+            return failedMonitors.isEmpty
         } catch {
             Logger.error("Failed to fetch remote LDK data: \(error)", context: "Migration")
+            return false
         }
     }
 

Bitkit/Services/TransferService.swift

@@ -172,7 +172,48 @@ class TransferService {
                             try await markSettled(id: transfer.id)
                             Logger.debug("Force close sweep detected, settled transfer: \(transfer.id)", context: "TransferService")
                         } else {
-                            Logger.debug("Force close awaiting sweep detection for transfer: \(transfer.id)", context: "TransferService")
+                            // When LDK batches sweeps from multiple channels into one transaction,
+                            // the onchain activity may only be linked to one channel. Fall back to
+                            // checking if there are no remaining pending sweep balances for this channel.
+                            var sweepSpendingTxid: String?
+                            let hasPendingSweep = balances?.pendingBalancesFromChannelClosures.contains(where: { sweep in
+                                switch sweep {
+                                case let .pendingBroadcast(sweepChannelId, _):
+                                    return sweepChannelId == channelId
+                                case let .broadcastAwaitingConfirmation(sweepChannelId, _, latestSpendingTxid, _):
+                                    if sweepChannelId == channelId {
+                                        sweepSpendingTxid = latestSpendingTxid.description
+                                        return true
+                                    }
+                                    return false
+                                case let .awaitingThresholdConfirmations(sweepChannelId, latestSpendingTxid, _, _, _):
+                                    if sweepChannelId == channelId {
+                                        sweepSpendingTxid = latestSpendingTxid.description
+                                        return true
+                                    }
+                                    return false
+                                }
+                            }) ?? false
+
+                            if !hasPendingSweep {
+                                try await markSettled(id: transfer.id)
+                                Logger.debug(
+                                    "Force close sweep completed (no pending sweeps), settled transfer: \(transfer.id)",
+                                    context: "TransferService"
+                                )
+                            } else if let sweepTxid = sweepSpendingTxid,
+                                      await coreService.activity.hasOnchainActivityForTxid(txid: sweepTxid)
+                            {
+                                // The sweep tx was already synced as an onchain activity (linked to another
+                                // channel in the same batched sweep). Safe to settle this transfer.
+                                try await markSettled(id: transfer.id)
+                                Logger.debug(
+                                    "Force close batched sweep detected via txid \(sweepTxid), settled transfer: \(transfer.id)",
+                                    context: "TransferService"
+                                )
+                            } else {
+                                Logger.debug("Force close awaiting sweep detection for transfer: \(transfer.id)", context: "TransferService")
+                            }
                         }
                     } else {
                         // For coop closes and other types, settle immediately when balance is gone

Bitkit/ViewModels/WalletViewModel.swift

@@ -136,6 +136,21 @@ class WalletViewModel: ObservableObject {
                 MigrationsService.shared.pendingChannelMigration = nil
             }
 
+            // If no local migration data, try fetching from RN remote backup (one-time)
+            if channelMigration == nil {
+                let (remoteMigration, allRetrieved) = await fetchOrphanedChannelMonitorsIfNeeded(walletIndex: walletIndex)
+                if let remoteMigration {
+                    channelMigration = ChannelDataMigration(
+                        channelManager: [UInt8](remoteMigration.channelManager),
+                        channelMonitors: remoteMigration.channelMonitors.map { [UInt8]($0) }
+                    )
+                    MigrationsService.shared.pendingChannelMigration = nil
+                }
+                if allRetrieved {
+                    MigrationsService.shared.isChannelRecoveryChecked = true
+                }
+            }
+
             await runLegacyNetworkGraphCleanupIfNeeded()
 
             try await lightningService.setup(
@@ -236,6 +251,43 @@ class WalletViewModel: ObservableObject {
         }
     }
 
+    /// Fetches orphaned channel monitors from RN remote backup before LDK setup.
+    /// Returns (migration data if found, whether all monitors were successfully retrieved).
+    private func fetchOrphanedChannelMonitorsIfNeeded(walletIndex: Int) async -> (PendingChannelMigration?, Bool) {
+        let migrations = MigrationsService.shared
+        guard !migrations.isChannelRecoveryChecked else { return (nil, true) }
+
+        Logger.info("Running pre-startup channel monitor recovery check", context: "WalletViewModel")
+
+        do {
+            guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: walletIndex)) else {
+                Logger.debug("Channel recovery: no mnemonic, skipping", context: "WalletViewModel")
+                migrations.isChannelRecoveryChecked = true
+                return (nil, true)
+            }
+            let passphrase = try? Keychain.loadString(key: .bip39Passphrase(index: walletIndex))
+
+            RNBackupClient.shared.reset()
+            try await RNBackupClient.shared.setup(mnemonic: mnemonic, passphrase: passphrase)
+
+            let allRetrieved = await migrations.fetchRNRemoteLdkData()
+
+            if let migration = migrations.pendingChannelMigration {
+                Logger.info(
+                    "Found \(migration.channelMonitors.count) monitors on RN backup for pre-startup recovery",
+                    context: "WalletViewModel"
+                )
+                return (migration, allRetrieved)
+            } else {
+                Logger.info("No channel monitors found on RN backup", context: "WalletViewModel")
+                return (nil, allRetrieved)
+            }
+        } catch {
+            Logger.error("Pre-startup channel monitor fetch failed: \(error)", context: "WalletViewModel")
+            return (nil, false)
+        }
+    }
+
     private func fetchTrustedPeersFromBlocktank() async -> [LnPeer]? {
         switch Self.peerSimulation {
         case .apiFailure: