Filter RBF txs

Author: ben-kaufman

Bitkit/Services/CoreService.swift

@@ -25,6 +25,42 @@ class ActivityService {
     /// Maximum address index to search when current address exists
     private static let maxAddressSearchIndex: UInt32 = 100_000
 
+    // MARK: - BoostTxIds Cache
+
+    // Cached set of transaction IDs that appear in boostTxIds (for filtering replaced transactions)
+    private var cachedTxIdsInBoostTxIds: Set<String> = []
+
+    /// Get the set of transaction IDs that appear in boostTxIds (cached for performance)
+    func getTxIdsInBoostTxIds() async -> Set<String> {
+        if cachedTxIdsInBoostTxIds.isEmpty {
+            await refreshBoostTxIdsCache()
+        }
+        return cachedTxIdsInBoostTxIds
+    }
+
+    private func updateBoostTxIdsCache(for activity: Activity) {
+        if case let .onchain(onchain) = activity {
+            cachedTxIdsInBoostTxIds.formUnion(onchain.boostTxIds)
+        }
+    }
+
+    private func refreshBoostTxIdsCache() async {
+        do {
+            let allOnchainActivities = try await get(filter: .onchain)
+            var txIds: Set<String> = []
+            for activity in allOnchainActivities {
+                if case let .onchain(onchain) = activity {
+                    txIds.formUnion(onchain.boostTxIds)
+                }
+            }
+            await MainActor.run {
+                self.cachedTxIdsInBoostTxIds = txIds
+            }
+        } catch {
+            Logger.error("Failed to refresh boostTxIds cache: \(error)", context: "ActivityService")
+        }
+    }
+
     // MARK: - Transaction Status Checks
 
     func wasTransactionReplaced(txid: String) async -> Bool {
@@ -125,20 +161,24 @@ class ActivityService {
                 _ = try deleteActivityById(activityId: id)
             }
 
+            // Clear cache since all activities are deleted
+            self.cachedTxIdsInBoostTxIds.removeAll()
             self.activitiesChangedSubject.send()
         }
     }
 
     func insert(_ activity: Activity) async throws {
         try await ServiceQueue.background(.core) {
             try insertActivity(activity: activity)
+            self.updateBoostTxIdsCache(for: activity)
             self.activitiesChangedSubject.send()
         }
     }
 
     func upsertList(_ activities: [Activity]) async throws {
         try await ServiceQueue.background(.core) {
             try upsertActivities(activities: activities)
+            await self.refreshBoostTxIdsCache()
         }
     }
 
@@ -308,10 +348,7 @@ class ActivityService {
             // Find the activity for the replaced transaction
             let replacedActivity = try await self.getOnchainActivityByTxId(txid: txid)
 
-            let replacedTags: [String]
             if var existing = replacedActivity {
-                replacedTags = await (try? self.tags(forActivity: existing.id)) ?? []
-
                 Logger.info(
                     "Transaction \(txid) replaced by \(conflicts.count) conflict(s): \(conflicts.joined(separator: ", "))",
                     context: "CoreService.handleOnchainTransactionReplaced"
@@ -323,9 +360,8 @@ class ActivityService {
                 try await self.update(id: existing.id, activity: .onchain(existing))
                 Logger.info("Marked transaction \(txid) as replaced", context: "CoreService.handleOnchainTransactionReplaced")
             } else {
-                replacedTags = []
                 Logger.info(
-                    "Activity not found for replaced transaction \(txid) - was deleted by initiated RBF, tags in pre-activity metadata",
+                    "Activity not found for replaced transaction \(txid) - will be created when transaction is processed",
                     context: "CoreService.handleOnchainTransactionReplaced"
                 )
             }
@@ -369,13 +405,16 @@ class ActivityService {
                     activity.updatedAt = UInt64(Date().timeIntervalSince1970)
                     try await self.update(id: activity.id, activity: .onchain(activity))
 
-                    // Apply tags from the replaced transaction
-                    if !replacedTags.isEmpty {
+                    // Move tags from the replaced transaction
+                    if let replacedActivity {
                         do {
-                            try await self.appendTags(toActivity: activity.id, replacedTags)
+                            let replacedTags = try await self.tags(forActivity: replacedActivity.id)
+                            if !replacedTags.isEmpty {
+                                try await self.appendTags(toActivity: activity.id, replacedTags)
+                            }
                         } catch {
                             Logger.error(
-                                "Failed to apply tags from replaced transaction \(txid) to replacement transaction \(conflictTxid): \(error)",
+                                "Failed to copy tags from replaced transaction \(txid) to replacement transaction \(conflictTxid): \(error)",
                                 context: "CoreService.handleOnchainTransactionReplaced"
                             )
                         }
@@ -792,19 +831,27 @@ class ActivityService {
     func update(id: String, activity: Activity) async throws {
         try await ServiceQueue.background(.core) {
             try updateActivity(activityId: id, activity: activity)
+            self.updateBoostTxIdsCache(for: activity)
             self.activitiesChangedSubject.send()
         }
     }
 
     func upsert(_ activity: Activity) async throws {
         try await ServiceQueue.background(.core) {
             try upsertActivity(activity: activity)
+            self.updateBoostTxIdsCache(for: activity)
             self.activitiesChangedSubject.send()
         }
     }
 
     func delete(id: String) async throws -> Bool {
         try await ServiceQueue.background(.core) {
+            // Rebuild cache if deleting an onchain activity with boostTxIds
+            let activity = try? getActivityById(activityId: id)
+            if let activity, case let .onchain(onchain) = activity, !onchain.boostTxIds.isEmpty {
+                await self.refreshBoostTxIdsCache()
+            }
+
             let result = try deleteActivityById(activityId: id)
             self.activitiesChangedSubject.send()
             return result
@@ -951,35 +998,12 @@ class ActivityService {
 
                 Logger.info("RBF transaction created successfully: \(txid)", context: "CoreService.boostOnchainTransaction")
 
-                // Get tags from the old activity before deleting it
-                let oldTags = await (try? self.tags(forActivity: activityId)) ?? []
-
-                // Create pre-activity metadata for the replacement transaction with tags from the old activity
-                if !oldTags.isEmpty {
-                    let currentTime = UInt64(Date().timeIntervalSince1970)
-                    let preActivityMetadata = BitkitCore.PreActivityMetadata(
-                        paymentId: txid,
-                        tags: oldTags,
-                        paymentHash: nil,
-                        txId: txid,
-                        address: onchainActivity.address,
-                        isReceive: false,
-                        feeRate: UInt64(feeRate),
-                        isTransfer: onchainActivity.isTransfer,
-                        channelId: onchainActivity.channelId,
-                        createdAt: currentTime
-                    )
-                    try? await self.addPreActivityMetadata(preActivityMetadata)
-                    Logger.info(
-                        "Created pre-activity metadata with \(oldTags.count) tag(s) for RBF replacement transaction \(txid)",
-                        context: "CoreService.boostOnchainTransaction"
-                    )
-                }
-
-                // For RBF we initiated, delete the old activity
-                _ = try await self.delete(id: activityId)
+                // For RBF, mark the original activity as doesExist = false instead of deleting it
+                // This allows it to be displayed with the "removed" status
+                onchainActivity.doesExist = false
+                try await self.update(id: activityId, activity: .onchain(onchainActivity))
                 Logger.info(
-                    "Successfully deleted activity \(activityId) (replaced by RBF transaction \(txid))",
+                    "Successfully marked activity \(activityId) as doesExist = false (replaced by RBF)",
                     context: "CoreService.boostOnchainTransaction"
                 )
             }

Bitkit/ViewModels/ActivityListViewModel.swift

@@ -144,12 +144,18 @@ class ActivityListViewModel: ObservableObject {
         do {
             // Get latest activities first as that's displayed on the home view
             let limitLatest: UInt32 = 3
-            latestActivities = try await coreService.activity.get(filter: .all, limit: limitLatest)
+            // Fetch extra to account for potential filtering of replaced transactions
+            let latest = try await coreService.activity.get(filter: .all, limit: limitLatest * 3)
+            let filtered = await filterOutReplacedSentTransactions(latest)
+            latestActivities = Array(filtered.prefix(Int(limitLatest)))
 
             // Fetch all activities
             await updateFilteredActivities()
-            lightningActivities = try await coreService.activity.get(filter: .lightning)
-            onchainActivities = try await coreService.activity.get(filter: .onchain)
+
+            let lightningActivities = try await coreService.activity.get(filter: .lightning)
+
+            let onchain = try await coreService.activity.get(filter: .onchain)
+            onchainActivities = await filterOutReplacedSentTransactions(onchain)
 
             // Update available tags and fee estimates
             await updateAvailableTags()
@@ -198,8 +204,11 @@ class ActivityListViewModel: ObservableObject {
                 maxDate: maxDate
             )
 
+            // Filter out replaced sent transactions that appear in another transaction's boostTxIds
+            let filteredOutReplaced = await filterOutReplacedSentTransactions(baseFilteredActivities)
+
             // Apply tab filtering
-            filteredActivities = filterActivitiesByTab(baseFilteredActivities, selectedTab: selectedTab)
+            filteredActivities = filterActivitiesByTab(filteredOutReplaced, selectedTab: selectedTab)
 
             // Update grouped activities
             updateGroupedActivities()
@@ -449,6 +458,26 @@ extension ActivityListViewModel {
         }
     }
 
+    /// Filter out replaced sent transactions that appear in another transaction's boostTxIds
+    private func filterOutReplacedSentTransactions(_ activities: [Activity]) async -> [Activity] {
+        // Get cached set of txIds that appear in boostTxIds
+        let txIdsInBoostTxIds = await coreService.activity.getTxIdsInBoostTxIds()
+
+        // Filter out activities that:
+        // 1. Are onchain
+        // 2. Have doesExist = false
+        // 3. Are sent transactions
+        // 4. Appear in another transaction's boostTxIds
+        return activities.filter { activity in
+            if case let .onchain(onchain) = activity {
+                if !onchain.doesExist && onchain.txType == .sent && txIdsInBoostTxIds.contains(onchain.txId) {
+                    return false
+                }
+            }
+            return true
+        }
+    }
+
     /// Filter activities based on the selected tab
     private func filterActivitiesByTab(_ activities: [Activity], selectedTab: ActivityTab) -> [Activity] {
         switch selectedTab {