test(node): assert the gauges from hand built reports

`ProbeReport` gains `From<Vec<ProviderHealth>>`, so the gauge tests no
longer open sockets and drive another crate's probe just to reach this
crate's publication. They now cover several chains in one report, and
pin the label of the one chain whose key is not its variant name.

Log lines carry the chain's config key rather than its variant name, and
a healthy or uncheckable provider logs at info, so the documented line
per provider appears at the level operators run. Also drops metric
labels from the truncation rationale: no metric carries a fingerprint.

Author: haiyuechen-nearone

crates/e2e-tests/tests/foreign_chain_probe.rs

@@ -42,6 +42,7 @@ async fn foreign_chain_probe__should_publish_provider_health_on_startup() {
     setup_evm_mock(&server, MockAuthExpectation::None);
     let url = server.url("/");
 
+    // when cluster probing is ran as part of start up
     let (cluster, _running) = common::must_setup_cluster(
         common::FOREIGN_CHAIN_PROBE_PORT_SEED,
         |c: &mut e2e_tests::MpcClusterConfig| {
@@ -61,7 +62,7 @@ async fn foreign_chain_probe__should_publish_provider_health_on_startup() {
     )
     .await;
 
-    // when — the probe runs detached at startup, so both gauges settle on their own.
+    // then
     common::wait_metric_on_nodes(
         &cluster,
         &[0, 1],
@@ -72,7 +73,6 @@ async fn foreign_chain_probe__should_publish_provider_health_on_startup() {
     .await
     .expect("both nodes should report one configured Base provider");
 
-    // then
     common::wait_metric_on_nodes(
         &cluster,
         &[0],
@@ -83,13 +83,13 @@ async fn foreign_chain_probe__should_publish_provider_health_on_startup() {
     .await
     .expect("the provider serving the expected network should be healthy");
 
-    let healthy = cluster
-        .get_metric_all_nodes(metrics::FOREIGN_CHAIN_RPC_PROVIDERS_HEALTHY)
-        .await
-        .expect("failed to scrape metrics");
-    assert_eq!(
-        healthy[1],
-        Some(0),
-        "the provider serving another network should not be healthy"
-    );
+    common::wait_metric_on_nodes(
+        &cluster,
+        &[1],
+        metrics::FOREIGN_CHAIN_RPC_PROVIDERS_HEALTHY,
+        |value| value == 0,
+        CLUSTER_WAIT_TIMEOUT,
+    )
+    .await
+    .expect("the provider serving another network should not be healthy");
 }

crates/foreign-chain-health-check/src/probe.rs

@@ -70,6 +70,12 @@ pub struct ProbeReport {
     rows: Vec<ProviderHealth>,
 }
 
+impl From<Vec<ProviderHealth>> for ProbeReport {
+    fn from(rows: Vec<ProviderHealth>) -> Self {
+        Self { rows }
+    }
+}
+
 impl ProbeReport {
     pub fn rows(&self) -> &[ProviderHealth] {
         &self.rows
@@ -142,8 +148,10 @@ pub async fn probe_all_providers(config: &ForeignChainsConfig) -> ProbeReport {
             }
         });
 
-    let report_rows = futures::future::join_all(probe_attempts).await.concat();
-    ProbeReport { rows: report_rows }
+    futures::future::join_all(probe_attempts)
+        .await
+        .concat()
+        .into()
 }
 
 async fn probe_evm<Chain>(chain: ForeignChain, config: &ForeignChainConfig) -> Vec<ProviderHealth>

crates/foreign-chain-inspector/src/lib.rs

@@ -55,8 +55,8 @@ impl NetworkFingerprint {
     pub const MAX_CHARS: usize = 96;
     const CUT_SHORT_MARKER: &str = "_TRUNCATED";
 
-    /// Text longer than [`Self::MAX_CHARS`] is cut short, a very long string answered by
-    /// faulty providers does not reach logs and metric labels in full length.
+    /// Text longer than [`Self::MAX_CHARS`] is cut short, so a very long string answered by a
+    /// faulty provider does not reach the logs in full length.
     pub fn new(fingerprint: impl Into<String>) -> Self {
         const KEPT_CHARS: usize =
             NetworkFingerprint::MAX_CHARS - NetworkFingerprint::CUT_SHORT_MARKER.len();

crates/near-mpc-contract-interface/src/types/foreign_chain.rs

@@ -1839,7 +1839,6 @@ mod tests {
     #[rstest]
     #[case::hyper_evm(ForeignChain::HyperEvm, "hyper_evm")]
     #[case::abstract_chain(ForeignChain::Abstract, "abstract")]
-    #[case::sui(ForeignChain::Sui, "sui")]
     fn label__should_name_the_chain_as_its_config_key(
         #[case] chain: ForeignChain,
         #[case] expected: &str,

crates/node/src/foreign_chain_probe.rs

@@ -8,7 +8,7 @@ use foreign_chain_health_check::probe::{
 };
 use mpc_node_config::ForeignChainsConfig;
 use near_mpc_contract_interface::types as dtos;
-use tracing::{debug, info, warn};
+use tracing::{info, warn};
 
 use crate::metrics;
 
@@ -46,18 +46,18 @@ fn log_report(report: &ProbeReport) {
     let rows = report.rows();
     for row in rows {
         match &row.status {
-            ProviderStatus::Healthy => debug!(
-                chain = ?row.chain,
+            ProviderStatus::Healthy => info!(
+                chain = %row.chain.label(),
                 provider = %row.provider,
                 "foreign-chain RPC provider serves the expected network",
             ),
-            ProviderStatus::ProbeNotImplemented => debug!(
-                chain = ?row.chain,
+            ProviderStatus::ProbeNotImplemented => info!(
+                chain = %row.chain.label(),
                 provider = %row.provider,
-                "foreign-chain RPC provider cannot be probed",
+                "foreign-chain RPC provider cannot be checked",
             ),
             unhealthy => warn!(
-                chain = ?row.chain,
+                chain = %row.chain.label(),
                 provider = %row.provider,
                 status = ?unhealthy,
                 "foreign-chain RPC provider is unhealthy",
@@ -102,28 +102,7 @@ fn publish_metrics(report: &ProbeReport) {
 #[expect(non_snake_case)]
 mod tests {
     use super::*;
-    use mpc_node_config::{AuthConfig, ForeignChainConfig, ForeignChainProviderConfig};
-    use near_mpc_bounded_collections::NonEmptyBTreeMap;
     use prometheus::core::Collector as _;
-    use std::num::NonZeroU64;
-
-    const CLOSED_PORT_URL: &str = "http://127.0.0.1:9";
-    const ANY_FINGERPRINT: &str = "any-fingerprint";
-
-    fn chain_config(expected: &str, rpc_url: &str) -> ForeignChainConfig {
-        ForeignChainConfig {
-            timeout_sec: NonZeroU64::new(1).unwrap(),
-            max_retries: NonZeroU64::new(1).unwrap(),
-            expected_network_fingerprint: Some(expected.to_string()),
-            providers: NonEmptyBTreeMap::new(
-                "only".to_string().into(),
-                ForeignChainProviderConfig {
-                    rpc_url: rpc_url.to_string(),
-                    auth: AuthConfig::None,
-                },
-            ),
-        }
-    }
 
     /// The chains a gauge holds a series for.
     fn labelled_chains(gauge: &prometheus::IntGaugeVec) -> Vec<String> {
@@ -136,10 +115,21 @@ mod tests {
             .collect()
     }
 
-    fn row(chain: dtos::ForeignChain, status: ProviderStatus) -> ProviderHealth {
+    fn counts(chain: &str) -> (i64, i64) {
+        (
+            metrics::FOREIGN_CHAIN_RPC_PROVIDERS_CONFIGURED
+                .with_label_values(&[chain])
+                .get(),
+            metrics::FOREIGN_CHAIN_RPC_PROVIDERS_HEALTHY
+                .with_label_values(&[chain])
+                .get(),
+        )
+    }
+
+    fn row(chain: dtos::ForeignChain, provider: &str, status: ProviderStatus) -> ProviderHealth {
         ProviderHealth {
             chain,
-            provider: dtos::ProviderId("only".to_string()),
+            provider: dtos::ProviderId(provider.to_string()),
             status,
         }
     }
@@ -149,10 +139,11 @@ mod tests {
     fn summarize__should_count_only_the_providers_a_probe_covers() {
         // Given
         let rows = [
-            row(dtos::ForeignChain::Base, ProviderStatus::Healthy),
-            row(dtos::ForeignChain::Bnb, ProviderStatus::Unreachable),
+            row(dtos::ForeignChain::Base, "only", ProviderStatus::Healthy),
+            row(dtos::ForeignChain::Bnb, "only", ProviderStatus::Unreachable),
             row(
                 dtos::ForeignChain::Solana,
+                "only",
                 ProviderStatus::ProbeNotImplemented,
             ),
         ];
@@ -169,6 +160,7 @@ mod tests {
         // Given
         let rows = [row(
             dtos::ForeignChain::Solana,
+            "only",
             ProviderStatus::ProbeNotImplemented,
         )];
 
@@ -179,35 +171,48 @@ mod tests {
         assert_eq!(summary.probed, 0);
     }
 
-    #[tokio::test]
-    async fn run_startup_probe__should_publish_the_provider_counts_per_chain() {
+    /// `HyperEvm` is labelled `hyper_evm`, so the series is keyed by the config key rather than the
+    /// variant name.
+    #[test]
+    fn publish_metrics__should_count_the_providers_of_each_chain() {
         // Given
-        let foreign_chains = ForeignChainsConfig {
-            aptos: Some(chain_config(ANY_FINGERPRINT, CLOSED_PORT_URL)),
-            ..Default::default()
-        };
+        let report = ProbeReport::from(vec![
+            row(
+                dtos::ForeignChain::HyperEvm,
+                "alchemy",
+                ProviderStatus::Healthy,
+            ),
+            row(
+                dtos::ForeignChain::HyperEvm,
+                "quicknode",
+                ProviderStatus::Unreachable,
+            ),
+            row(dtos::ForeignChain::Aptos, "only", ProviderStatus::TimedOut),
+        ]);
 
         // When
-        run_startup_probe(foreign_chains).await;
+        publish_metrics(&report);
 
-        // Then — unreachable, so configured counts it and healthy does not.
-        let counts = |gauge: &prometheus::IntGaugeVec| gauge.with_label_values(&["aptos"]).get();
-        assert_eq!(counts(&metrics::FOREIGN_CHAIN_RPC_PROVIDERS_CONFIGURED), 1);
-        assert_eq!(counts(&metrics::FOREIGN_CHAIN_RPC_PROVIDERS_HEALTHY), 0);
+        // Then
+        assert_eq!(counts("hyper_evm"), (2, 1));
+        assert_eq!(counts("aptos"), (1, 0));
     }
 
     /// A `0` healthy for a chain no probe covers would read as every provider failing.
-    #[tokio::test]
-    async fn run_startup_probe__should_publish_no_counts_for_an_unprobeable_chain() {
+    #[test]
+    fn publish_metrics__should_publish_no_counts_for_an_unprobeable_chain() {
         // Given
-        let foreign_chains = ForeignChainsConfig {
-            bnb: Some(chain_config(ANY_FINGERPRINT, CLOSED_PORT_URL)),
-            solana: Some(chain_config(ANY_FINGERPRINT, CLOSED_PORT_URL)),
-            ..Default::default()
-        };
+        let report = ProbeReport::from(vec![
+            row(dtos::ForeignChain::Bnb, "only", ProviderStatus::Healthy),
+            row(
+                dtos::ForeignChain::Solana,
+                "only",
+                ProviderStatus::ProbeNotImplemented,
+            ),
+        ]);
 
         // When
-        run_startup_probe(foreign_chains).await;
+        publish_metrics(&report);
 
         // Then
         let chains = labelled_chains(&metrics::FOREIGN_CHAIN_RPC_PROVIDERS_CONFIGURED);

docs/foreign-chain-transactions.md

@@ -562,7 +562,7 @@ Every chain with an inspector is probed, each by the RPC below. `solana` and `et
 
 The reported and the configured value are normalized before they are compared, because the same fingerprint has several legal spellings. Starknet's is the chain id felt in lowercase `0x` hex without leading zeros, which providers and operators alike are free to pad and upper-case. The EVM chain id is compared in decimal, the form it is published and configured in, while `eth_chainId` answers a `0x` hex quantity. Bitcoin's genesis hash is compared in lowercase hex, with the leading zeros kept, since they are digits of the hash. Aptos answers its chain id as a number, so only the configured value needs normalizing, and Sui's base58 digest has a single spelling with nothing to normalize.
 
-An answer that is no fingerprint at all is reported as the wrong network, carrying the text the provider sent, so the report says what was actually claimed. An answer longer than any real fingerprint is cut short and ends in `_TRUNCATED`, because it is repeated into logs and metric labels.
+An answer that is no fingerprint at all is reported as the wrong network, carrying the text the provider sent, so the report says what was actually claimed. An answer longer than any real fingerprint is cut short and ends in `_TRUNCATED`, because it is repeated into the logs.
 
 #### Why drop-and-log on local-config mismatch, not hard-crash