feat: use feature for console UI (#158)

* feat: use feature for console ui in dash spv

* fmt

* fix

Author: QuantumExplorer

dash-spv/Cargo.toml

@@ -43,8 +43,8 @@ rand = "0.8"
 hex = "0.4"
 indexmap = "2.0"
 
-# Terminal UI
-crossterm = "0.27"
+# Terminal UI (optional)
+crossterm = { version = "0.27", optional = true }
 
 # DNS (trust-dns-resolver was renamed to hickory_resolver)
 hickory-resolver = "0.25"
@@ -61,6 +61,7 @@ hex = "0.4"
 [[bin]]
 name = "dash-spv"
 path = "src/main.rs"
+required-features = ["terminal-ui"]
 
 [lib]
 name = "dash_spv"
@@ -69,3 +70,6 @@ path = "src/lib.rs"
 [features]
 # Gate incomplete mock-dependent tests to avoid "unexpected cfg" warnings.
 skip_mock_implementation_incomplete = []
+
+# Terminal UI feature (off by default, for use by binary only)
+terminal-ui = ["dep:crossterm"]

dash-spv/src/client/mod.rs

@@ -10,6 +10,7 @@ use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 use tokio::sync::{mpsc, Mutex, RwLock};
 
+#[cfg(feature = "terminal-ui")]
 use crate::terminal::TerminalUI;
 use std::collections::HashSet;
 
@@ -77,6 +78,7 @@ pub struct DashSpvClient<W: WalletInterface, N: NetworkManager, S: StorageManage
     validation: ValidationManager,
     chainlock_manager: Arc<ChainLockManager>,
     running: Arc<RwLock<bool>>,
+    #[cfg(feature = "terminal-ui")]
     terminal_ui: Option<Arc<TerminalUI>>,
     filter_processor: Option<FilterNotificationSender>,
     block_processor_tx: mpsc::UnboundedSender<BlockProcessingTask>,
@@ -241,6 +243,7 @@ impl<
     }
 
     /// Helper to create a StatusDisplay instance.
+    #[cfg(feature = "terminal-ui")]
     async fn create_status_display(&self) -> StatusDisplay<'_, S> {
         StatusDisplay::new(
             &self.state,
@@ -251,6 +254,12 @@ impl<
         )
     }
 
+    /// Helper to create a StatusDisplay instance (without terminal UI).
+    #[cfg(not(feature = "terminal-ui"))]
+    async fn create_status_display(&self) -> StatusDisplay<'_, S> {
+        StatusDisplay::new(&self.state, &self.stats, self.storage.clone(), &None, &self.config)
+    }
+
     // UTXO mismatch checking removed - handled by external wallet
 
     // Address mismatch checking removed - handled by external wallet
@@ -344,6 +353,7 @@ impl<
             validation,
             chainlock_manager,
             running: Arc::new(RwLock::new(false)),
+            #[cfg(feature = "terminal-ui")]
             terminal_ui: None,
             filter_processor: None,
             block_processor_tx,
@@ -487,6 +497,7 @@ impl<
         }
 
         // Update terminal UI after connection with initial data
+        #[cfg(feature = "terminal-ui")]
         if let Some(ui) = &self.terminal_ui {
             // Get initial header count from storage
             let (header_height, filter_height) = {
@@ -511,12 +522,14 @@ impl<
     }
 
     /// Enable terminal UI for status display.
+    #[cfg(feature = "terminal-ui")]
     pub fn enable_terminal_ui(&mut self) {
         let ui = Arc::new(TerminalUI::new(true));
         self.terminal_ui = Some(ui);
     }
 
     /// Get the terminal UI handle.
+    #[cfg(feature = "terminal-ui")]
     pub fn get_terminal_ui(&self) -> Option<Arc<TerminalUI>> {
         self.terminal_ui.clone()
     }

dash-spv/src/client/status_display.rs

@@ -6,6 +6,7 @@ use tokio::sync::{Mutex, RwLock};
 use crate::client::ClientConfig;
 use crate::error::Result;
 use crate::storage::StorageManager;
+#[cfg(feature = "terminal-ui")]
 use crate::terminal::TerminalUI;
 use crate::types::{ChainState, SpvStats, SyncProgress};
 
@@ -14,12 +15,15 @@ pub struct StatusDisplay<'a, S: StorageManager> {
     state: &'a Arc<RwLock<ChainState>>,
     stats: &'a Arc<RwLock<SpvStats>>,
     storage: Arc<Mutex<S>>,
+    #[cfg(feature = "terminal-ui")]
     terminal_ui: &'a Option<Arc<TerminalUI>>,
+    #[allow(dead_code)]
     config: &'a ClientConfig,
 }
 
 impl<'a, S: StorageManager + Send + Sync + 'static> StatusDisplay<'a, S> {
     /// Create a new status display manager.
+    #[cfg(feature = "terminal-ui")]
     pub fn new(
         state: &'a Arc<RwLock<ChainState>>,
         stats: &'a Arc<RwLock<SpvStats>>,
@@ -36,6 +40,23 @@ impl<'a, S: StorageManager + Send + Sync + 'static> StatusDisplay<'a, S> {
         }
     }
 
+    /// Create a new status display manager (without terminal UI support).
+    #[cfg(not(feature = "terminal-ui"))]
+    pub fn new(
+        state: &'a Arc<RwLock<ChainState>>,
+        stats: &'a Arc<RwLock<SpvStats>>,
+        storage: Arc<Mutex<S>>,
+        _terminal_ui: &'a Option<()>,
+        config: &'a ClientConfig,
+    ) -> Self {
+        Self {
+            state,
+            stats,
+            storage,
+            config,
+        }
+    }
+
     /// Calculate the header height based on the current state and storage.
     /// This handles both checkpoint sync and normal sync scenarios.
     async fn calculate_header_height_with_logging(
@@ -121,57 +142,64 @@ impl<'a, S: StorageManager + Send + Sync + 'static> StatusDisplay<'a, S> {
 
     /// Update the status display.
     pub async fn update_status_display(&self) {
-        if let Some(ui) = self.terminal_ui {
-            // Get header height - when syncing from checkpoint, use the actual blockchain height
-            let header_height = {
-                let state = self.state.read().await;
-                self.calculate_header_height_with_logging(&state, true).await
-            };
-
-            // Get filter header height from storage
-            let storage = self.storage.lock().await;
-            let filter_height = storage.get_filter_tip_height().await.ok().flatten().unwrap_or(0);
-            drop(storage);
-
-            // Get latest chainlock height from state
-            let chainlock_height = {
-                let state = self.state.read().await;
-                state.last_chainlock_height
-            };
-
-            // Get latest chainlock height from storage metadata (in case state wasn't updated)
-            let stored_chainlock_height = {
+        #[cfg(feature = "terminal-ui")]
+        {
+            if let Some(ui) = self.terminal_ui {
+                // Get header height - when syncing from checkpoint, use the actual blockchain height
+                let header_height = {
+                    let state = self.state.read().await;
+                    self.calculate_header_height_with_logging(&state, true).await
+                };
+
+                // Get filter header height from storage
                 let storage = self.storage.lock().await;
-                if let Ok(Some(data)) = storage.load_metadata("latest_chainlock_height").await {
-                    if data.len() >= 4 {
-                        Some(u32::from_le_bytes([data[0], data[1], data[2], data[3]]))
+                let filter_height =
+                    storage.get_filter_tip_height().await.ok().flatten().unwrap_or(0);
+                drop(storage);
+
+                // Get latest chainlock height from state
+                let chainlock_height = {
+                    let state = self.state.read().await;
+                    state.last_chainlock_height
+                };
+
+                // Get latest chainlock height from storage metadata (in case state wasn't updated)
+                let stored_chainlock_height = {
+                    let storage = self.storage.lock().await;
+                    if let Ok(Some(data)) = storage.load_metadata("latest_chainlock_height").await {
+                        if data.len() >= 4 {
+                            Some(u32::from_le_bytes([data[0], data[1], data[2], data[3]]))
+                        } else {
+                            None
+                        }
                     } else {
                         None
                     }
-                } else {
-                    None
-                }
-            };
-
-            // Use the higher of the two chainlock heights
-            let latest_chainlock = match (chainlock_height, stored_chainlock_height) {
-                (Some(a), Some(b)) => Some(a.max(b)),
-                (Some(a), None) => Some(a),
-                (None, Some(b)) => Some(b),
-                (None, None) => None,
-            };
+                };
+
+                // Use the higher of the two chainlock heights
+                let latest_chainlock = match (chainlock_height, stored_chainlock_height) {
+                    (Some(a), Some(b)) => Some(a.max(b)),
+                    (Some(a), None) => Some(a),
+                    (None, Some(b)) => Some(b),
+                    (None, None) => None,
+                };
+
+                // Update terminal UI
+                let _ = ui
+                    .update_status(|status| {
+                        status.headers = header_height;
+                        status.filter_headers = filter_height;
+                        status.chainlock_height = latest_chainlock;
+                        status.peer_count = 1; // TODO: Get actual peer count
+                        status.network = format!("{:?}", self.config.network);
+                    })
+                    .await;
+                return;
+            }
+        }
 
-            // Update terminal UI
-            let _ = ui
-                .update_status(|status| {
-                    status.headers = header_height;
-                    status.filter_headers = filter_height;
-                    status.chainlock_height = latest_chainlock;
-                    status.peer_count = 1; // TODO: Get actual peer count
-                    status.network = format!("{:?}", self.config.network);
-                })
-                .await;
-        } else {
+        {
             // Fall back to simple logging if terminal UI is not enabled
             // Get header height - when syncing from checkpoint, use the actual blockchain height
             let header_height = {

dash-spv/src/lib.rs

@@ -66,6 +66,7 @@ pub mod mempool_filter;
 pub mod network;
 pub mod storage;
 pub mod sync;
+#[cfg(feature = "terminal-ui")]
 pub mod terminal;
 pub mod types;
 pub mod validation;