test(probe): tell the nodes apart by how many providers are healthy

Both nodes configure two BNB providers and expect the same network, so the
healthy gauge reads 2 against 1. Neither is the gauge default, which a poll
waiting for zero cannot tell from a probe that never ran. A new mock serves
eth_chainId alone, all the probe asks, so the fuller EVM mock keeps its shape.

Also covers the Fogo variant main added, converts the counts with try_from,
and drops the label rstest the exhaustive node config test subsumes.

Author: haiyuechen-nearone

crates/e2e-tests/src/foreign_chain_mock.rs

@@ -75,7 +75,6 @@ impl MockServerExt {
     }
 }
 
-pub const MOCK_EVM_CHAIN_ID: u64 = 8453;
 pub const MOCK_BLOCK_HASH: &str =
     "0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20";
 pub const MOCK_TX_ID: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -137,6 +136,28 @@ pub fn setup_bitcoin_mock(server: &MockServer, auth: MockAuthExpectation) -> usi
     mock_id
 }
 
+pub fn setup_evm_chain_id_mock(server: &MockServer, chain_id: u64) -> usize {
+    server
+        .mock(|when, then| {
+            when.method(POST);
+            then.respond_with(move |req: &HttpMockRequest| {
+                let body: serde_json::Value =
+                    serde_json::from_slice(req.body().as_ref()).expect("valid json-rpc request");
+                let response_body = serde_json::json!({
+                    "jsonrpc": "2.0",
+                    "result": format!("{chain_id:#x}"),
+                    "id": body["id"].clone(),
+                });
+                HttpMockResponse::builder()
+                    .status(200)
+                    .header("content-type", "application/json")
+                    .body(serde_json::to_string(&response_body).unwrap())
+                    .build()
+            });
+        })
+        .id
+}
+
 pub fn setup_evm_mock(server: &MockServer, auth: MockAuthExpectation) -> usize {
     let mock_id = server.mock(|when, then| {
         auth.apply(when.method(POST));
@@ -147,7 +168,6 @@ pub fn setup_evm_mock(server: &MockServer, auth: MockAuthExpectation) -> usize {
             let method = body["method"].as_str().expect("method field");
 
             let result = match method {
-                "eth_chainId" => serde_json::json!(format!("{MOCK_EVM_CHAIN_ID:#x}")),
                 "eth_getBlockByNumber" => {
                     // First param is either a finality tag (e.g. "finalized") for the
                     // finality-head lookup, or a `0x`-prefixed block number for the

crates/e2e-tests/tests/foreign_chain_probe.rs

@@ -1,42 +1,59 @@
+use std::collections::BTreeMap;
 use std::num::NonZeroU64;
 
 use crate::common;
 
-use e2e_tests::foreign_chain_mock::{MOCK_EVM_CHAIN_ID, MockAuthExpectation, setup_evm_mock};
+use e2e_tests::foreign_chain_mock::setup_evm_chain_id_mock;
 use e2e_tests::{CLUSTER_WAIT_TIMEOUT, metrics};
 use httpmock::MockServer;
 use mpc_node_config::{
     AuthConfig, ForeignChainConfig, ForeignChainProviderConfig, ForeignChainsConfig,
 };
-use near_mpc_bounded_collections::NonEmptyBTreeMap;
 
-const HEALTHY_PROVIDER: &str = "healthy";
-const WRONG_NETWORK_PROVIDER: &str = "wrong-network";
-/// Any chain id the mock does not serve, so the probe reads a network mismatch.
+/// Belongs to no real chain: the probe only compares what a provider answers against config.
+const EXPECTED_NETWORK: u64 = 99999;
+/// Any chain id the expected mock does not serve, so the probe reads a network mismatch.
 const ANOTHER_NETWORK: u64 = 1;
 
-fn base_chain_config(rpc_url: &str, expected_network: u64, provider: &str) -> ForeignChainConfig {
-    ForeignChainConfig {
-        timeout_sec: NonZeroU64::new(10).unwrap(),
-        max_retries: NonZeroU64::new(1).unwrap(),
-        expected_network_fingerprint: Some(expected_network.to_string()),
-        providers: NonEmptyBTreeMap::new(
-            provider.to_string().into(),
-            ForeignChainProviderConfig {
-                rpc_url: rpc_url.to_string(),
-                auth: AuthConfig::None,
-            },
-        ),
+fn bnb_chain_config(providers: &[(&str, &str)]) -> ForeignChainsConfig {
+    let providers: BTreeMap<_, _> = providers
+        .iter()
+        .map(|(name, rpc_url)| {
+            (
+                name.to_string().into(),
+                ForeignChainProviderConfig {
+                    rpc_url: rpc_url.to_string(),
+                    auth: AuthConfig::None,
+                },
+            )
+        })
+        .collect();
+    ForeignChainsConfig {
+        bnb: Some(ForeignChainConfig {
+            timeout_sec: NonZeroU64::new(10).unwrap(),
+            max_retries: NonZeroU64::new(1).unwrap(),
+            expected_network_fingerprint: Some(EXPECTED_NETWORK.to_string()),
+            providers: providers.try_into().expect("a named provider"),
+        }),
+        ..Default::default()
     }
 }
 
+/// Both nodes expect the same network and configure two BNB providers, so the healthy gauge
+/// separates them on one provider serving another network.
 #[tokio::test]
 #[expect(non_snake_case)]
 async fn foreign_chain_probe__should_publish_provider_health_on_startup() {
     // Given
-    let server = MockServer::start();
-    setup_evm_mock(&server, MockAuthExpectation::None);
-    let url = server.url("/");
+    let expected_network = MockServer::start();
+    setup_evm_chain_id_mock(&expected_network, EXPECTED_NETWORK);
+    let other_network = MockServer::start();
+    setup_evm_chain_id_mock(&other_network, ANOTHER_NETWORK);
+
+    // The config rejects duplicate provider URLs, so the two sound providers take separate paths.
+    let good_path = expected_network.url("/good_provider");
+    let also_good_path = expected_network.url("/also_good_provider");
+    let wrong_network = other_network.url("/wrong_network_provider");
 
     // When
     let (cluster, _running) = common::must_setup_cluster(
@@ -45,18 +62,14 @@ async fn foreign_chain_probe__should_publish_provider_health_on_startup() {
             c.num_nodes = 2;
             c.threshold = 2;
             c.foreign_chains.node_configs = vec![
-                ForeignChainsConfig {
-                    base: Some(base_chain_config(&url, MOCK_EVM_CHAIN_ID, HEALTHY_PROVIDER)),
-                    ..Default::default()
-                },
-                ForeignChainsConfig {
-                    base: Some(base_chain_config(
-                        &url,
-                        ANOTHER_NETWORK,
-                        WRONG_NETWORK_PROVIDER,
-                    )),
-                    ..Default::default()
-                },
+                bnb_chain_config(&[
+                    ("good_provider", &good_path),
+                    ("also_good_provider", &also_good_path),
+                ]),
+                bnb_chain_config(&[
+                    ("good_provider", &good_path),
+                    ("wrong_network_provider", &wrong_network),
+                ]),
             ];
         },
     )
@@ -67,29 +80,29 @@ async fn foreign_chain_probe__should_publish_provider_health_on_startup() {
         &cluster,
         &[0, 1],
         metrics::FOREIGN_CHAIN_RPC_PROVIDERS_CONFIGURED,
-        |value| value == 1,
+        |value| value == 2,
         CLUSTER_WAIT_TIMEOUT,
     )
     .await
-    .expect("both nodes should report one configured Base provider");
+    .expect("both nodes should report two configured BNB providers");
 
     common::wait_metric_on_nodes(
         &cluster,
         &[0],
         metrics::FOREIGN_CHAIN_RPC_PROVIDERS_HEALTHY,
-        |value| value == 1,
+        |value| value == 2,
         CLUSTER_WAIT_TIMEOUT,
     )
     .await
-    .expect("the provider serving the expected network should be healthy");
+    .expect("both providers serving the expected network should be healthy");
 
     common::wait_metric_on_nodes(
         &cluster,
         &[1],
         metrics::FOREIGN_CHAIN_RPC_PROVIDERS_HEALTHY,
-        |value| value == 0,
+        |value| value == 1,
         CLUSTER_WAIT_TIMEOUT,
     )
     .await
-    .expect("the provider serving another network should not be healthy");
+    .expect("only the provider serving the expected network should be healthy");
 }

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

@@ -1408,6 +1408,7 @@ impl ForeignChain {
             Self::Sui => "sui",
             Self::Avalanche => "avalanche",
             Self::Adi => "adi",
+            Self::Fogo => "fogo",
         }
     }
 }
@@ -1976,19 +1977,6 @@ mod tests {
     use super::*;
     use rstest::rstest;
 
-    /// The two whose config key is not the variant name lowercased, which is where a label would
-    /// drift from what an operator writes.
-    #[rstest]
-    #[case::hyper_evm(ForeignChain::HyperEvm, "hyper_evm")]
-    #[case::abstract_chain(ForeignChain::Abstract, "abstract")]
-    fn label__should_name_the_chain_as_its_config_key(
-        #[case] chain: ForeignChain,
-        #[case] expected: &str,
-    ) {
-        // When / Then
-        assert_eq!(chain.label(), expected);
-    }
-
     #[test]
     fn foreign_tx_sign_payload_v1_ethereum__should_have_consistent_hash() {
         // Given

crates/node/src/foreign_chain_probe.rs

@@ -105,10 +105,10 @@ fn publish_metrics(report: &ProbeReport) {
         }
         metrics::FOREIGN_CHAIN_RPC_PROVIDERS_CONFIGURED
             .with_label_values(&[chain.label()])
-            .set(counts.configured as i64);
+            .set(i64::try_from(counts.configured).expect("provider count never exceeds i64"));
         metrics::FOREIGN_CHAIN_RPC_PROVIDERS_HEALTHY
             .with_label_values(&[chain.label()])
-            .set(counts.healthy as i64);
+            .set(i64::try_from(counts.healthy).expect("provider count never exceeds i64"));
     }
 }