feat: tweaks for local network (#8)

shumkov · web-flow · commit fb86d001f178 · 2025-12-28T11:47:56.000+07:00
* feat: support regtest

* fix: memebers

* feat: tweaks for local network

* refactor: remove redundant Network enum implementation
diff --git a/src/api.rs b/src/api.rs
@@ -220,10 +220,20 @@ async fn get_previous_quorums(
 
 #[axum::debug_handler]
 async fn get_masternodes(
-    State((_, _, masternode_cache)): State<(SharedQuorumList, SharedConfig, SharedMasternodeCache)>,
+    State((_, config, masternode_cache)): State<(SharedQuorumList, SharedConfig, SharedMasternodeCache)>,
 ) -> Result<Json<ApiResponse<EvoMasternodeList>>, StatusCode> {
     match masternode_cache.get_masternodes().await {
-        Ok(masternodes) => Ok(Json(ApiResponse::success(masternodes))),
+        Ok(masternodes) => {
+            // Apply address host override if configured
+            let masternodes: EvoMasternodeList = masternodes
+                .into_iter()
+                .map(|mut m| {
+                    m.address = config.apply_address_host_override(&m.address);
+                    m
+                })
+                .collect();
+            Ok(Json(ApiResponse::success(masternodes)))
+        }
         Err(e) => Ok(Json(ApiResponse::error(format!("Failed to load masternodes: {}", e))))
     }
 }
diff --git a/src/config.rs b/src/config.rs
@@ -77,11 +77,17 @@ pub struct Config {
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct DockerConfig {
-    /// Replace 127.0.0.1 in masternode addresses with this host.
-    /// Useful when running in Docker to reach host services.
+    /// Use this host for version checks instead of the masternode's reported address.
+    /// Useful when running in Docker where the reported IPs are not reachable.
     /// Example: "host.docker.internal" for Docker Desktop
     #[serde(default)]
-    pub localhost_replacement: Option<String>,
+    pub version_check_host: Option<String>,
+
+    /// Replace the host in masternode addresses returned by the /masternodes endpoint.
+    /// Useful when clients need to connect via a different host than what's reported.
+    /// Example: "127.0.0.1" for local testing
+    #[serde(default)]
+    pub address_host_override: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -141,6 +147,7 @@ impl Config {
         // Fall back to environment variables or defaults
         let mut config = Config::default();
 
+
         if let Ok(port) = std::env::var("API_PORT") {
             if let Ok(port_num) = port.parse::<u16>() {
                 config.server.port = port_num;
@@ -174,8 +181,12 @@ impl Config {
                 Network::try_from(network_str.as_str()).unwrap_or_else(|e| panic!("{}", e));
         }
 
-        if let Ok(localhost_replacement) = std::env::var("LOCALHOST_REPLACEMENT") {
-            config.docker.localhost_replacement = Some(localhost_replacement);
+        if let Ok(version_check_host) = std::env::var("VERSION_CHECK_HOST") {
+            config.docker.version_check_host = Some(version_check_host);
+        }
+
+        if let Ok(address_host_override) = std::env::var("ADDRESS_HOST_OVERRIDE") {
+            config.docker.address_host_override = Some(address_host_override);
         }
 
         config
@@ -202,13 +213,35 @@ impl Config {
         self.network.dapi_port()
     }
 
-    /// Replace 127.0.0.1 in an address with the configured replacement host.
-    /// Returns the original address if no replacement is configured.
-    pub fn replace_localhost(&self, address: &str) -> String {
-        if let Some(ref replacement) = self.docker.localhost_replacement {
-            address.replace("127.0.0.1", replacement)
+    /// Get the host to use for version checks.
+    /// If version_check_host is configured, use that host instead of the original address host.
+    /// Returns the original host if no replacement is configured.
+    pub fn get_version_check_host(&self, address: &str) -> String {
+        if let Some(ref replacement) = self.docker.version_check_host {
+            replacement.clone()
+        } else {
+            // Extract host from address (format: "ip:port")
+            address
+                .rsplit_once(':')
+                .map(|(h, _)| h.to_string())
+                .unwrap_or_else(|| address.to_string())
+        }
+    }
+
+    /// Apply address host override to an address string.
+    /// If address_host_override is configured, replace the host portion while keeping the port.
+    /// Returns the original address if no override is configured.
+    pub fn apply_address_host_override(&self, address: &str) -> String {
+        if let Some(ref override_host) = self.docker.address_host_override {
+            // Extract port from address (format: "ip:port")
+            if let Some((_, port)) = address.rsplit_once(':') {
+                format!("{}:{}", override_host, port)
+            } else {
+                address.to_string()
+            }
         } else {
             address.to_string()
         }
     }
 }
+
diff --git a/src/grpc_client.rs b/src/grpc_client.rs
@@ -1,3 +1,4 @@
+use crate::config::Network;
 use semver::Version;
 use std::time::Duration;
 use tonic::transport::{Channel, ClientTlsConfig};
@@ -16,21 +17,31 @@ pub mod platform {
 use platform::{platform_client::PlatformClient, get_status_request::GetStatusRequestV0};
 use platform::GetStatusRequest;
 
-pub async fn check_node_version(address: &str, port: u16) -> Result<VersionCheckResult, Box<dyn std::error::Error + Send + Sync>> {
-    // Parse the address and create the endpoint
-    let endpoint = format!("https://{}:{}", address, port);
-    
+pub async fn check_node_version(address: &str, port: u16, network: Network) -> Result<VersionCheckResult, Box<dyn std::error::Error + Send + Sync>> {
     // Create a channel with TLS configuration
-    let tls = ClientTlsConfig::new()
-        .with_native_roots()
-        .assume_http2(true);
-    
-    let channel = Channel::from_shared(endpoint)?
-        .tls_config(tls)?
-        .timeout(Duration::from_secs(2))
-        .connect_timeout(Duration::from_secs(2))
-        .connect()
-        .await?;
+    // For regtest, use HTTP (no TLS) since local nodes use self-signed certs
+    // For mainnet/testnet, use HTTPS with proper certificate verification
+    let channel = if network == Network::Regtest {
+        // For regtest, use plain HTTP to avoid certificate issues
+        let endpoint = format!("http://{}:{}", address, port);
+        Channel::from_shared(endpoint)?
+            .timeout(Duration::from_secs(2))
+            .connect_timeout(Duration::from_secs(2))
+            .connect()
+            .await?
+    } else {
+        let endpoint = format!("https://{}:{}", address, port);
+        let tls = ClientTlsConfig::new()
+            .with_native_roots()
+            .assume_http2(true);
+
+        Channel::from_shared(endpoint)?
+            .tls_config(tls)?
+            .timeout(Duration::from_secs(2))
+            .connect_timeout(Duration::from_secs(2))
+            .connect()
+            .await?
+    };
     
     // Create the gRPC client
     let mut client = PlatformClient::new(channel);
diff --git a/src/masternode.rs b/src/masternode.rs
@@ -40,6 +40,8 @@ pub struct EvoMasternodeInfo {
     pub pro_tx_hash: String,
     pub address: String,
     pub status: String,
+    #[serde(rename = "platformHTTPPort", skip_serializing_if = "Option::is_none")]
+    pub platform_http_port: Option<u16>,
     #[serde(rename = "versionCheck")]
     pub version_check: String, // "success", "fail", or "pending"
     #[serde(rename = "dapiVersion", skip_serializing_if = "Option::is_none")]
@@ -57,11 +59,12 @@ impl From<MasternodeInfo> for Option<EvoMasternodeInfo> {
             } else {
                 "pending".to_string()
             };
-            
+
             Some(EvoMasternodeInfo {
                 pro_tx_hash: info.pro_tx_hash,
                 address: info.address,
                 status: info.status,
+                platform_http_port: info.platform_http_port,
                 version_check,
                 dapi_version: None,
                 drive_version: None,
diff --git a/src/masternode_cache.rs b/src/masternode_cache.rs
@@ -1,11 +1,11 @@
 use crate::config::Config;
+use crate::grpc_client;
 use crate::masternode::EvoMasternodeList;
 use crate::masternode_loader;
-use crate::grpc_client;
+use chrono::Local;
 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>>>,
@@ -24,7 +24,9 @@ impl MasternodeCache {
         }
     }
 
-    pub async fn get_masternodes(&self) -> Result<EvoMasternodeList, Box<dyn std::error::Error + Send + Sync>> {
+    pub async fn get_masternodes(
+        &self,
+    ) -> Result<EvoMasternodeList, Box<dyn std::error::Error + Send + Sync>> {
         // Check if we need to update the cache
         let should_update = {
             let last_update_guard = self.last_update.lock().await;
@@ -40,18 +42,16 @@ impl MasternodeCache {
 
         // Return the cached data
         let cached_data = {
-            let data = self.data.read()
-                .map_err(|_| "Failed to read cache")?;
+            let data = self.data.read().map_err(|_| "Failed to read cache")?;
             data.clone()
         };
-        
+
         match cached_data {
             Some(masternodes) => Ok(masternodes),
             None => {
                 // This shouldn't happen as we just updated, but handle it gracefully
                 self.update_cache().await?;
-                let data = self.data.read()
-                    .map_err(|_| "Failed to read cache")?;
+                let data = self.data.read().map_err(|_| "Failed to read cache")?;
                 Ok(data.as_ref().ok_or("No masternode data available")?.clone())
             }
         }
@@ -63,8 +63,9 @@ impl MasternodeCache {
         // Wrap the entire operation in a timeout (30 seconds)
         let result = tokio::time::timeout(
             tokio::time::Duration::from_secs(30),
-            self.update_cache_internal()
-        ).await;
+            self.update_cache_internal(),
+        )
+        .await;
 
         match result {
             Ok(Ok(())) => Ok(()),
@@ -80,12 +81,16 @@ impl MasternodeCache {
         // Fetch new data
         let mut masternodes = masternode_loader::load_masternode_list(&self.config).await?;
 
-        println!("Checking version for {} Evo masternodes...", masternodes.len());
-        
+        println!(
+            "Checking version for {} Evo masternodes...",
+            masternodes.len()
+        );
+
         // Check version for each masternode
         let check_tasks: Vec<_> = masternodes.iter().enumerate().map(|(idx, node)| {
             let address = node.address.clone();
             let status = node.status.clone();
+            let platform_http_port = node.platform_http_port;
             let config = self.config.clone();
 
             async move {
@@ -97,23 +102,17 @@ impl MasternodeCache {
                     return (idx, "fail".to_string(), None, None, start.elapsed());
                 }
 
-                // Parse address to get IP and port, applying localhost replacement if configured
-                let resolved_address = config.replace_localhost(&address);
-                let parts: Vec<&str> = resolved_address.split(':').collect();
-                if parts.len() != 2 {
-                    println!("❌ Node {} at {} - invalid address format", idx, address);
-                    return (idx, "fail".to_string(), None, None, start.elapsed());
-                }
-
-                let ip = parts[0].to_string();
-                let port = config.get_dapi_port();
+                // Get the host to use for version check (may be replaced by version_check_host)
+                let ip = config.get_version_check_host(&address);
+                // Use platformHTTPPort from masternode info, fallback to config default
+                let port = platform_http_port.unwrap_or_else(|| config.get_dapi_port());
 
                 println!("🔍 Node {} at {} (resolved: {}:{}) - checking version...", idx, address, ip, port);
 
                 // Check version with additional timeout wrapper (2 seconds total)
                 let result = match tokio::time::timeout(
                     tokio::time::Duration::from_secs(2),
-                    grpc_client::check_node_version(&ip, port)
+                    grpc_client::check_node_version(&ip, port, config.network)
                 ).await {
                     Ok(Ok(result)) => {
                         let elapsed = start.elapsed();
@@ -141,7 +140,7 @@ impl MasternodeCache {
                 result
             }
         }).collect();
-        
+
         // Execute all version checks concurrently
         let overall_start = std::time::Instant::now();
         let results = futures::future::join_all(check_tasks).await;
@@ -162,33 +161,44 @@ impl MasternodeCache {
             }
         }
 
-        let success_count = masternodes.iter().filter(|n| n.version_check == "success").count();
-        let fail_count = masternodes.iter().filter(|n| n.version_check == "fail").count();
-        println!("Version check complete: {} success, {} fail (total time: {:?})", success_count, fail_count, total_elapsed);
+        let success_count = masternodes
+            .iter()
+            .filter(|n| n.version_check == "success")
+            .count();
+        let fail_count = masternodes
+            .iter()
+            .filter(|n| n.version_check == "fail")
+            .count();
+        println!(
+            "Version check complete: {} success, {} fail (total time: {:?})",
+            success_count, fail_count, total_elapsed
+        );
 
         // Report slow nodes
         if !slow_nodes.is_empty() {
-            println!("\n🐌 SLOW NODES DETECTED ({} nodes took >2s):", slow_nodes.len());
+            println!(
+                "\n🐌 SLOW NODES DETECTED ({} nodes took >2s):",
+                slow_nodes.len()
+            );
             slow_nodes.sort_by(|a, b| b.2.cmp(&a.2)); // Sort by duration, slowest first
             for (idx, address, duration) in slow_nodes.iter().take(10) {
                 println!("   Node {} at {} took {:?}", idx, address, duration);
             }
             println!();
         }
-        
+
         // Update the cache
         {
-            let mut data = self.data.write()
-                .map_err(|_| "Failed to write to cache")?;
+            let mut data = self.data.write().map_err(|_| "Failed to write to cache")?;
             *data = Some(masternodes);
         }
-        
+
         // Update the timestamp
         {
             let mut last_update = self.last_update.lock().await;
             *last_update = Some(Instant::now());
         }
-        
+
         println!("Masternode cache updated successfully");
         Ok(())
     }
@@ -198,12 +208,22 @@ impl MasternodeCache {
             loop {
                 tokio::time::sleep(self.update_interval).await;
                 let now = Local::now();
-                println!("🔄 [{}] Background refresh: Starting masternode cache update...", now.format("%Y-%m-%d %H:%M:%S"));
+                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),
+                    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
+                    ),
                 }
             }
         });
     }
-}
+}
