Fix error handling in node initialization - return Result instead of panic

- Change ValidatorNode::with_key() and MinerNode::with_key() to return Result
- Change ValidatorNode::new() and MinerNode::new() to return Result
- Update all call sites in main.rs to handle errors gracefully
- Update test cases to unwrap Results
- Addresses PR review feedback about using .expect() causing panics

Co-authored-by: Steake <530040+Steake@users.noreply.github.com>

Author: Copilot

crates/bitcell-node/src/main.rs

@@ -122,7 +122,13 @@ async fn main() {
             // Or we can modify NodeConfig to hold the secret key? No, NodeConfig is serializable.
 
             // Let's update ValidatorNode::new to take the secret key as an argument.
-            let mut node = ValidatorNode::with_key(config, secret_key.clone());
+            let mut node = match ValidatorNode::with_key(config, secret_key.clone()) {
+                Ok(node) => node,
+                Err(e) => {
+                    eprintln!("Error initializing validator node: {}", e);
+                    std::process::exit(1);
+                }
+            };
 
             // Start metrics server on port + 2 to avoid conflict with P2P port (30333) and RPC port (30334)
             let metrics_port = port + 2;
@@ -191,7 +197,13 @@ async fn main() {
 
             println!("Miner Public Key: {:?}", secret_key.public_key());
 
-            let mut node = MinerNode::with_key(config, secret_key.clone());
+            let mut node = match MinerNode::with_key(config, secret_key.clone()) {
+                Ok(node) => node,
+                Err(e) => {
+                    eprintln!("Error initializing miner node: {}", e);
+                    std::process::exit(1);
+                }
+            };
 
             let metrics_port = port + 2;
 
@@ -259,7 +271,13 @@ async fn main() {
             println!("Full Node Public Key: {:?}", secret_key.public_key());
 
             // Reuse ValidatorNode for now as FullNode logic is similar (just no voting)
-            let mut node = ValidatorNode::with_key(config, secret_key.clone());
+            let mut node = match ValidatorNode::with_key(config, secret_key.clone()) {
+                Ok(node) => node,
+                Err(e) => {
+                    eprintln!("Error initializing full node: {}", e);
+                    std::process::exit(1);
+                }
+            };
 
             let metrics_port = port + 2;
 

crates/bitcell-node/src/miner.rs

@@ -20,30 +20,30 @@ pub struct MinerNode {
 }
 
 impl MinerNode {
-    pub fn new(config: NodeConfig, secret_key: SecretKey) -> Self {
+    pub fn new(config: NodeConfig, secret_key: SecretKey) -> crate::Result<Self> {
         Self::with_key(config, Arc::new(secret_key))
     }
 
-    pub fn with_key(config: NodeConfig, secret_key: Arc<SecretKey>) -> Self {
+    pub fn with_key(config: NodeConfig, secret_key: Arc<SecretKey>) -> crate::Result<Self> {
         let metrics = MetricsRegistry::new();
 
         // Create blockchain with or without persistent storage based on config
         let blockchain = if let Some(ref data_path) = config.data_dir {
             // Ensure data directory exists
             std::fs::create_dir_all(data_path)
-                .expect("Failed to create data directory");
+                .map_err(|e| crate::Error::Config(format!("Failed to create data directory: {}", e)))?;
 
             println!("📦 Using persistent storage at: {}", data_path.display());
             Blockchain::with_storage(secret_key.clone(), metrics.clone(), data_path)
-                .expect("Failed to initialize blockchain with storage")
+                .map_err(|e| crate::Error::Config(format!("Failed to initialize blockchain with storage: {}", e)))?
         } else {
             println!("⚠️  Using in-memory storage (data will not persist)");
             Blockchain::new(secret_key.clone(), metrics.clone())
         };
 
         let network = Arc::new(NetworkManager::new(secret_key.public_key(), metrics.clone()));
 
-        Self {
+        Ok(Self {
             config,
             secret_key,
             state: StateManager::new(),
@@ -52,7 +52,7 @@ impl MinerNode {
             blockchain,
             tx_pool: TransactionPool::default(),
             network,
-        }
+        })
     }
 
     pub async fn start(&mut self) -> Result<()> {
@@ -176,15 +176,15 @@ mod tests {
     fn test_miner_creation() {
         let config = NodeConfig::default();
         let sk = SecretKey::generate();
-        let miner = MinerNode::new(config, sk);
+        let miner = MinerNode::new(config, sk).unwrap();
         assert_eq!(miner.glider_strategy, GliderPattern::Standard);
     }
 
     #[test]
     fn test_glider_generation() {
         let config = NodeConfig::default();
         let sk = SecretKey::generate();
-        let miner = MinerNode::new(config, sk);
+        let miner = MinerNode::new(config, sk).unwrap();
         let glider = miner.generate_glider();
         assert_eq!(glider.pattern, GliderPattern::Standard);
     }

crates/bitcell-node/src/validator.rs

@@ -26,7 +26,7 @@ pub struct ValidatorNode {
 }
 
 impl ValidatorNode {
-    pub fn new(config: NodeConfig) -> Self {
+    pub fn new(config: NodeConfig) -> crate::Result<Self> {
         let secret_key = if let Some(seed) = &config.key_seed {
             println!("Generating validator key from seed: {}", seed);
             let hash = bitcell_crypto::Hash256::hash(seed.as_bytes());
@@ -37,18 +37,18 @@ impl ValidatorNode {
         Self::with_key(config, secret_key)
     }
 
-    pub fn with_key(config: NodeConfig, secret_key: Arc<SecretKey>) -> Self {
+    pub fn with_key(config: NodeConfig, secret_key: Arc<SecretKey>) -> crate::Result<Self> {
         let metrics = MetricsRegistry::new();
 
         // Create blockchain with or without persistent storage based on config
         let blockchain = if let Some(ref data_path) = config.data_dir {
             // Ensure data directory exists
             std::fs::create_dir_all(data_path)
-                .expect("Failed to create data directory");
+                .map_err(|e| crate::Error::Config(format!("Failed to create data directory: {}", e)))?;
 
             println!("📦 Using persistent storage at: {}", data_path.display());
             Blockchain::with_storage(secret_key.clone(), metrics.clone(), data_path)
-                .expect("Failed to initialize blockchain with storage")
+                .map_err(|e| crate::Error::Config(format!("Failed to initialize blockchain with storage: {}", e)))?
         } else {
             println!("⚠️  Using in-memory storage (data will not persist)");
             Blockchain::new(secret_key.clone(), metrics.clone())
@@ -57,7 +57,7 @@ impl ValidatorNode {
         let tournament_manager = Arc::new(crate::tournament::TournamentManager::new(metrics.clone()));
         let network = Arc::new(crate::network::NetworkManager::new(secret_key.public_key(), metrics.clone()));
 
-        Self {
+        Ok(Self {
             config,
             state: StateManager::new(),
             peers: PeerManager::new(),
@@ -67,7 +67,7 @@ impl ValidatorNode {
             secret_key,
             tournament_manager,
             network,
-        }
+        })
     }
 
     pub async fn start(&mut self) -> Result<()> {
@@ -290,7 +290,7 @@ mod tests {
     #[test]
     fn test_validator_creation() {
         let config = NodeConfig::default();
-        let node = ValidatorNode::new(config);
+        let node = ValidatorNode::new(config).unwrap();
         assert_eq!(node.state.accounts.len(), 0);
     }
 }