Merge branch 'feat/dash-spv-client-interface' into feat/quorum-lookup-validation

Author: pauldelucia

dash-spv-ffi/src/client.rs

@@ -889,24 +889,24 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
                 let (_command_sender, command_receiver) = tokio::sync::mpsc::unbounded_channel();
                 let run_token = shutdown_token_sync.clone();
                 let (abort_handle, abort_registration) = AbortHandle::new_pair();
-                let mut run_future = Box::pin(Abortable::new(
-                    spv_client.run(command_receiver, run_token),
+                let mut monitor_future = Box::pin(Abortable::new(
+                    spv_client.monitor_network(command_receiver, run_token),
                     abort_registration,
                 ));
                 let result = tokio::select! {
-                    res = &mut run_future => match res {
+                    res = &mut monitor_future => match res {
                         Ok(inner) => inner,
                         Err(_) => Ok(()),
                     },
                     _ = shutdown_token_sync.cancelled() => {
                         abort_handle.abort();
-                        match run_future.as_mut().await {
+                        match monitor_future.as_mut().await {
                             Ok(inner) => inner,
                             Err(_) => Ok(()),
                         }
                     }
                 };
-                drop(run_future);
+                drop(monitor_future);
                 let mut guard = inner.lock().unwrap();
                 *guard = Some(spv_client);
                 result

dash-spv/examples/filter_sync.rs

@@ -48,7 +48,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (_command_sender, command_receiver) = tokio::sync::mpsc::unbounded_channel();
     let shutdown_token = CancellationToken::new();
 
-    client.run_until_shutdown(command_receiver, shutdown_token).await?;
+    client.run(command_receiver, shutdown_token).await?;
 
     println!("Done!");
     Ok(())

dash-spv/examples/simple_sync.rs

@@ -51,7 +51,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (_command_sender, command_receiver) = tokio::sync::mpsc::unbounded_channel();
     let shutdown_token = CancellationToken::new();
 
-    client.run_until_shutdown(command_receiver, shutdown_token).await?;
+    client.run(command_receiver, shutdown_token).await?;
 
     println!("Done!");
     Ok(())

dash-spv/examples/spv_with_wallet.rs

@@ -52,7 +52,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (_command_sender, command_receiver) = tokio::sync::mpsc::unbounded_channel();
     let shutdown_token = CancellationToken::new();
 
-    client.run_until_shutdown(command_receiver, shutdown_token).await?;
+    client.run(command_receiver, shutdown_token).await?;
 
     println!("Done!");
     Ok(())

dash-spv/src/client/sync_coordinator.rs

@@ -68,9 +68,9 @@ impl<
     ///
     /// This is the sole network message receiver to prevent race conditions.
     /// All sync operations coordinate through this monitoring loop.
-    pub async fn run(
+    pub async fn monitor_network(
         &mut self,
-        mut receiver: UnboundedReceiver<DashSpvClientCommand>,
+        mut command_receiver: UnboundedReceiver<DashSpvClientCommand>,
         token: CancellationToken,
     ) -> Result<()> {
         let running = self.running.read().await;
@@ -482,7 +482,7 @@ impl<
             }
 
             tokio::select! {
-                received = receiver.recv() => {
+                received = command_receiver.recv() => {
                     match received {
                     None => {tracing::warn!("DashSpvClientCommand channel closed.");},
                     Some(command) => {
@@ -570,15 +570,15 @@ impl<
         Ok(())
     }
 
-    pub async fn run_until_shutdown(
+    pub async fn run(
         mut self,
-        receiver: UnboundedReceiver<DashSpvClientCommand>,
+        command_receiver: UnboundedReceiver<DashSpvClientCommand>,
         shutdown_token: CancellationToken,
     ) -> Result<()> {
         let client_token = shutdown_token.clone();
 
         let client_task = tokio::spawn(async move {
-            let result = self.run(receiver, client_token).await;
+            let result = self.monitor_network(command_receiver, client_token).await;
             if let Err(e) = &result {
                 tracing::error!("Error running client: {}", e);
             }
@@ -589,7 +589,9 @@ impl<
         });
 
         let shutdown_task = tokio::spawn(async move {
-            let _ = tokio::signal::ctrl_c().await;
+            if let Err(e) = tokio::signal::ctrl_c().await {
+                tracing::error!("Error waiting for ctrl_c: {}", e);
+            }
             tracing::debug!("Shutdown signal received");
             shutdown_token.cancel();
         });

dash-spv/src/main.rs

@@ -633,7 +633,7 @@ async fn run_client<S: dash_spv::storage::StorageManager + Send + Sync + 'static
     let (_command_sender, command_receiver) = tokio::sync::mpsc::unbounded_channel();
     let shutdown_token = CancellationToken::new();
 
-    client.run_until_shutdown(command_receiver, shutdown_token).await?;
+    client.run(command_receiver, shutdown_token).await?;
 
     Ok(())
 }