refactor: name every foreign chain by ForeignChain::label

Covers the avalanche and adi sections main added to ForeignChainsConfig,
and applies review feedback from the earlier PRs in the stack: named
structs in place of positional tuples in the probe tests, bare
Given/When/Then markers, and comments that no longer restate the code.

Author: haiyuechen-nearone

crates/e2e-tests/src/foreign_chain_mock.rs

@@ -75,8 +75,9 @@ impl MockServerExt {
     }
 }
 
+/// Answered by every EVM mock regardless of the chain it stands in for, so a test probing one has
+/// to expect Base's id.
 pub const MOCK_EVM_CHAIN_ID: u64 = 8453;
-
 pub const MOCK_BLOCK_HASH: &str =
     "0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20";
 pub const MOCK_TX_ID: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";

crates/e2e-tests/tests/foreign_chain_probe.rs

@@ -15,7 +15,7 @@ const WRONG_NETWORK_PROVIDER: &str = "wrong-network";
 /// Any chain id the mock does not serve, so the probe reads a network mismatch.
 const ANOTHER_NETWORK: u64 = 1;
 
-fn base_config(rpc_url: &str, expected_network: u64, provider: &str) -> ForeignChainConfig {
+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(),
@@ -30,36 +30,41 @@ fn base_config(rpc_url: &str, expected_network: u64, provider: &str) -> ForeignC
     }
 }
 
-/// Both nodes configure one provider, so only `healthy` separates them.
+/// Both nodes point one Base provider at the same mock and differ only in the fingerprint they
+/// expect, so the healthy gauge is the only one that separates them.
 #[tokio::test]
 #[expect(non_snake_case)]
 async fn foreign_chain_probe__should_publish_provider_health_on_startup() {
-    // given
+    // Given
     let server = MockServer::start();
     setup_evm_mock(&server, MockAuthExpectation::None);
     let url = server.url("/");
 
-    // when
+    // When
     let (cluster, _running) = common::must_setup_cluster(
         common::FOREIGN_CHAIN_PROBE_PORT_SEED,
         |c: &mut e2e_tests::MpcClusterConfig| {
             c.num_nodes = 2;
             c.threshold = 2;
             c.foreign_chains.node_configs = vec![
                 ForeignChainsConfig {
-                    base: Some(base_config(&url, MOCK_EVM_CHAIN_ID, HEALTHY_PROVIDER)),
+                    base: Some(base_chain_config(&url, MOCK_EVM_CHAIN_ID, HEALTHY_PROVIDER)),
                     ..Default::default()
                 },
                 ForeignChainsConfig {
-                    base: Some(base_config(&url, ANOTHER_NETWORK, WRONG_NETWORK_PROVIDER)),
+                    base: Some(base_chain_config(
+                        &url,
+                        ANOTHER_NETWORK,
+                        WRONG_NETWORK_PROVIDER,
+                    )),
                     ..Default::default()
                 },
             ];
         },
     )
     .await;
 
-    // then
+    // Then
     common::wait_metric_on_nodes(
         &cluster,
         &[0, 1],

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

@@ -31,6 +31,7 @@ use foreign_chain_rpc_interfaces::sui::GrpcSuiClient;
 use http::{HeaderName, HeaderValue};
 use mpc_node_config::foreign_chains::RpcProviderName;
 use mpc_node_config::{ForeignChainConfig, ForeignChainProviderConfig, ForeignChainsConfig};
+use near_mpc_contract_interface::types::ForeignChain;
 
 pub use network::Network;
 pub use results::{ProviderResult, Status};
@@ -57,71 +58,111 @@ pub async fn check_all_providers(
         mark_not_configured("ethereum", &mut out);
     }
     if let Some(cfg) = &fc.base {
-        run_evm::<Base>("base", cfg, golden.base, network, &mut out).await;
+        run_evm::<Base>(ForeignChain::Base, cfg, golden.base, network, &mut out).await;
     } else {
-        mark_not_configured("base", &mut out);
+        mark_not_configured(ForeignChain::Base, &mut out);
     }
     if let Some(cfg) = &fc.bnb {
-        run_evm::<Bnb>("bnb", cfg, golden.bnb, network, &mut out).await;
+        run_evm::<Bnb>(ForeignChain::Bnb, cfg, golden.bnb, network, &mut out).await;
     } else {
-        mark_not_configured("bnb", &mut out);
+        mark_not_configured(ForeignChain::Bnb, &mut out);
     }
     if let Some(cfg) = &fc.arbitrum {
-        run_evm::<Arbitrum>("arbitrum", cfg, golden.arbitrum, network, &mut out).await;
+        run_evm::<Arbitrum>(
+            ForeignChain::Arbitrum,
+            cfg,
+            golden.arbitrum,
+            network,
+            &mut out,
+        )
+        .await;
     } else {
-        mark_not_configured("arbitrum", &mut out);
+        mark_not_configured(ForeignChain::Arbitrum, &mut out);
     }
     if let Some(cfg) = &fc.polygon {
-        run_evm::<Polygon>("polygon", cfg, golden.polygon, network, &mut out).await;
+        run_evm::<Polygon>(
+            ForeignChain::Polygon,
+            cfg,
+            golden.polygon,
+            network,
+            &mut out,
+        )
+        .await;
     } else {
-        mark_not_configured("polygon", &mut out);
+        mark_not_configured(ForeignChain::Polygon, &mut out);
     }
     if let Some(cfg) = &fc.hyper_evm {
-        run_evm::<HyperEvm>("hyper_evm", cfg, golden.hyper_evm, network, &mut out).await;
+        run_evm::<HyperEvm>(
+            ForeignChain::HyperEvm,
+            cfg,
+            golden.hyper_evm,
+            network,
+            &mut out,
+        )
+        .await;
     } else {
-        mark_not_configured("hyper_evm", &mut out);
+        mark_not_configured(ForeignChain::HyperEvm, &mut out);
     }
     if let Some(cfg) = &fc.avalanche {
-        run_evm::<Avalanche>("avalanche", cfg, golden.avalanche, network, &mut out).await;
+        run_evm::<Avalanche>(
+            ForeignChain::Avalanche,
+            cfg,
+            golden.avalanche,
+            network,
+            &mut out,
+        )
+        .await;
     } else {
-        mark_not_configured("avalanche", &mut out);
+        mark_not_configured(ForeignChain::Avalanche, &mut out);
     }
     if let Some(cfg) = &fc.adi {
-        run_evm::<Adi>("adi", cfg, golden.adi, network, &mut out).await;
+        run_evm::<Adi>(ForeignChain::Adi, cfg, golden.adi, network, &mut out).await;
     } else {
-        mark_not_configured("adi", &mut out);
+        mark_not_configured(ForeignChain::Adi, &mut out);
     }
     if let Some(cfg) = &fc.abstract_chain {
-        run_evm::<Abstract>("abstract", cfg, golden.abstract_chain, network, &mut out).await;
+        run_evm::<Abstract>(
+            ForeignChain::Abstract,
+            cfg,
+            golden.abstract_chain,
+            network,
+            &mut out,
+        )
+        .await;
     } else {
-        mark_not_configured("abstract", &mut out);
+        mark_not_configured(ForeignChain::Abstract, &mut out);
     }
     if let Some(cfg) = &fc.bitcoin {
         run_bitcoin(cfg, golden.bitcoin, network, &mut out).await;
     } else {
-        mark_not_configured("bitcoin", &mut out);
+        mark_not_configured(ForeignChain::Bitcoin, &mut out);
     }
     if let Some(cfg) = &fc.starknet {
         run_starknet(cfg, golden.starknet, network, &mut out).await;
     } else {
-        mark_not_configured("starknet", &mut out);
+        mark_not_configured(ForeignChain::Starknet, &mut out);
     }
     if let Some(cfg) = &fc.aptos {
         run_aptos(cfg, golden.aptos, network, &mut out).await;
     } else {
-        mark_not_configured("aptos", &mut out);
+        mark_not_configured(ForeignChain::Aptos, &mut out);
     }
     if let Some(cfg) = &fc.sui {
         run_sui(cfg, golden.sui, network, &mut out).await;
     } else {
-        mark_not_configured("sui", &mut out);
+        mark_not_configured(ForeignChain::Sui, &mut out);
     }
 
     // Configured but not yet supported by the node (see verify_foreign_tx/sign.rs).
     if let Some(cfg) = &fc.solana {
-        mark_skipped("solana", cfg, "not yet supported by the node", &mut out);
+        mark_skipped(
+            ForeignChain::Solana,
+            cfg,
+            "not yet supported by the node",
+            &mut out,
+        );
     } else {
-        mark_not_configured("solana", &mut out);
+        mark_not_configured(ForeignChain::Solana, &mut out);
     }
 
     out
@@ -172,7 +213,7 @@ async fn run_check(timeout: Duration, fut: impl Future<Output = anyhow::Result<(
 }
 
 async fn run_evm<Chain: EvmChain + Send + Sync>(
-    chain: &'static str,
+    chain: ForeignChain,
     cfg: &ForeignChainConfig,
     vector: Option<BlockHashVector>,
     network: Network,
@@ -194,7 +235,7 @@ async fn run_evm<Chain: EvmChain + Send + Sync>(
             }
         };
         out.push(ProviderResult {
-            chain,
+            chain: chain.label(),
             provider: provider_name(name),
             status,
         });
@@ -208,7 +249,12 @@ async fn run_bitcoin(
     out: &mut Vec<ProviderResult>,
 ) {
     let Some(vector) = vector else {
-        mark_skipped("bitcoin", cfg, &no_reference_reason(network), out);
+        mark_skipped(
+            ForeignChain::Bitcoin,
+            cfg,
+            &no_reference_reason(network),
+            out,
+        );
         return;
     };
     let timeout = timeout_of(cfg);
@@ -223,7 +269,7 @@ async fn run_bitcoin(
             }
         };
         out.push(ProviderResult {
-            chain: "bitcoin",
+            chain: ForeignChain::Bitcoin.label(),
             provider: provider_name(name),
             status,
         });
@@ -237,7 +283,12 @@ async fn run_starknet(
     out: &mut Vec<ProviderResult>,
 ) {
     let Some(vector) = vector else {
-        mark_skipped("starknet", cfg, &no_reference_reason(network), out);
+        mark_skipped(
+            ForeignChain::Starknet,
+            cfg,
+            &no_reference_reason(network),
+            out,
+        );
         return;
     };
     let timeout = timeout_of(cfg);
@@ -252,7 +303,7 @@ async fn run_starknet(
             }
         };
         out.push(ProviderResult {
-            chain: "starknet",
+            chain: ForeignChain::Starknet.label(),
             provider: provider_name(name),
             status,
         });
@@ -266,7 +317,7 @@ async fn run_aptos(
     out: &mut Vec<ProviderResult>,
 ) {
     let Some(vector) = vector else {
-        mark_skipped("aptos", cfg, &no_reference_reason(network), out);
+        mark_skipped(ForeignChain::Aptos, cfg, &no_reference_reason(network), out);
         return;
     };
     let timeout = timeout_of(cfg);
@@ -291,7 +342,7 @@ async fn run_aptos(
             }
         };
         out.push(ProviderResult {
-            chain: "aptos",
+            chain: ForeignChain::Aptos.label(),
             provider: provider_name(name),
             status,
         });
@@ -309,7 +360,7 @@ async fn run_sui(
     out: &mut Vec<ProviderResult>,
 ) {
     let Some(vector) = vector else {
-        mark_skipped("sui", cfg, &no_reference_reason(network), out);
+        mark_skipped(ForeignChain::Sui, cfg, &no_reference_reason(network), out);
         return;
     };
     let timeout = timeout_of(cfg);
@@ -319,7 +370,7 @@ async fn run_sui(
             Ok(client) => run_check(timeout, checks::check_sui(client, vector.chain_id)).await,
         };
         out.push(ProviderResult {
-            chain: "sui",
+            chain: ForeignChain::Sui.label(),
             provider: provider_name(name),
             status,
         });
@@ -344,21 +395,25 @@ fn prepare_sui(
 }
 
 fn mark_skipped(
-    chain: &'static str,
+    chain: ForeignChain,
     cfg: &ForeignChainConfig,
     reason: &str,
     out: &mut Vec<ProviderResult>,
 ) {
     for name in cfg.providers.keys() {
-        out.push(ProviderResult::skipped(chain, provider_name(name), reason));
+        out.push(ProviderResult::skipped(
+            chain.label(),
+            provider_name(name),
+            reason,
+        ));
     }
 }
 
 /// A chain absent from the config has no providers to enumerate; emit one
 /// placeholder [`ProviderResult`] so it still appears in the returned results.
-fn mark_not_configured(chain: &'static str, out: &mut Vec<ProviderResult>) {
+fn mark_not_configured(chain: ForeignChain, out: &mut Vec<ProviderResult>) {
     out.push(ProviderResult::skipped(
-        chain,
+        chain.label(),
         "-".to_string(),
         "not configured",
     ));

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

@@ -1390,6 +1390,7 @@ pub enum ForeignChain {
 }
 
 impl ForeignChain {
+    /// The chain's key in an operator's `foreign_chains` config, also used as its metric label.
     pub fn label(&self) -> &'static str {
         match self {
             Self::Solana => "solana",

crates/node-config/src/foreign_chains.rs

@@ -737,6 +737,8 @@ ckd:
             polygon: Some(section()),
             aptos: Some(section()),
             sui: Some(section()),
+            avalanche: Some(section()),
+            adi: Some(section()),
         };
 
         // When