fix: migrate activities for unsupported addresses

Author: ben-kaufman

Bitkit/Services/CoreService.swift

@@ -338,7 +338,12 @@ class ActivityService {
         guard case let .onchain(txid, _) = payment.kind else { return }
 
         let paymentTimestamp = payment.latestUpdateTimestamp
-        let existingActivity = try getActivityById(activityId: payment.id)
+
+        // Look for existing activity by id first, then by txid (for migrated activities)
+        var existingActivity = try getActivityById(activityId: payment.id)
+        if existingActivity == nil {
+            existingActivity = try BitkitCore.getActivityByTxId(txId: txid).map { .onchain($0) }
+        }
 
         // Skip if existing activity has newer timestamp to avoid overwriting local data
         if let existingActivity, case let .onchain(existing) = existingActivity {
@@ -348,9 +353,6 @@ class ActivityService {
             }
         }
 
-        // Determine confirmation status from payment's txStatus
-        let value = payment.amountSats ?? 0
-
         // Determine confirmation status from payment's txStatus
         var blockTimestamp: UInt64?
         let isConfirmed: Bool
@@ -381,6 +383,13 @@ class ActivityService {
         let doesExist = existingOnchain?.doesExist ?? true
         let seenAt = existingOnchain?.seenAt
 
+        let ldkValue = payment.amountSats ?? 0
+        let value: UInt64 = if let existingValue = existingOnchain?.value, existingValue > ldkValue {
+            existingValue
+        } else {
+            ldkValue
+        }
+
         // Check if this transaction is a channel transfer
         if channelId == nil || !isTransfer {
             let foundChannelId = await findChannelForTransaction(
@@ -441,8 +450,8 @@ class ActivityService {
             seenAt: seenAt
         )
 
-        if existingActivity != nil {
-            try await update(id: payment.id, activity: .onchain(onchain))
+        if let existingActivity, case let .onchain(existing) = existingActivity {
+            try await update(id: existing.id, activity: .onchain(onchain))
         } else {
             try await upsert(.onchain(onchain))
         }

Bitkit/Services/MigrationsService.swift

@@ -1200,11 +1200,6 @@ extension MigrationsService {
     func reapplyMetadataAfterSync() async {
         // Handle MMKV (local) migration data
         if hasRNMmkvData(), let mmkvData = loadRNMmkvData() {
-            if let metadata = extractRNMetadata(from: mmkvData) {
-                Logger.info("Re-applying MMKV metadata after sync", context: "Migration")
-                await applyAllMetadata(metadata)
-            }
-
             if let activities = extractRNActivities(from: mmkvData) {
                 await applyOnchainMetadata(activities)
             }
@@ -1220,6 +1215,11 @@ extension MigrationsService {
                     await applyBoostTransactions(walletBackup.boosts)
                 }
             }
+
+            if let metadata = extractRNMetadata(from: mmkvData) {
+                Logger.info("Re-applying MMKV metadata after sync", context: "Migration")
+                await applyAllMetadata(metadata)
+            }
         }
 
         // Handle remote backup data (for on-chain timestamps from RN backup)
@@ -1243,7 +1243,7 @@ extension MigrationsService {
             pendingRemoteBoosts = nil
         }
 
-        // Apply stored metadata (all tags after sync when activities exist)
+        // Apply stored metadata (all tags after activities are imported)
         if let metadata = pendingRemoteMetadata {
             Logger.info("Applying stored metadata after sync", context: "Migration")
             await applyAllMetadata(metadata)
@@ -1374,63 +1374,123 @@ extension MigrationsService {
 
     private func applyOnchainMetadata(_ items: [RNActivityItem]) async {
         let onchainItems = items.filter { $0.activityType == "onchain" }
+        var updatedCount = 0
+        var createdCount = 0
+
         for item in onchainItems {
-            guard let txId = item.txId ?? (item.id.isEmpty ? nil : item.id),
-                  var onchain = try? await CoreService.shared.activity.getOnchainActivityByTxId(txid: txId)
-            else {
+            guard let txId = item.txId ?? (item.id.isEmpty ? nil : item.id) else {
                 continue
             }
 
-            if item.timestamp > 0 {
-                onchain.timestamp = UInt64(item.timestamp / 1000)
-            }
-            if let confirmTs = item.confirmTimestamp, confirmTs > 0 {
-                onchain.confirmTimestamp = UInt64(confirmTs / 1000)
-            }
-            if item.isTransfer == true {
-                onchain.isTransfer = true
-                onchain.channelId = item.channelId
-                onchain.transferTxId = item.transferTxId
-            }
+            // Try to get existing activity (synced by LDK)
+            if var onchain = try? await CoreService.shared.activity.getOnchainActivityByTxId(txid: txId) {
+                // Activity exists, update metadata
+                if item.timestamp > 0 {
+                    onchain.timestamp = UInt64(item.timestamp / 1000)
+                }
+                if let confirmTs = item.confirmTimestamp, confirmTs > 0 {
+                    onchain.confirmTimestamp = UInt64(confirmTs / 1000)
+                }
+                if item.isTransfer == true {
+                    onchain.isTransfer = true
+                    onchain.channelId = item.channelId
+                    onchain.transferTxId = item.transferTxId
+                }
 
-            if let boostedParents = item.boostedParents, !boostedParents.isEmpty {
-                for parentTxId in boostedParents {
-                    if var parentOnchain = try? await CoreService.shared.activity.getOnchainActivityByTxId(txid: parentTxId) {
-                        if !parentOnchain.boostTxIds.contains(txId) {
-                            parentOnchain.boostTxIds.append(txId)
-                        }
-                        parentOnchain.isBoosted = true
+                if let boostedParents = item.boostedParents, !boostedParents.isEmpty {
+                    await applyBoostedParents(boostedParents, childTxId: txId)
+                    onchain.isBoosted = false
+                    onchain.boostTxIds.removeAll { boostedParents.contains($0) }
+                } else if item.isBoosted == true {
+                    onchain.isBoosted = true
+                }
 
-                        do {
-                            try await CoreService.shared.activity.update(id: parentOnchain.id, activity: .onchain(parentOnchain))
-                        } catch {
-                            Logger.error("Failed to mark parent \(parentTxId) as boosted for CPFP: \(error)", context: "Migration")
-                        }
-                    }
+                if let feeRate = item.feeRate, feeRate > 0 {
+                    onchain.feeRate = UInt64(feeRate)
                 }
-                onchain.isBoosted = false
-                onchain.boostTxIds.removeAll { boostedParents.contains($0) }
-            } else if item.isBoosted == true {
-                onchain.isBoosted = true
-            }
 
-            if let feeRate = item.feeRate, feeRate > 0 {
-                onchain.feeRate = UInt64(feeRate)
-            }
+                // Preserve higher value from backup (handles mixed input txs with unsupported addresses)
+                let backupValue = UInt64(item.value)
+                if backupValue > onchain.value {
+                    onchain.value = backupValue
+                }
 
-            if let address = item.address, !address.isEmpty {
-                onchain.address = address
-            }
+                // Preserve higher fee from backup
+                if let backupFee = item.fee, UInt64(backupFee) > onchain.fee {
+                    onchain.fee = UInt64(backupFee)
+                }
 
-            do {
-                try await CoreService.shared.activity.update(id: onchain.id, activity: .onchain(onchain))
-            } catch {
-                Logger.error("Failed to update onchain metadata for \(txId): \(error)", context: "Migration")
+                if let address = item.address, !address.isEmpty {
+                    onchain.address = address
+                }
+
+                do {
+                    try await CoreService.shared.activity.update(id: onchain.id, activity: .onchain(onchain))
+                    updatedCount += 1
+                } catch {
+                    Logger.error("Failed to update onchain metadata for \(txId): \(error)", context: "Migration")
+                }
+            } else {
+                let timestampSecs = UInt64(item.timestamp / 1000)
+                let now = UInt64(Date().timeIntervalSince1970)
+                let activityTimestamp = timestampSecs > 0 ? timestampSecs : now
+
+                let onchain = BitkitCore.OnchainActivity(
+                    id: item.id,
+                    txType: item.txType == "sent" ? .sent : .received,
+                    txId: txId,
+                    value: UInt64(item.value),
+                    fee: item.fee.map { UInt64($0) } ?? 0,
+                    feeRate: item.feeRate.map { UInt64($0) } ?? 1,
+                    address: item.address ?? "",
+                    confirmed: item.confirmed ?? false,
+                    timestamp: activityTimestamp,
+                    isBoosted: item.isBoosted ?? false,
+                    boostTxIds: [],
+                    isTransfer: item.isTransfer ?? false,
+                    doesExist: item.exists ?? true,
+                    confirmTimestamp: item.confirmTimestamp.map { UInt64($0 / 1000) },
+                    channelId: item.channelId,
+                    transferTxId: item.transferTxId,
+                    createdAt: activityTimestamp,
+                    updatedAt: activityTimestamp,
+                    seenAt: now
+                )
+
+                do {
+                    try await CoreService.shared.activity.upsert(.onchain(onchain))
+                    createdCount += 1
+
+                    if let boostedParents = item.boostedParents, !boostedParents.isEmpty {
+                        await applyBoostedParents(boostedParents, childTxId: txId)
+                    }
+                } catch {
+                    Logger.error("Failed to import onchain activity from backup \(txId): \(error)", context: "Migration")
+                }
             }
         }
 
-        if !onchainItems.isEmpty {
-            Logger.info("Applied metadata to \(onchainItems.count) onchain activities", context: "Migration")
+        if updatedCount > 0 || createdCount > 0 {
+            Logger.info(
+                "Applied metadata to \(updatedCount) onchain activities, imported \(createdCount) from backup",
+                context: "Migration"
+            )
+        }
+    }
+
+    private func applyBoostedParents(_ boostedParents: [String], childTxId: String) async {
+        for parentTxId in boostedParents {
+            if var parentOnchain = try? await CoreService.shared.activity.getOnchainActivityByTxId(txid: parentTxId) {
+                if !parentOnchain.boostTxIds.contains(childTxId) {
+                    parentOnchain.boostTxIds.append(childTxId)
+                }
+                parentOnchain.isBoosted = true
+                do {
+                    try await CoreService.shared.activity.update(id: parentOnchain.id, activity: .onchain(parentOnchain))
+                } catch {
+                    Logger.error("Failed to mark parent \(parentTxId) as boosted for CPFP: \(error)", context: "Migration")
+                }
+            }
         }
     }