fix: sync progress

QuantumExplorer · QuantumExplorer · commit e8b54f4ecd86 · 2025-09-26T17:34:38.000+07:00
diff --git a/dash-spv-ffi/dash_spv_ffi.h b/dash-spv-ffi/dash_spv_ffi.h
@@ -70,19 +70,6 @@ typedef struct FFIString {
   uintptr_t length;
 } FFIString;
 
-typedef struct FFIDetailedSyncProgress {
-  uint32_t current_height;
-  uint32_t total_height;
-  double percentage;
-  double headers_per_second;
-  int64_t estimated_seconds_remaining;
-  enum FFISyncStage stage;
-  struct FFIString stage_message;
-  uint32_t connected_peers;
-  uint64_t total_headers;
-  int64_t sync_start_timestamp;
-} FFIDetailedSyncProgress;
-
 typedef struct FFISyncProgress {
   uint32_t header_height;
   uint32_t filter_header_height;
@@ -96,6 +83,18 @@ typedef struct FFISyncProgress {
   uint32_t last_synced_filter_height;
 } FFISyncProgress;
 
+typedef struct FFIDetailedSyncProgress {
+  uint32_t total_height;
+  double percentage;
+  double headers_per_second;
+  int64_t estimated_seconds_remaining;
+  enum FFISyncStage stage;
+  struct FFIString stage_message;
+  struct FFISyncProgress overview;
+  uint64_t total_headers;
+  int64_t sync_start_timestamp;
+} FFIDetailedSyncProgress;
+
 typedef struct FFISpvStats {
   uint32_t connected_peers;
   uint32_t total_peers;
diff --git a/dash-spv-ffi/include/dash_spv_ffi.h b/dash-spv-ffi/include/dash_spv_ffi.h
@@ -70,19 +70,6 @@ typedef struct FFIString {
   uintptr_t length;
 } FFIString;
 
-typedef struct FFIDetailedSyncProgress {
-  uint32_t current_height;
-  uint32_t total_height;
-  double percentage;
-  double headers_per_second;
-  int64_t estimated_seconds_remaining;
-  enum FFISyncStage stage;
-  struct FFIString stage_message;
-  uint32_t connected_peers;
-  uint64_t total_headers;
-  int64_t sync_start_timestamp;
-} FFIDetailedSyncProgress;
-
 typedef struct FFISyncProgress {
   uint32_t header_height;
   uint32_t filter_header_height;
@@ -96,6 +83,18 @@ typedef struct FFISyncProgress {
   uint32_t last_synced_filter_height;
 } FFISyncProgress;
 
+typedef struct FFIDetailedSyncProgress {
+  uint32_t total_height;
+  double percentage;
+  double headers_per_second;
+  int64_t estimated_seconds_remaining;
+  enum FFISyncStage stage;
+  struct FFIString stage_message;
+  struct FFISyncProgress overview;
+  uint64_t total_headers;
+  int64_t sync_start_timestamp;
+} FFIDetailedSyncProgress;
+
 typedef struct FFISpvStats {
   uint32_t connected_peers;
   uint32_t total_peers;
diff --git a/dash-spv-ffi/src/bin/ffi_cli.rs b/dash-spv-ffi/src/bin/ffi_cli.rs
@@ -35,10 +35,10 @@ extern "C" fn on_detailed_progress(progress: *const FFIDetailedSyncProgress, _ud
         let p = &*progress;
         println!(
             "height {}/{} {:.2}% peers {} hps {:.1}",
-            p.current_height,
+            p.overview.header_height,
             p.total_height,
             p.percentage * 100.0,
-            p.connected_peers,
+            p.overview.peer_count,
             p.headers_per_second
         );
     }
diff --git a/dash-spv-ffi/src/types.rs b/dash-spv-ffi/src/types.rs
@@ -97,14 +97,13 @@ impl From<SyncStage> for FFISyncStage {
 
 #[repr(C)]
 pub struct FFIDetailedSyncProgress {
-    pub current_height: u32,
     pub total_height: u32,
     pub percentage: f64,
     pub headers_per_second: f64,
     pub estimated_seconds_remaining: i64, // -1 if unknown
     pub stage: FFISyncStage,
     pub stage_message: FFIString,
-    pub connected_peers: u32,
+    pub overview: FFISyncProgress,
     pub total_headers: u64,
     pub sync_start_timestamp: i64,
 }
@@ -130,8 +129,9 @@ impl From<DetailedSyncProgress> for FFIDetailedSyncProgress {
             SyncStage::Failed(err) => err.clone(),
         };
 
+        let overview = FFISyncProgress::from(progress.sync_progress.clone());
+
         FFIDetailedSyncProgress {
-            current_height: progress.current_height,
             total_height: progress.peer_best_height,
             percentage: progress.percentage,
             headers_per_second: progress.headers_per_second,
@@ -141,7 +141,7 @@ impl From<DetailedSyncProgress> for FFIDetailedSyncProgress {
                 .unwrap_or(-1),
             stage: progress.sync_stage.into(),
             stage_message: FFIString::new(&stage_message),
-            connected_peers: progress.connected_peers as u32,
+            overview,
             total_headers: progress.total_headers_processed,
             sync_start_timestamp: progress
                 .sync_start_time
diff --git a/dash-spv/src/client/mod.rs b/dash-spv/src/client/mod.rs
@@ -918,8 +918,21 @@ impl<
                         crate::types::SyncStage::Complete
                     };
 
+                    let status_display = self.create_status_display().await;
+                    let mut sync_progress = match status_display.sync_progress().await {
+                        Ok(p) => p,
+                        Err(e) => {
+                            tracing::warn!("Failed to compute sync progress snapshot: {}", e);
+                            SyncProgress::default()
+                        }
+                    };
+
+                    // Update peer count with the latest network information.
+                    sync_progress.peer_count = self.network.peer_count() as u32;
+                    sync_progress.header_height = current_height;
+
                     let progress = DetailedSyncProgress {
-                        current_height,
+                        sync_progress,
                         peer_best_height: peer_best,
                         percentage: if peer_best > 0 {
                             (current_height as f64 / peer_best as f64 * 100.0).min(100.0)
@@ -937,7 +950,6 @@ impl<
                             None
                         },
                         sync_stage,
-                        connected_peers: self.network.peer_count(),
                         total_headers_processed: current_height as u64,
                         total_bytes_downloaded,
                         sync_start_time,
diff --git a/dash-spv/src/types.rs b/dash-spv/src/types.rs
@@ -85,8 +85,8 @@ impl Default for SyncProgress {
 /// Detailed sync progress with performance metrics.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DetailedSyncProgress {
-    /// Current state
-    pub current_height: u32,
+    /// Snapshot of the core sync metrics for quick consumption.
+    pub sync_progress: SyncProgress,
     pub peer_best_height: u32,
     pub percentage: f64,
 
@@ -97,7 +97,6 @@ pub struct DetailedSyncProgress {
 
     /// Detailed status
     pub sync_stage: SyncStage,
-    pub connected_peers: usize,
     pub total_headers_processed: u64,
     pub total_bytes_downloaded: u64,
 
@@ -130,15 +129,17 @@ impl DetailedSyncProgress {
         if self.peer_best_height == 0 {
             return 0.0;
         }
-        ((self.current_height as f64 / self.peer_best_height as f64) * 100.0).min(100.0)
+        let current_height = self.sync_progress.header_height;
+        ((current_height as f64 / self.peer_best_height as f64) * 100.0).min(100.0)
     }
 
     pub fn calculate_eta(&self) -> Option<Duration> {
         if self.headers_per_second <= 0.0 {
             return None;
         }
 
-        let remaining = self.peer_best_height.saturating_sub(self.current_height);
+        let current_height = self.sync_progress.header_height;
+        let remaining = self.peer_best_height.saturating_sub(current_height);
         if remaining == 0 {
             return Some(Duration::from_secs(0));
         }
diff --git a/swift-dash-core-sdk/Sources/DashSPVFFI/include/dash_spv_ffi.h b/swift-dash-core-sdk/Sources/DashSPVFFI/include/dash_spv_ffi.h
@@ -61,6 +61,7 @@ typedef struct FFIArray {
 
 typedef struct FFIClientConfig {
   void *inner;
+  uint32_t worker_threads;
 
 } FFIClientConfig;
 
@@ -69,19 +70,6 @@ typedef struct FFIString {
   uintptr_t length;
 } FFIString;
 
-typedef struct FFIDetailedSyncProgress {
-  uint32_t current_height;
-  uint32_t total_height;
-  double percentage;
-  double headers_per_second;
-  int64_t estimated_seconds_remaining;
-  enum FFISyncStage stage;
-  struct FFIString stage_message;
-  uint32_t connected_peers;
-  uint64_t total_headers;
-  int64_t sync_start_timestamp;
-} FFIDetailedSyncProgress;
-
 typedef struct FFISyncProgress {
   uint32_t header_height;
   uint32_t filter_header_height;
@@ -95,6 +83,18 @@ typedef struct FFISyncProgress {
   uint32_t last_synced_filter_height;
 } FFISyncProgress;
 
+typedef struct FFIDetailedSyncProgress {
+  uint32_t total_height;
+  double percentage;
+  double headers_per_second;
+  int64_t estimated_seconds_remaining;
+  enum FFISyncStage stage;
+  struct FFIString stage_message;
+  struct FFISyncProgress overview;
+  uint64_t total_headers;
+  int64_t sync_start_timestamp;
+} FFIDetailedSyncProgress;
+
 typedef struct FFISpvStats {
   uint32_t connected_peers;
   uint32_t total_peers;
@@ -281,6 +281,14 @@ struct FFIArray dash_spv_ffi_checkpoints_between_heights(FFINetwork network,
  */
  struct FFIDashSpvClient *dash_spv_ffi_client_new(const struct FFIClientConfig *config) ;
 
+/**
+ * Drain pending events and invoke configured callbacks (non-blocking).
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ */
+ int32_t dash_spv_ffi_client_drain_events(struct FFIDashSpvClient *client) ;
+
 /**
  * Update the running client's configuration.
  *
@@ -392,10 +400,8 @@ int32_t dash_spv_ffi_client_sync_to_tip_with_progress(struct FFIDashSpvClient *c
 /**
  * Cancels the sync operation.
  *
- * **Note**: This function currently only stops the SPV client and clears sync callbacks,
- * but does not fully abort the ongoing sync process. The sync operation may continue
- * running in the background until it completes naturally. Full sync cancellation with
- * proper task abortion is not yet implemented.
+ * This stops the SPV client, clears callbacks, and joins active threads so the sync
+ * operation halts immediately.
  *
  * # Safety
  * The client pointer must be valid and non-null.
@@ -704,6 +710,14 @@ int32_t dash_spv_ffi_config_set_masternode_sync_enabled(struct FFIClientConfig *
 void dash_spv_ffi_config_destroy(struct FFIClientConfig *config)
 ;
 
+/**
+ * Sets the number of Tokio worker threads for the FFI runtime (0 = auto)
+ *
+ * # Safety
+ * - `config` must be a valid pointer to an FFIClientConfig
+ */
+ int32_t dash_spv_ffi_config_set_worker_threads(struct FFIClientConfig *config, uint32_t threads) ;
+
 /**
  * Enables or disables mempool tracking
  *
diff --git a/swift-dash-core-sdk/Sources/SwiftDashCoreSDK/Core/SPVClient.swift b/swift-dash-core-sdk/Sources/SwiftDashCoreSDK/Core/SPVClient.swift
@@ -8,17 +8,19 @@ import Network
 
 /// Detailed sync progress information with real-time statistics
 public struct DetailedSyncProgress: Sendable, Equatable {
-    public let currentHeight: UInt32
+    public let overview: SyncProgress
     public let totalHeight: UInt32
     public let percentage: Double
     public let headersPerSecond: Double
     public let estimatedSecondsRemaining: Int64
     public let stage: SyncStage
     public let stageMessage: String
-    public let connectedPeers: UInt32
     public let totalHeadersProcessed: UInt64
     public let syncStartTimestamp: Date
     
+    public var currentHeight: UInt32 { overview.currentHeight }
+    public var connectedPeers: UInt32 { overview.peerCount }
+    
     /// Calculated properties
     public var blocksRemaining: UInt32 {
         guard totalHeight > currentHeight else { return 0 }
@@ -65,39 +67,36 @@ public struct DetailedSyncProgress: Sendable, Equatable {
     
     /// Public initializer for creating DetailedSyncProgress
     public init(
-        currentHeight: UInt32,
+        overview: SyncProgress,
         totalHeight: UInt32,
         percentage: Double,
         headersPerSecond: Double,
         estimatedSecondsRemaining: Int64,
         stage: SyncStage,
         stageMessage: String,
-        connectedPeers: UInt32,
         totalHeadersProcessed: UInt64,
         syncStartTimestamp: Date
     ) {
-        self.currentHeight = currentHeight
+        self.overview = overview
         self.totalHeight = totalHeight
         self.percentage = percentage
         self.headersPerSecond = headersPerSecond
         self.estimatedSecondsRemaining = estimatedSecondsRemaining
         self.stage = stage
         self.stageMessage = stageMessage
-        self.connectedPeers = connectedPeers
         self.totalHeadersProcessed = totalHeadersProcessed
         self.syncStartTimestamp = syncStartTimestamp
     }
     
     /// Initialize from FFI type
     internal init(ffiProgress: FFIDetailedSyncProgress) {
-        self.currentHeight = ffiProgress.current_height
+        self.overview = SyncProgress(ffiProgress: ffiProgress.overview)
         self.totalHeight = ffiProgress.total_height
         self.percentage = ffiProgress.percentage
         self.headersPerSecond = ffiProgress.headers_per_second
         self.estimatedSecondsRemaining = ffiProgress.estimated_seconds_remaining
         self.stage = SyncStage(ffiStage: ffiProgress.stage)
         self.stageMessage = String(cString: ffiProgress.stage_message.ptr)
-        self.connectedPeers = ffiProgress.connected_peers
         self.totalHeadersProcessed = ffiProgress.total_headers
         self.syncStartTimestamp = Date(timeIntervalSince1970: TimeInterval(ffiProgress.sync_start_timestamp))
     }
@@ -308,6 +307,9 @@ extension DetailedSyncProgress {
             "Time Remaining": formattedTimeRemaining,
             "Connected Peers": "\(connectedPeers)",
             "Headers Processed": "\(totalHeadersProcessed)",
+            "Filter Header Height": "\(overview.filterHeaderHeight)",
+            "Filters Downloaded": "\(overview.filtersDownloaded)",
+            "Peer Count": "\(overview.peerCount)",
             "Duration": formattedSyncDuration
         ]
     }
@@ -1240,4 +1242,4 @@ extension SPVClient {
     public func syncProgressStream() -> SyncProgressStream {
         return SyncProgressStream(client: self)
     }
-}
+}
diff --git a/swift-dash-core-sdk/Sources/SwiftDashCoreSDK/Models/SyncProgress.swift b/swift-dash-core-sdk/Sources/SwiftDashCoreSDK/Models/SyncProgress.swift
