perf(ui): collapse queued timeline reconciles, and measure what is left

DashWallet/Sources/Application/Syncyng Activity Monitor/SyncingActivityMonitor.swift

@@ -17,6 +17,7 @@
 
 import Combine
 import Foundation
+import OSLog
 import SwiftDashSDK
 
 private let kMaxProgressDelta = 0.1 // 10%
@@ -304,9 +305,37 @@ extension SyncingActivityMonitor {
 
         applyProgressWithPeakSmoothing(sdkProgress)
         isSyncing = (mapped == .syncing)
+        let wasDone = state == .syncDone
         state = mapped
+
+        // `syncDone` is derived purely from the SPV network phases — it knows
+        // nothing about how much of what was scanned is durably persisted.
+        // The two can be far apart: the durable watermark is what a relaunch
+        // resumes from, and what the transaction list is built out of, so a
+        // wallet can report "synced" while rows are still materializing.
+        //
+        // Logged at the transition rather than gated on, because whether the
+        // watermark reliably reaches the tip is exactly what is unproven. One
+        // line per completion answers it from an ordinary session.
+        if mapped == .syncDone && !wasDone {
+            logDurableWatermarkAtCompletion(scannedTip: sdkSyncProgress.headers?.currentHeight ?? 0)
+        }
     }
 
+    /// One-shot read of the persisted sync height at the moment the UI first
+    /// calls a sync complete, next to the height that was actually scanned.
+    /// A single fetch on a state transition — not a per-tick cost.
+    private func logDurableWatermarkAtCompletion(scannedTip: UInt32) {
+        guard let durable = SwiftDashSDKWalletSource.persistedSyncedHeight() else {
+            Self.logger.warning("⛓️ SYNCSTATE :: reported done at tip \(scannedTip, privacy: .public); durable watermark unavailable")
+            return
+        }
+        let behind = scannedTip > durable ? scannedTip - durable : 0
+        Self.logger.info("⛓️ SYNCSTATE :: reported done — scanned tip \(scannedTip, privacy: .public), durable watermark \(durable, privacy: .public), behind by \(behind, privacy: .public) block(s)")
+    }
+
+    private static let logger = Logger(subsystem: "org.dashfoundation.dash", category: "sync-state")
+
     /// Map SwiftDashSDK's per-phase progress to the snapshot fields the
     /// existing UI consumers expect. The phase priority order
     /// (headers → filterHeaders → filters → masternodes → finished)

DashWallet/Sources/Infrastructure/SwiftDashSDK/SwiftDashSDKSPVCoordinator.swift

@@ -552,6 +552,19 @@ public final class SwiftDashSDKSPVCoordinator: NSObject, ObservableObject {
 
     @MainActor
     private func applyProgress(_ p: PlatformSpvSyncProgress) {
+        // Everything below runs on the main actor, once per progress tick
+        // (~1Hz for as long as any sync phase advances), and reaches
+        // synchronous FFI and a main-context SwiftData fetch. Nothing here has
+        // ever been timed, so a uniform app-wide stutter during sync has no
+        // way of being attributed. Measured here rather than assumed.
+        let tickStartedAt = Date()
+        defer {
+            let heldMs = Int(Date().timeIntervalSince(tickStartedAt) * 1000)
+            if heldMs >= 50 {
+                Self.logger.warning(
+                    "🛰️ SPVCOORD :: progress tick held the main thread \(heldMs, privacy: .public)ms")
+            }
+        }
         let mappedState = mapState(p.overallState)
         let translated = SPVSyncProgress(
             state: mappedState,
@@ -603,6 +616,17 @@ public final class SwiftDashSDKSPVCoordinator: NSObject, ObservableObject {
     /// publisher was removed in the SDK refactor, so the bridge replaces it.
     @MainActor
     private func refreshBalanceBridge() {
+        // Timed separately from the tick: this is the FFI half, and knowing
+        // which half is expensive decides whether the fix is throttling the
+        // tick or moving the read off the main actor.
+        let startedAt = Date()
+        defer {
+            let ms = Int(Date().timeIntervalSince(startedAt) * 1000)
+            if ms >= 50 {
+                Self.logger.warning(
+                    "🛰️ SPVCOORD :: balance bridge held the main thread \(ms, privacy: .public)ms")
+            }
+        }
         guard let wallet = SwiftDashSDKHost.shared.wallet else {
             SwiftDashSDKWalletState.shared.clearBalance()
             return

DashWallet/Sources/UI/Home/Views/HomeViewModel.swift

@@ -43,6 +43,20 @@ enum TransactionFilterCategory: CaseIterable {
 class HomeViewModel: ObservableObject {
     private var cancellableBag = Set<AnyCancellable>()
     private let queue = DispatchQueue(label: "HomeViewModel", qos: .userInitiated)
+    /// Whether a reconcile pass is queued or running. `queue` is serial, so
+    /// without this every trigger enqueues another full pass and they drain
+    /// back-to-back — each one re-reading the window and republishing the whole
+    /// list to the main thread for a result the pass behind it is about to
+    /// replace. Main-actor state, mutated only from `reloadTxDataSource` and
+    /// `finishReloadPass`.
+    private var reloadPassInFlight = false
+    /// A trigger that arrived while a pass was in flight. Collapsed to a
+    /// single follow-up pass, so a burst of N notifications costs two passes
+    /// (the one running plus one more that sees all of it), not N.
+    private var reloadPassRequestedAgain = false
+    /// Triggers folded into the current pass — logged so the next session's
+    /// numbers say how much this actually absorbs.
+    private var reloadPassCoalesced = 0
     private var timeSkewDialogShown: Bool = false
     /// Session guard so the proactive CoinJoin-sweep popup shows at most once
     /// per launch (re-evaluated each launch while a leftover balance exists).
@@ -515,6 +529,18 @@ class HomeViewModel: ObservableObject {
         // once up front, asynchronously, keeps the pass free-running.
         let dispatch = { @MainActor [weak self] in
             guard let self else { return }
+            // A pass already owns the queue: record that the world changed
+            // again and let it re-run once when it lands. Enqueueing here
+            // instead is what produced bursts of identical rebuilds — the
+            // reported duration of each includes the wait behind the ones
+            // before it, so a backlog reads as a slow pass and every entry in
+            // it republishes the full list.
+            guard !self.reloadPassInFlight else {
+                self.reloadPassRequestedAgain = true
+                self.reloadPassCoalesced += 1
+                return
+            }
+            self.reloadPassInFlight = true
             // Pair each request with the filter selection that was live when
             // it was made. Reading it inside the pass instead would let a pass
             // triggered by one change render a selection the user made after
@@ -523,6 +549,7 @@ class HomeViewModel: ObservableObject {
             let startedAt = Date()
             self.queue.async { [weak self] in
                 self?.performReload(selectedFilters: selectedFilters, startedAt: startedAt)
+                self?.finishReloadPass()
             }
         }
         if Thread.isMainThread {
@@ -532,7 +559,30 @@ class HomeViewModel: ObservableObject {
         }
     }
 
+    /// Release the pass and, if the world moved while it ran, run exactly one
+    /// more. Called outside `performReload` so every early return in it — an
+    /// unbound host, a nil delta — still releases.
+    private func finishReloadPass() {
+        DispatchQueue.main.async { MainActor.assumeIsolated { [weak self] in
+            guard let self else { return }
+            let coalesced = self.reloadPassCoalesced
+            self.reloadPassCoalesced = 0
+            self.reloadPassInFlight = false
+            if coalesced > 0 {
+                DWLogger.log("HomeViewModel: coalesced \(coalesced) reconcile trigger(s) into that pass")
+            }
+            guard self.reloadPassRequestedAgain else { return }
+            self.reloadPassRequestedAgain = false
+            self.reloadTxDataSource()
+        } }
+    }
+
     private func performReload(selectedFilters: Set<TransactionFilterCategory>, startedAt: Date) {
+        // `startedAt` is stamped when the pass was REQUESTED, on the main
+        // actor. `workStartedAt` is when it actually got the queue. Reporting
+        // only their sum reads a backlog as a slow pass — which is exactly how
+        // a burst of triggers used to look like one 21-second rebuild.
+        let workStartedAt = Date()
         DWLogger.log("HomeViewModel: Starting timeline reconcile")
 
         // --- Stage 1: bring the wrapped-row window up to date. Every
@@ -586,7 +636,11 @@ class HomeViewModel: ObservableObject {
         }
 
         // --- Stage 3: rebuild the visible list from the in-memory window.
-        rebuildTimelineItems(selectedFilters: selectedFilters, startedAt: startedAt, pageCompleted: false)
+        rebuildTimelineItems(
+            selectedFilters: selectedFilters,
+            startedAt: startedAt,
+            workStartedAt: workStartedAt,
+            pageCompleted: false)
     }
 
     /// Replace the window cache with a freshly fetched first page.
@@ -659,6 +713,7 @@ class HomeViewModel: ObservableObject {
         let startedAt = Date()
         queue.async { [weak self] in
             guard let self else { return }
+            let workStartedAt = Date()
             guard self.hasOlderHistory, self.windowOldestDayStart > 0,
                   let page = self.transactionSource.olderTimelinePage(
                       endingBefore: self.windowOldestDayStart,
@@ -678,7 +733,11 @@ class HomeViewModel: ObservableObject {
             // its rows' `lastUpdated` can postdate window updates the next
             // delta still has to pick up.
             DWLogger.log("HomeViewModel: Timeline paged to \(self.windowTxs.count) rows, older history: \(self.hasOlderHistory)")
-            self.rebuildTimelineItems(selectedFilters: selectedFilters, startedAt: startedAt, pageCompleted: true)
+            self.rebuildTimelineItems(
+                selectedFilters: selectedFilters,
+                startedAt: startedAt,
+                workStartedAt: workStartedAt,
+                pageCompleted: true)
         }
     }
 
@@ -711,6 +770,7 @@ class HomeViewModel: ObservableObject {
     private func rebuildTimelineItems(
         selectedFilters: Set<TransactionFilterCategory>,
         startedAt: Date,
+        workStartedAt: Date,
         pageCompleted: Bool
     ) {
         let transactions = timelineInputTransactions()
@@ -846,8 +906,10 @@ class HomeViewModel: ObservableObject {
             return TransactionGroup(id: key, date: first.date, items: items)
         }.sorted { $0.date > $1.date }
 
-        let elapsedMs = Int(Date().timeIntervalSince(startedAt) * 1000)
-        DWLogger.log("HomeViewModel: Timeline rebuild complete in \(elapsedMs)ms, \(array.count) groups, \(self.txByHash.count) items cached, window \(windowTxs.count) rows")
+        let now = Date()
+        let elapsedMs = Int(now.timeIntervalSince(startedAt) * 1000)
+        let workMs = Int(now.timeIntervalSince(workStartedAt) * 1000)
+        DWLogger.log("HomeViewModel: Timeline rebuild complete in \(elapsedMs)ms (queued \(max(0, elapsedMs - workMs))ms, work \(workMs)ms), \(array.count) groups, \(self.txByHash.count) items cached, window \(windowTxs.count) rows")
 
         publishTimeline(
             array,
@@ -904,7 +966,13 @@ class HomeViewModel: ObservableObject {
         pageCompleted: Bool
     ) {
         let canLoadMore = hasOlderHistory
+        let groupCount = array.count
         DispatchQueue.main.async {
+            // The one part of a reconcile that is unavoidably main-thread:
+            // assigning `txItems` republishes the whole list and SwiftUI diffs
+            // it. Timed so the cost of republishing is a number rather than an
+            // inference.
+            let publishStartedAt = Date()
             self.txItems = array
             self.hasLoadedInitialTxItems = true
             if self.canLoadMoreHistory != canLoadMore {
@@ -920,6 +988,10 @@ class HomeViewModel: ObservableObject {
             if self.hasMasternodeHistory != hasMasternodes {
                 self.hasMasternodeHistory = hasMasternodes
             }
+            let publishMs = Int(Date().timeIntervalSince(publishStartedAt) * 1000)
+            if publishMs >= 50 {
+                DWLogger.log("HomeViewModel: publish held the main thread \(publishMs)ms for \(groupCount) groups")
+            }
         }
     }
 
@@ -2370,6 +2442,21 @@ class SwiftDashSDKWalletSource: TransactionSource {
     /// cheap enough to block a worker queue on). `ModelContainer` is
     /// `Sendable`, so the caller then opens its own `ModelContext` on its
     /// own thread and all SwiftData work stays there.
+    /// The durable sync watermark the persister last wrote for the active
+    /// wallet — the height a relaunch resumes from, and the boundary below
+    /// which the transaction list is materialized. Distinct from the height
+    /// the SPV scan has reached, which is what the sync UI reports.
+    ///
+    /// One bounded fetch; call it on a state transition, not per tick.
+    static func persistedSyncedHeight() -> UInt32? {
+        guard let (container, walletId) = hostHandles() else { return nil }
+        let context = ModelContext(container)
+        var descriptor = FetchDescriptor<PersistentWallet>(
+            predicate: #Predicate { $0.walletId == walletId })
+        descriptor.fetchLimit = 1
+        return (try? context.fetch(descriptor))?.first?.syncedHeight
+    }
+
     private static func hostHandles() -> (container: ModelContainer, walletId: Data)? {
         onMain {
             guard let container = SwiftDashSDKHost.shared.modelContainer,

DashWallet/Sources/UI/Payments/InternalTransfer/InternalTransferViewModel.swift

@@ -57,14 +57,28 @@ enum CoreToShieldedAmountPolicy {
     /// (50_000 duffs) × 1000 credits/duff.
     static let assetLockBaseCostCredits: UInt64 = 50_000_000
 
+    /// Cached: this is read from `amountValidationMessage` and `canContinue`,
+    /// both of which a SwiftUI `body` evaluates — so an uncached property
+    /// crosses into Rust on every render and every keystroke. The value is a
+    /// pure function of the protocol version and the fixed `(transfer, 2)`
+    /// shape, so it cannot change within a launch.
+    private static var cachedPoolFeeCredits: UInt64??
+
     static var poolFeeCredits: UInt64? {
+        if let cached = cachedPoolFeeCredits { return cached }
         guard let shieldedFee = try? PlatformWalletManager.estimateShieldedFee(
             kind: .transfer,
             numActions: 2)
-        else { return nil }
+        else {
+            // Not cached: a failed estimate is a transient FFI condition, and
+            // caching it would keep the screen permanently unusable.
+            return nil
+        }
 
         let (total, overflow) = shieldedFee.addingReportingOverflow(assetLockBaseCostCredits)
-        return overflow ? nil : total
+        let value: UInt64? = overflow ? nil : total
+        cachedPoolFeeCredits = .some(value)
+        return value
     }
 
     /// User-entered Core amounts have duff precision (1000 Platform credits).