fix(swift-sdk): keep deep core diagnostics off startup

Author: llbartekll

packages/swift-sdk/Sources/SwiftDashSDK/PlatformWallet/CoreWalletDiagnosticAnalyzers.swift

@@ -192,13 +192,13 @@ enum CoreWalletDiagnosticAnalyzer {
             case invalidAccountType = "invalid_account_type"
         }
 
-        let txo: CoreWalletDatabaseDiagnosticSnapshot.Txo
+        /// Only the fields required by the restore summary. Keeping this
+        /// intentionally small prevents the launch-time callback from doing
+        /// any diagnostic outpoint/script materialization or fingerprinting.
+        let amount: UInt64
         let accountType: UInt32?
         let standardTag: UInt8?
         let rejectionReason: RejectionReason?
-        let isCoinbase: Bool
-        let isConfirmed: Bool
-        let isInstantLocked: Bool
     }
 
     struct RestoreBufferSummary: Sendable {
@@ -237,23 +237,23 @@ enum CoreWalletDiagnosticAnalyzer {
         let emittedCoinJoin = emittedCandidates.filter { $0.accountType == 1 }
         return RestoreBufferSummary(
             candidateCount: candidates.count,
-            candidateValueDuffs: diagnosticSaturatingSum(candidates.map(\.txo.amount)),
+            candidateValueDuffs: diagnosticSaturatingSum(candidates.map(\.amount)),
             candidateBip44Count: candidateBip44.count,
             candidateBip44ValueDuffs: diagnosticSaturatingSum(
-                candidateBip44.map(\.txo.amount)
+                candidateBip44.map(\.amount)
             ),
             candidateCoinJoinCount: candidateCoinJoin.count,
             candidateCoinJoinValueDuffs: diagnosticSaturatingSum(
-                candidateCoinJoin.map(\.txo.amount)
+                candidateCoinJoin.map(\.amount)
             ),
             builtCount: emittedCount,
             emittedCandidates: emittedCandidates,
-            emittedValueDuffs: diagnosticSaturatingSum(emittedCandidates.map(\.txo.amount)),
+            emittedValueDuffs: diagnosticSaturatingSum(emittedCandidates.map(\.amount)),
             emittedBip44Count: emittedBip44.count,
-            emittedBip44ValueDuffs: diagnosticSaturatingSum(emittedBip44.map(\.txo.amount)),
+            emittedBip44ValueDuffs: diagnosticSaturatingSum(emittedBip44.map(\.amount)),
             emittedCoinJoinCount: emittedCoinJoin.count,
             emittedCoinJoinValueDuffs: diagnosticSaturatingSum(
-                emittedCoinJoin.map(\.txo.amount)
+                emittedCoinJoin.map(\.amount)
             ),
             missingAccountCount: candidates.filter {
                 $0.rejectionReason == .missingAccount

packages/swift-sdk/Sources/SwiftDashSDK/PlatformWallet/PlatformWalletManager.swift

@@ -467,6 +467,11 @@ public class PlatformWalletManager: ObservableObject {
     /// data (for create, the caller would roll back its mnemonic and
     /// orphan the persisted rows).
     private var activeNativeOpCount = 0
+    /// Read-only Core diagnostics have their own admission count. They must
+    /// keep the manager handle alive until their FFI reads finish, but they do
+    /// not make synchronous create/load/delete operations unsafe and therefore
+    /// must not participate in `ensureSyncNativeOpAllowed`.
+    private var activeCoreDiagnosticsNativeOpCount = 0
     private var nativeOpDrainContinuations: [CheckedContinuation<Void, Never>] = []
 
     /// Admission + bookkeeping shared by the async native entrypoints:
@@ -484,22 +489,32 @@ public class PlatformWalletManager: ObservableObject {
 
     private func finishNativeOp() {
         activeNativeOpCount -= 1
-        if activeNativeOpCount == 0, !nativeOpDrainContinuations.isEmpty {
-            let waiters = nativeOpDrainContinuations
-            nativeOpDrainContinuations.removeAll()
-            waiters.forEach { $0.resume() }
-        }
+        resumeNativeOpDrainIfIdle()
     }
 
-    /// Diagnostics use the same admission/drain contract as other background
-    /// native work: once admitted, shutdown cannot consume the manager handle
-    /// until the read-only snapshot has finished on `destroyQueue`.
+    /// Diagnostics have independent admission bookkeeping: shutdown drains
+    /// them, while synchronous wallet operations ignore them.
     func admitCoreDiagnosticsNativeOp() throws {
-        try admitNativeOp("coreWalletDiagnostics")
+        guard !shutdownRequested else {
+            throw PlatformWalletError.invalidHandle(
+                "manager shutdown is in progress; coreWalletDiagnostics rejected")
+        }
+        activeCoreDiagnosticsNativeOpCount += 1
     }
 
     func finishCoreDiagnosticsNativeOp() {
-        finishNativeOp()
+        activeCoreDiagnosticsNativeOpCount -= 1
+        resumeNativeOpDrainIfIdle()
+    }
+
+    private func resumeNativeOpDrainIfIdle() {
+        guard activeNativeOpCount == 0,
+              activeCoreDiagnosticsNativeOpCount == 0,
+              !nativeOpDrainContinuations.isEmpty
+        else { return }
+        let waiters = nativeOpDrainContinuations
+        nativeOpDrainContinuations.removeAll()
+        waiters.forEach { $0.resume() }
     }
 
     /// Test seam for the individual native calls. Production keeps `.live`;
@@ -635,7 +650,7 @@ public class PlatformWalletManager: ObservableObject {
                     ranOffMainThread: false)
             }
             shutdownRequested = true
-            if activeNativeOpCount == 0 { break }
+            if activeNativeOpCount == 0, activeCoreDiagnosticsNativeOpCount == 0 { break }
             await withCheckedContinuation { continuation in
                 nativeOpDrainContinuations.append(continuation)
             }
@@ -1298,8 +1313,6 @@ public class PlatformWalletManager: ObservableObject {
     /// `createWallet` flow.
     @discardableResult
     public func loadFromPersistor() throws -> [ManagedPlatformWallet] {
-        let diagnosticPersistenceHandler = persistenceHandler
-        defer { diagnosticPersistenceHandler?.clearStartupCoreDiagnosticSnapshots() }
         // Same synchronous-admission gate as the sync creates: rejected
         // during the shutdown drain AND while an async native op is in
         // flight — a second Rust loader running concurrently with the one
@@ -1382,13 +1395,6 @@ public class PlatformWalletManager: ObservableObject {
             }
         }
 
-        for managedWallet in restored {
-            emitCoreWalletDiagnosticsSynchronously(
-                for: managedWallet.walletId,
-                checkpoint: .startupPostRestore
-            )
-        }
-
         // Kick off a background catch-up pass for every persisted
         // asset lock at `statusRaw < 2`. Closes the SPV-restart gap:
         // the wallet's in-memory transactions map was just
@@ -1530,13 +1536,12 @@ public class PlatformWalletManager: ObservableObject {
     /// and once admitted the teardown waits for the full transaction.
     @discardableResult
     public func loadFromPersistor() async throws -> [ManagedPlatformWallet] {
-        let handler = persistenceHandler
-        defer { handler?.clearStartupCoreDiagnosticSnapshots() }
         try ensureConfigured()
         try admitNativeOp("loadFromPersistor")
         defer { finishNativeOp() }
 
         let h = handle
+        let handler = persistenceHandler
         let calls = nativeLoadCalls
 
         // Direct continuation for the same FIFO reason as the async
@@ -1609,13 +1614,6 @@ public class PlatformWalletManager: ObservableObject {
             ]
         )
 
-        for managedWallet in restored {
-            await emitCoreWalletDiagnostics(
-                for: managedWallet.walletId,
-                checkpoint: .startupPostRestore
-            )
-        }
-
         catchUpStuckAssetLocks(wallets: restored)
         return restored
     }

packages/swift-sdk/Sources/SwiftDashSDK/PlatformWallet/PlatformWalletManagerCoreDiagnostics.swift

@@ -3,11 +3,8 @@ import DashSDKFFI
 import Foundation
 import SwiftData
 
-/// Named checkpoints make two exports from the same device directly
-/// comparable without putting any user-controlled text in the log.
+/// Deep Core diagnostics are emitted only on explicit log export.
 enum CoreWalletDiagnosticCheckpoint: String, Sendable {
-    case startupPreRestore = "startup_pre_restore"
-    case startupPostRestore = "startup_post_restore"
     case preExport = "pre_export"
 }
 
@@ -154,26 +151,6 @@ func diagnosticTxoFingerprint(
     return data
 }
 
-/// Canonical material for one exact `UtxoRestoreEntryFFI` row. The general
-/// DB↔memory UTXO query cannot observe these three flags, so they live only in
-/// this restore-specific fingerprint instead of creating false memory diffs.
-func diagnosticRestoreTxoFingerprint(
-    _ candidate: CoreWalletDiagnosticAnalyzer.RestoreCandidate
-) -> Data {
-    var data = diagnosticTxoFingerprint(
-        outpoint: candidate.txo.outpoint,
-        amount: candidate.txo.amount,
-        height: candidate.txo.height,
-        scriptPubKey: candidate.txo.scriptPubKey,
-        isLocked: candidate.txo.isLocked,
-        account: candidate.txo.account
-    )
-    data.append(candidate.isCoinbase ? 1 : 0)
-    data.append(candidate.isConfirmed ? 1 : 0)
-    data.append(candidate.isInstantLocked ? 1 : 0)
-    return data
-}
-
 extension PlatformWalletPersistenceHandler {
     /// Main-actor-friendly entry point used by manual log export. The handler's
     /// serial queue owns the ModelContext; only a Sendable value snapshot is
@@ -185,18 +162,6 @@ extension PlatformWalletPersistenceHandler {
         await withCheckedContinuation { continuation in
             serialQueue.async { [self] in
                 let snapshot = autoreleasepool { () -> CoreWalletDatabaseDiagnosticSnapshot? in
-                    if checkpoint == .startupPostRestore,
-                       let cached = startupCoreDiagnosticSnapshots.removeValue(forKey: walletId) {
-                        SDKLogger.event(
-                            "core_db_startup_snapshot_reused",
-                            category: .persistence,
-                            fields: [
-                                "checkpoint": .publicText(checkpoint.rawValue),
-                                "wallet_reference": .reference(walletId),
-                            ]
-                        )
-                        return cached
-                    }
                     return emitCoreWalletDatabaseDiagnosticsOnQueue(
                         walletId: walletId,
                         checkpoint: checkpoint
@@ -207,44 +172,25 @@ extension PlatformWalletPersistenceHandler {
         }
     }
 
-    /// Synchronous companion for the legacy synchronous restore overload.
+    /// Synchronous companion used by focused persistence tests.
     func emitCoreWalletDatabaseDiagnostics(
         walletId: Data,
         checkpoint: CoreWalletDiagnosticCheckpoint
     ) -> CoreWalletDatabaseDiagnosticSnapshot? {
         onQueue {
-            if checkpoint == .startupPostRestore,
-               let cached = startupCoreDiagnosticSnapshots.removeValue(forKey: walletId) {
-                SDKLogger.event(
-                    "core_db_startup_snapshot_reused",
-                    category: .persistence,
-                    fields: [
-                        "checkpoint": .publicText(checkpoint.rawValue),
-                        "wallet_reference": .reference(walletId),
-                    ]
-                )
-                return cached
-            }
             return emitCoreWalletDatabaseDiagnosticsOnQueue(
                 walletId: walletId,
                 checkpoint: checkpoint
             )
         }
     }
 
-    /// Must be called while `serialQueue` is held. `loadWalletList` uses this
-    /// directly, avoiding a recursive `serialQueue.sync` deadlock.
+    /// Must be called while `serialQueue` is held.
     @discardableResult
     func emitCoreWalletDatabaseDiagnosticsOnQueue(
         walletId: Data,
         checkpoint: CoreWalletDiagnosticCheckpoint
     ) -> CoreWalletDatabaseDiagnosticSnapshot? {
-        // A previous restore can fail after the pre-snapshot was cached but
-        // before post-restore consumes it. Never let a later attempt compare
-        // Rust against that stale value.
-        if checkpoint == .startupPreRestore {
-            startupCoreDiagnosticSnapshots.removeValue(forKey: walletId)
-        }
         do {
             let walletDescriptor = FetchDescriptor<PersistentWallet>(
                 predicate: PersistentWallet.predicate(walletId: walletId)
@@ -530,9 +476,6 @@ extension PlatformWalletPersistenceHandler {
                 assetLocks: assetLocks,
                 assetLocksAvailable: assetLocksAvailable
             )
-            if checkpoint == .startupPreRestore {
-                startupCoreDiagnosticSnapshots[walletId] = snapshot
-            }
             return snapshot
         } catch {
             SDKLogger.event(
@@ -571,20 +514,10 @@ extension PlatformWalletPersistenceHandler {
                 rejection = nil
             }
             return CoreWalletDiagnosticAnalyzer.RestoreCandidate(
-                txo: CoreWalletDatabaseDiagnosticSnapshot.Txo(
-                    outpoint: PersistentTxo.makeOutpoint(txid: row.txid, vout: row.vout),
-                    amount: row.amount,
-                    height: row.height,
-                    scriptPubKey: row.scriptPubKey,
-                    isLocked: row.isLocked,
-                    account: Self.diagnosticAccountKey(row.account)
-                ),
+                amount: row.amount,
                 accountType: row.account?.accountType,
                 standardTag: row.account?.standardTag,
-                rejectionReason: rejection,
-                isCoinbase: row.isCoinbase,
-                isConfirmed: row.isConfirmed,
-                isInstantLocked: row.isInstantLocked
+                rejectionReason: rejection
             )
         }
         // A validation error deallocates the compact buffer and aborts the
@@ -595,7 +528,6 @@ extension PlatformWalletPersistenceHandler {
             emittedCount: emittedCount,
             errored: errored
         )
-        let emittedMaterials = summary.emittedCandidates.map(diagnosticRestoreTxoFingerprint)
         let hasRejectedRows = summary.missingAccountCount > 0
             || summary.invalidTxidCount > 0
             || summary.invalidAccountTypeCount > 0
@@ -616,7 +548,7 @@ extension PlatformWalletPersistenceHandler {
                 ),
                 "candidate_value_duffs": .unsignedInteger(summary.candidateValueDuffs),
                 "built_count": .integer(Int64(summary.builtCount)),
-                "checkpoint": .publicText(CoreWalletDiagnosticCheckpoint.startupPreRestore.rawValue),
+                "checkpoint": .publicText("restore_buffer"),
                 "emitted_count": .integer(Int64(summary.emittedCandidates.count)),
                 "emitted_bip44_count": .integer(Int64(summary.emittedBip44Count)),
                 "emitted_bip44_value_duffs": .unsignedInteger(
@@ -626,7 +558,6 @@ extension PlatformWalletPersistenceHandler {
                 "emitted_coinjoin_value_duffs": .unsignedInteger(
                     summary.emittedCoinJoinValueDuffs
                 ),
-                "emitted_fingerprint": .reference(diagnosticFingerprint(emittedMaterials)),
                 "emitted_value_duffs": .unsignedInteger(summary.emittedValueDuffs),
                 "errored": .boolean(errored),
                 "skipped_invalid_account_type_count": .integer(
@@ -1026,7 +957,7 @@ extension PlatformWalletManager {
         await emitCoreWalletDiagnostics(for: walletId, checkpoint: .preExport)
     }
 
-    func emitCoreWalletDiagnostics(
+    private func emitCoreWalletDiagnostics(
         for walletId: Data,
         checkpoint: CoreWalletDiagnosticCheckpoint
     ) async {
@@ -1096,29 +1027,6 @@ extension PlatformWalletManager {
         }
     }
 
-    /// Blocking variant used only by the already-blocking synchronous restore
-    /// API. New application code should use the async public entry point.
-    func emitCoreWalletDiagnosticsSynchronously(
-        for walletId: Data,
-        checkpoint: CoreWalletDiagnosticCheckpoint
-    ) {
-        guard walletId.count == 32,
-              let handler = persistence,
-              let database = handler.emitCoreWalletDatabaseDiagnostics(
-                walletId: walletId,
-                checkpoint: checkpoint
-              ),
-              isConfigured,
-              handle != NULL_HANDLE
-        else { return }
-        Self.emitCoreMemoryDiagnostics(
-            managerHandle: handle,
-            managedWallet: wallets[walletId],
-            database: database,
-            checkpoint: checkpoint
-        )
-    }
-
     private nonisolated static func emitCoreMemoryDiagnostics(
         managerHandle: Handle,
         managedWallet: ManagedPlatformWallet?,