feat: extend network inference to JDC; move tp_type utilities to stratum-apps

vnprc · vnprc · commit 5e3bb6fe6353 · 2026-04-14T13:49:59.000-04:00
Move network_from_tp_port() and VALID_NETWORKS from pool-apps (private) into
stratum-apps/src/tp_type.rs as public API. Add BitcoinNetwork::as_network_str()
and TemplateProviderType::infer_network() so any application using
TemplateProviderType can derive the Bitcoin network without duplicating the
port-mapping logic.

Pool config is updated to delegate to infer_network() instead of carrying its
own copy of the helper function.

JobDeclaratorClientConfig gains the same effective_network() / with_network()
pattern as PoolConfig. For Sv2Tp the network is inferred from the sv2-tp port;
for BitcoinCoreIpc it is taken directly from the BitcoinNetwork enum value. An
explicit network override field (serde default) is provided for non-standard
port setups. Both the initial startup and reconnect MonitoringServer paths are
updated to call .with_network(config.effective_network()).

Integration test lib adds start_jdc_with_network_override(); new test
global_info_network_jdc_from_config_override verifies JDC GlobalInfo exposes
the network field. Unit tests added to stratum-apps/tp_type, pool config, and
JDC config.
diff --git a/integration-tests/lib/mod.rs b/integration-tests/lib/mod.rs
@@ -216,6 +216,26 @@ pub fn start_jdc(
     required_extensions: Vec<u16>,
     enable_monitoring: bool,
     jdc_mode: Option<ConfigJDCMode>,
+) -> (JobDeclaratorClient, SocketAddr, Option<SocketAddr>) {
+    start_jdc_with_network_override(
+        pool,
+        template_provider_config,
+        supported_extensions,
+        required_extensions,
+        enable_monitoring,
+        jdc_mode,
+        None,
+    )
+}
+
+pub fn start_jdc_with_network_override(
+    pool: &[(SocketAddr, SocketAddr)], // (pool_address, jds_address)
+    template_provider_config: TemplateProviderType,
+    supported_extensions: Vec<u16>,
+    required_extensions: Vec<u16>,
+    enable_monitoring: bool,
+    jdc_mode: Option<ConfigJDCMode>,
+    network: Option<String>,
 ) -> (JobDeclaratorClient, SocketAddr, Option<SocketAddr>) {
     use jd_client_sv2::config::{JobDeclaratorClientConfig, PoolConfig, ProtocolConfig, Upstream};
     let jdc_address = get_available_address();
@@ -279,7 +299,8 @@ pub fn start_jdc(
         required_extensions,
         monitoring_address,
         monitoring_cache_refresh_secs,
-    );
+    )
+    .with_network(network);
     let ret = jd_client_sv2::JobDeclaratorClient::new(jd_client_proxy);
     let ret_clone = ret.clone();
     tokio::spawn(async move { ret_clone.start().await });
diff --git a/integration-tests/tests/monitoring_integration.rs b/integration-tests/tests/monitoring_integration.rs
@@ -305,7 +305,48 @@ async fn global_info_network_from_config_override() {
 }
 
 // ---------------------------------------------------------------------------
-// 6. Translator starts cleanly when upstream_monitoring_url is unreachable.
+// 6. JDC exposes network via config override in GlobalInfo.
+// ---------------------------------------------------------------------------
+#[tokio::test]
+async fn global_info_network_jdc_from_config_override() {
+    start_tracing();
+    let (tp, tp_addr) = start_template_provider(None, DifficultyLevel::Low);
+    let (_pool, pool_addr, jds_addr, _pool_monitoring) =
+        start_pool_with_jds(tp.bitcoin_core(), vec![], vec![], false).await;
+
+    let (jdc, _jdc_addr, jdc_monitoring) = start_jdc_with_network_override(
+        &[(pool_addr, jds_addr)],
+        sv2_tp_config(tp_addr),
+        vec![],
+        vec![],
+        true,
+        None,
+        Some("regtest".to_string()),
+    );
+    let jdc_mon = jdc_monitoring.expect("jdc monitoring should be enabled");
+
+    // Wait up to 30 seconds for JDC to connect and serve the monitoring endpoint.
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    loop {
+        let body = fetch_api(jdc_mon, "/api/v1/global").await;
+        let json: serde_json::Value = serde_json::from_str(&body).unwrap();
+        if json["network"] == "regtest" {
+            break;
+        }
+        if std::time::Instant::now() >= deadline {
+            panic!(
+                "jdc global info did not expose network within timeout; got: {}",
+                json
+            );
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(200)).await;
+    }
+
+    shutdown_all!(jdc);
+}
+
+// ---------------------------------------------------------------------------
+// 7. Translator starts cleanly when upstream_monitoring_url is unreachable.
 // ---------------------------------------------------------------------------
 #[tokio::test]
 async fn global_info_network_unreachable_upstream() {
diff --git a/miner-apps/jd-client/src/lib/config.rs b/miner-apps/jd-client/src/lib/config.rs
@@ -8,7 +8,7 @@ use stratum_apps::{
     config_helpers::{opt_path_from_toml, CoinbaseRewardScript},
     key_utils::{Secp256k1PublicKey, Secp256k1SecretKey},
     stratum_core::bitcoin::{Amount, TxOut},
-    tp_type::TemplateProviderType,
+    tp_type::{TemplateProviderType, VALID_NETWORKS},
     utils::types::{SharesBatchSize, SharesPerMinute},
 };
 
@@ -59,6 +59,15 @@ pub struct JobDeclaratorClientConfig {
     monitoring_address: Option<SocketAddr>,
     #[serde(default)]
     monitoring_cache_refresh_secs: Option<u64>,
+    /// Optional override for the Bitcoin network name exposed via `GET /api/v1/global`.
+    /// When absent the network is inferred from the template provider config:
+    /// - `Sv2Tp`: mapped from the sv2-tp port using well-known defaults (see
+    ///   `stratum_apps::tp_type::network_from_tp_port`). Returns `None` for non-standard ports.
+    /// - `BitcoinCoreIpc`: taken directly from the `BitcoinNetwork` enum value.
+    /// Values follow bitcoin-cli convention: `"main"`, `"test"`, `"testnet4"`,
+    /// `"signet"`, `"regtest"`.
+    #[serde(default)]
+    network: Option<String>,
 }
 
 impl JobDeclaratorClientConfig {
@@ -100,6 +109,7 @@ impl JobDeclaratorClientConfig {
             required_extensions,
             monitoring_address,
             monitoring_cache_refresh_secs,
+            network: None,
         }
     }
 
@@ -196,6 +206,35 @@ impl JobDeclaratorClientConfig {
     pub fn required_extensions(&self) -> &[u16] {
         &self.required_extensions
     }
+
+    /// Set the Bitcoin network override (builder style).
+    /// Only needed for non-standard sv2-tp port setups; `BitcoinCoreIpc` configs derive the
+    /// network automatically from the `BitcoinNetwork` enum value.
+    pub fn with_network(mut self, network: Option<String>) -> Self {
+        self.network = network;
+        self
+    }
+
+    /// Returns the effective Bitcoin network name: the explicit `network` override if set,
+    /// otherwise inferred from `template_provider_type`.
+    ///
+    /// Returns `None` if the explicit override is not one of the known values, or if using
+    /// `Sv2Tp` with a non-standard port (set `network` explicitly for non-standard port setups).
+    pub fn effective_network(&self) -> Option<String> {
+        if let Some(ref n) = self.network {
+            if !VALID_NETWORKS.contains(&n.as_str()) {
+                tracing::warn!(
+                    "jdc config: network {:?} is not a recognised value \
+                     (expected one of {:?}); network will not be reported.",
+                    n,
+                    VALID_NETWORKS
+                );
+                return None;
+            }
+            return Some(n.clone());
+        }
+        self.template_provider_type.infer_network().map(|s| s.to_string())
+    }
 }
 
 #[derive(Debug, Deserialize, Clone, Default, PartialEq)]
@@ -302,3 +341,47 @@ impl Upstream {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use stratum_apps::tp_type::{BitcoinNetwork, TemplateProviderType};
+
+    fn sv2_tp(address: &str) -> TemplateProviderType {
+        TemplateProviderType::Sv2Tp {
+            address: address.to_string(),
+            public_key: None,
+        }
+    }
+
+    fn ipc_tp(network: BitcoinNetwork) -> TemplateProviderType {
+        TemplateProviderType::BitcoinCoreIpc {
+            network,
+            data_dir: None,
+            fee_threshold: 0,
+            min_interval: 5,
+        }
+    }
+
+    #[test]
+    fn infer_network_sv2tp_standard_ports() {
+        assert_eq!(sv2_tp("127.0.0.1:18447").infer_network(), Some("regtest"));
+        assert_eq!(sv2_tp("127.0.0.1:8442").infer_network(), Some("main"));
+        assert_eq!(sv2_tp("127.0.0.1:18442").infer_network(), Some("test"));
+        assert_eq!(sv2_tp("127.0.0.1:48442").infer_network(), Some("testnet4"));
+        assert_eq!(sv2_tp("127.0.0.1:38442").infer_network(), Some("signet"));
+    }
+
+    #[test]
+    fn infer_network_sv2tp_nonstandard_port_returns_none() {
+        assert_eq!(sv2_tp("127.0.0.1:4444").infer_network(), None);
+        assert_eq!(sv2_tp("127.0.0.1:3333").infer_network(), None);
+    }
+
+    #[test]
+    fn infer_network_bitcoin_core_ipc() {
+        assert_eq!(ipc_tp(BitcoinNetwork::Regtest).infer_network(), Some("regtest"));
+        assert_eq!(ipc_tp(BitcoinNetwork::Mainnet).infer_network(), Some("main"));
+        assert_eq!(ipc_tp(BitcoinNetwork::Testnet4).infer_network(), Some("testnet4"));
+        assert_eq!(ipc_tp(BitcoinNetwork::Signet).infer_network(), Some("signet"));
+    }
+}
diff --git a/miner-apps/jd-client/src/lib/mod.rs b/miner-apps/jd-client/src/lib/mod.rs
@@ -136,7 +136,8 @@ impl JobDeclaratorClient {
                     self.config.monitoring_cache_refresh_secs().unwrap_or(15),
                 ),
             )
-            .expect("Failed to initialize monitoring server");
+            .expect("Failed to initialize monitoring server")
+            .with_network(self.config.effective_network());
 
             // Create shutdown signal using cancellation token
             let cancellation_token_clone = self.cancellation_token.clone();
@@ -506,7 +507,8 @@ impl JobDeclaratorClient {
                                         Some(Arc::new(channel_manager_clone.clone())),
                                         std::time::Duration::from_secs(self.config.monitoring_cache_refresh_secs().unwrap_or(15)),
                                     )
-                                    .expect("Failed to initialize monitoring server");
+                                    .expect("Failed to initialize monitoring server")
+                                    .with_network(self.config.effective_network());
 
                                     let cancellation_token_clone = self.cancellation_token.clone();
                                     let fallback_coordinator_token = fallback_coordinator.token();
diff --git a/pool-apps/pool/src/lib/config.rs b/pool-apps/pool/src/lib/config.rs
@@ -18,30 +18,12 @@ use stratum_apps::{
     config_helpers::{opt_path_from_toml, CoinbaseRewardScript},
     key_utils::{Secp256k1PublicKey, Secp256k1SecretKey},
     stratum_core::bitcoin::{Amount, TxOut},
-    tp_type::TemplateProviderType,
+    tp_type::{TemplateProviderType, VALID_NETWORKS},
     utils::types::{SharesBatchSize, SharesPerMinute},
 };
 
 use crate::error::PoolErrorKind;
 
-/// Valid Bitcoin network names (bitcoin-cli / `getblockchaininfo` convention).
-const VALID_NETWORKS: &[&str] = &["main", "test", "testnet4", "signet", "regtest"];
-
-/// Maps a well-known sv2-tp default port to a Bitcoin network name.
-/// Port assignments from `man sv2-tp`:
-///   8442  → main, 18442 → test, 48442 → testnet4,
-///   38442 → signet, 18447 → regtest
-fn network_from_tp_port(port: u16) -> Option<&'static str> {
-    match port {
-        8442 => Some("main"),
-        18442 => Some("test"),
-        48442 => Some("testnet4"),
-        38442 => Some("signet"),
-        18447 => Some("regtest"),
-        _ => None,
-    }
-}
-
 /// Configuration for the Pool, including connection, authority, and coinbase settings.
 #[derive(Clone, Debug, serde::Deserialize)]
 pub struct PoolConfig {
@@ -236,12 +218,7 @@ impl PoolConfig {
             }
             return Some(n.clone());
         }
-        if let TemplateProviderType::Sv2Tp { address, .. } = &self.template_provider_type {
-            if let Ok(socket_addr) = address.parse::<std::net::SocketAddr>() {
-                return network_from_tp_port(socket_addr.port()).map(|s| s.to_string());
-            }
-        }
-        None
+        self.template_provider_type.infer_network().map(|s| s.to_string())
     }
 
     /// Set the Bitcoin network override (builder style).
@@ -307,21 +284,7 @@ impl ConnectionConfig {
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    #[test]
-    fn network_from_tp_port_known_ports() {
-        assert_eq!(network_from_tp_port(8442), Some("main"));
-        assert_eq!(network_from_tp_port(18442), Some("test"));
-        assert_eq!(network_from_tp_port(48442), Some("testnet4"));
-        assert_eq!(network_from_tp_port(38442), Some("signet"));
-        assert_eq!(network_from_tp_port(18447), Some("regtest"));
-    }
-
-    #[test]
-    fn network_from_tp_port_unknown_port() {
-        assert_eq!(network_from_tp_port(4444), None);
-        assert_eq!(network_from_tp_port(0), None);
-    }
+    use stratum_apps::tp_type::network_from_tp_port;
 
     fn sv2_tp_type(address: &str) -> TemplateProviderType {
         TemplateProviderType::Sv2Tp {
@@ -331,26 +294,14 @@ mod tests {
     }
 
     #[test]
-    fn effective_network_infers_from_tp_port() {
-        let tp_type = sv2_tp_type("127.0.0.1:18447");
-        // Build a minimal config manually using the serde path is complex; test the
-        // helper function directly.
-        assert_eq!(network_from_tp_port(18447), Some("regtest"));
-        assert_eq!(network_from_tp_port(8442), Some("main"));
-        // Confirm an unknown port yields None
-        assert_eq!(network_from_tp_port(4444), None);
-        // Confirm the address parser works as expected
-        let port = "127.0.0.1:18447"
-            .parse::<std::net::SocketAddr>()
-            .unwrap()
-            .port();
-        assert_eq!(network_from_tp_port(port), Some("regtest"));
-        drop(tp_type); // suppress unused warning
+    fn infer_network_standard_tp_ports() {
+        assert_eq!(sv2_tp_type("127.0.0.1:18447").infer_network(), Some("regtest"));
+        assert_eq!(sv2_tp_type("127.0.0.1:8442").infer_network(), Some("main"));
+        assert_eq!(sv2_tp_type("127.0.0.1:4444").infer_network(), None);
     }
 
     #[test]
     fn valid_networks_covers_known_port_outputs() {
-        // Every value network_from_tp_port can return must be in VALID_NETWORKS
         for port in [8442u16, 18442, 48442, 38442, 18447] {
             let name = network_from_tp_port(port).unwrap();
             assert!(
diff --git a/stratum-apps/src/tp_type.rs b/stratum-apps/src/tp_type.rs
