Merge pull request #3 from dashpay/split_config

mainnet/testnet & timeout changes

Author: ktechmidas

Cargo.toml

@@ -24,6 +24,7 @@ tonic = { version = "0.12", features = ["tls", "tls-roots"] }
 prost = "0.13"
 tokio-stream = "0.1"
 semver = "1.0"
+chrono = "0.4"
 
 [target.'cfg(not(target_os = "windows"))'.dependencies]
 image = "0.24"

config.toml

@@ -8,4 +8,7 @@ username = "dashrpc"
 password = "password"
 
 [quorum]
-previous_blocks_offset = 8
+previous_blocks_offset = 8
+
+[network]
+network = "testnet"

src/config.rs

@@ -7,6 +7,7 @@ pub struct Config {
     pub server: ServerConfig,
     pub rpc: RpcConfig,
     pub quorum: QuorumConfig,
+    pub network: NetworkConfig,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -27,6 +28,16 @@ pub struct QuorumConfig {
     pub previous_blocks_offset: u32,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NetworkConfig {
+    #[serde(default = "default_network")]
+    pub network: String, // "mainnet" or "testnet"
+}
+
+fn default_network() -> String {
+    "testnet".to_string()
+}
+
 impl Default for Config {
     fn default() -> Self {
         Self {
@@ -42,6 +53,9 @@ impl Default for Config {
             quorum: QuorumConfig {
                 previous_blocks_offset: 8,
             },
+            network: NetworkConfig {
+                network: default_network(),
+            },
         }
     }
 }
@@ -90,6 +104,12 @@ impl Config {
             }
         }
 
+        if let Ok(network) = std::env::var("DASH_NETWORK") {
+            if network == "mainnet" || network == "testnet" {
+                config.network.network = network;
+            }
+        }
+
         config
     }
 
@@ -98,4 +118,25 @@ impl Config {
         fs::write(path, content)?;
         Ok(())
     }
+
+    pub fn get_llmq_type(&self) -> &str {
+        match self.network.network.as_str() {
+            "mainnet" => "llmq_100_67",
+            _ => "llmq_25_67", // default to testnet
+        }
+    }
+
+    pub fn get_llmq_type_id(&self) -> u32 {
+        match self.network.network.as_str() {
+            "mainnet" => 4, // llmq_100_67 = type 4
+            _ => 6, // llmq_25_67 = type 6 (testnet)
+        }
+    }
+
+    pub fn get_dapi_port(&self) -> u16 {
+        match self.network.network.as_str() {
+            "mainnet" => 443,
+            _ => 1443, // default to testnet
+        }
+    }
 }

src/grpc_client.rs

@@ -27,7 +27,8 @@ pub async fn check_node_version(address: &str, port: u16) -> Result<VersionCheck
 
     let channel = Channel::from_shared(endpoint)?
         .tls_config(tls)?
-        .timeout(Duration::from_secs(5))
+        .timeout(Duration::from_secs(2))
+        .connect_timeout(Duration::from_secs(2))
         .connect()
         .await?;
 
@@ -41,7 +42,7 @@ pub async fn check_node_version(address: &str, port: u16) -> Result<VersionCheck
 
     // Make the request with a timeout
     let response = tokio::time::timeout(
-        Duration::from_secs(5),
+        Duration::from_secs(2),
         client.get_status(request)
     ).await??;
 

src/main.rs

@@ -23,6 +23,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Configuration loaded:");
     println!("  Server: {}:{}", config.server.host, config.server.port);
     println!("  RPC: {} (user: {})", config.rpc.url, config.rpc.username);
+    println!("  Network: {}", config.network.network);
+    println!("  LLMQ Type: {} (ID: {})", config.get_llmq_type(), config.get_llmq_type_id());
+    println!("  DAPI Port: {}", config.get_dapi_port());
     println!("  Previous blocks offset: {}", config.quorum.previous_blocks_offset);
 
     // Load initial quorums from Dash Core
@@ -43,6 +46,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Create masternode cache
     let masternode_cache = Arc::new(MasternodeCache::new(config.clone()));
 
+    // Populate masternode cache on startup
+    println!("Loading initial masternode list...");
+    match masternode_cache.get_masternodes().await {
+        Ok(masternodes) => {
+            println!("Successfully loaded {} masternodes into cache", masternodes.len());
+        }
+        Err(e) => {
+            eprintln!("Warning: Failed to load initial masternodes: {}. Cache will populate on first request.", e);
+        }
+    }
+    
     // Start background refresh for masternode cache
     masternode_cache.clone().start_background_refresh().await;
 

src/masternode_cache.rs

@@ -5,6 +5,7 @@ use crate::grpc_client;
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, Instant};
 use tokio::sync::Mutex;
+use chrono::Local;
 
 pub struct MasternodeCache {
     data: Arc<RwLock<Option<EvoMasternodeList>>>,
@@ -72,21 +73,28 @@ impl MasternodeCache {
             async move {
                 // Skip POSE_BANNED nodes
                 if status == "POSE_BANNED" {
+                    println!("⏭️  Node {} at {} - skipping (POSE_BANNED)", idx, address);
                     return (idx, "fail".to_string(), None, None);
                 }
 
                 // Parse address to get IP and port
                 let parts: Vec<&str> = address.split(':').collect();
                 if parts.len() != 2 {
+                    println!("❌ Node {} at {} - invalid address format", idx, address);
                     return (idx, "fail".to_string(), None, None);
                 }
 
                 let ip = parts[0];
-                let port = 1443u16; // Platform gRPC port is always 1443
+                let port = self.config.get_dapi_port();
 
-                // Check version with timeout
-                match grpc_client::check_node_version(ip, port).await {
-                    Ok(result) => {
+                println!("🔍 Node {} at {} - checking version...", idx, address);
+                
+                // Check version with additional timeout wrapper (3 seconds total)
+                match tokio::time::timeout(
+                    tokio::time::Duration::from_secs(3),
+                    grpc_client::check_node_version(ip, port)
+                ).await {
+                    Ok(Ok(result)) => {
                         if result.success {
                             println!("✓ Node {} at {} - version 2.0+ (DAPI: {:?}, Drive: {:?})", 
                                 idx, address, result.dapi_version, result.drive_version);
@@ -97,10 +105,14 @@ impl MasternodeCache {
                             (idx, "fail".to_string(), result.dapi_version, result.drive_version)
                         }
                     },
-                    Err(e) => {
+                    Ok(Err(e)) => {
                         println!("✗ Node {} at {} - error: {}", idx, address, e);
                         (idx, "fail".to_string(), None, None)
                     },
+                    Err(_) => {
+                        println!("✗ Node {} at {} - timeout after 3 seconds", idx, address);
+                        (idx, "fail".to_string(), None, None)
+                    },
                 }
             }
         }).collect();
@@ -140,8 +152,11 @@ impl MasternodeCache {
         tokio::spawn(async move {
             loop {
                 tokio::time::sleep(self.update_interval).await;
-                if let Err(e) = self.update_cache().await {
-                    eprintln!("Failed to update masternode cache: {}", e);
+                let now = Local::now();
+                println!("🔄 [{}] Background refresh: Starting masternode cache update...", now.format("%Y-%m-%d %H:%M:%S"));
+                match self.update_cache().await {
+                    Ok(_) => println!("✅ [{}] Background refresh: Masternode cache updated successfully", Local::now().format("%Y-%m-%d %H:%M:%S")),
+                    Err(e) => eprintln!("❌ [{}] Background refresh: Failed to update masternode cache: {}", Local::now().format("%Y-%m-%d %H:%M:%S"), e),
                 }
             }
         });

src/quorum_loader.rs

@@ -27,10 +27,11 @@ pub async fn load_initial_quorums(
 
     let mut quorum_list = QuorumList::new();
 
-    // Parse the extended quorum list - extract llmq_25_67 quorums for testnet
+    // Parse the extended quorum list - extract the appropriate LLMQ type based on network
+    let llmq_type = config.get_llmq_type();
     if let Some(quorum_obj) = result.as_object() {
-        if let Some(llmq_25_67) = quorum_obj.get("llmq_25_67") {
-            if let Some(quorums_arr) = llmq_25_67.as_array() {
+        if let Some(llmq_quorums) = quorum_obj.get(llmq_type) {
+            if let Some(quorums_arr) = llmq_quorums.as_array() {
                 for quorum_item in quorums_arr {
                     if let Some(quorum_obj) = quorum_item.as_object() {
                         for (quorum_hash_str, quorum_info) in quorum_obj {
@@ -40,7 +41,7 @@ pub async fn load_initial_quorums(
                                     // Get the actual quorum public key via quorum info
                                     let rpc_params = [
                                         serde_json::json!("info"), 
-                                        serde_json::json!(6), // llmq_25_67 = type 6
+                                        serde_json::json!(config.get_llmq_type_id()),
                                         serde_json::json!(quorum_hash_str)
                                     ];
                                     println!("DEBUG: Calling quorum with params: {:?}", rpc_params);
@@ -113,10 +114,11 @@ pub async fn load_quorums_at_height(
 
     let mut quorum_list = QuorumList::new();
 
-    // Parse the extended quorum list - extract llmq_25_67 quorums for testnet
+    // Parse the extended quorum list - extract the appropriate LLMQ type based on network
+    let llmq_type = config.get_llmq_type();
     if let Some(quorum_obj) = result.as_object() {
-        if let Some(llmq_25_67) = quorum_obj.get("llmq_25_67") {
-            if let Some(quorums_arr) = llmq_25_67.as_array() {
+        if let Some(llmq_quorums) = quorum_obj.get(llmq_type) {
+            if let Some(quorums_arr) = llmq_quorums.as_array() {
                 for quorum_item in quorums_arr {
                     if let Some(quorum_obj) = quorum_item.as_object() {
                         for (quorum_hash_str, quorum_info) in quorum_obj {
@@ -126,7 +128,7 @@ pub async fn load_quorums_at_height(
                                     // Get the actual quorum public key via quorum info
                                     let rpc_params = [
                                         serde_json::json!("info"), 
-                                        serde_json::json!(6), // llmq_25_67 = type 6
+                                        serde_json::json!(config.get_llmq_type_id()),
                                         serde_json::json!(quorum_hash_str),
                                         serde_json::json!(true) // includeSkShare
                                     ];