refactor: leave the retiring golden route untouched

check_all_providers is slated for removal, so routing its chain names
through ForeignChain::label was churn in a file on its way out. Also drops
two comments that restated the code beside them.

Author: haiyuechen-nearone

crates/e2e-tests/src/foreign_chain_mock.rs

@@ -75,8 +75,6 @@ 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";

crates/e2e-tests/tests/foreign_chain_probe.rs

@@ -30,8 +30,6 @@ fn base_chain_config(rpc_url: &str, expected_network: u64, provider: &str) -> Fo
     }
 }
 
-/// 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() {

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

@@ -31,7 +31,6 @@ 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};
@@ -58,111 +57,71 @@ pub async fn check_all_providers(
         mark_not_configured("ethereum", &mut out);
     }
     if let Some(cfg) = &fc.base {
-        run_evm::<Base>(ForeignChain::Base, cfg, golden.base, network, &mut out).await;
+        run_evm::<Base>("base", cfg, golden.base, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Base, &mut out);
+        mark_not_configured("base", &mut out);
     }
     if let Some(cfg) = &fc.bnb {
-        run_evm::<Bnb>(ForeignChain::Bnb, cfg, golden.bnb, network, &mut out).await;
+        run_evm::<Bnb>("bnb", cfg, golden.bnb, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Bnb, &mut out);
+        mark_not_configured("bnb", &mut out);
     }
     if let Some(cfg) = &fc.arbitrum {
-        run_evm::<Arbitrum>(
-            ForeignChain::Arbitrum,
-            cfg,
-            golden.arbitrum,
-            network,
-            &mut out,
-        )
-        .await;
+        run_evm::<Arbitrum>("arbitrum", cfg, golden.arbitrum, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Arbitrum, &mut out);
+        mark_not_configured("arbitrum", &mut out);
     }
     if let Some(cfg) = &fc.polygon {
-        run_evm::<Polygon>(
-            ForeignChain::Polygon,
-            cfg,
-            golden.polygon,
-            network,
-            &mut out,
-        )
-        .await;
+        run_evm::<Polygon>("polygon", cfg, golden.polygon, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Polygon, &mut out);
+        mark_not_configured("polygon", &mut out);
     }
     if let Some(cfg) = &fc.hyper_evm {
-        run_evm::<HyperEvm>(
-            ForeignChain::HyperEvm,
-            cfg,
-            golden.hyper_evm,
-            network,
-            &mut out,
-        )
-        .await;
+        run_evm::<HyperEvm>("hyper_evm", cfg, golden.hyper_evm, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::HyperEvm, &mut out);
+        mark_not_configured("hyper_evm", &mut out);
     }
     if let Some(cfg) = &fc.avalanche {
-        run_evm::<Avalanche>(
-            ForeignChain::Avalanche,
-            cfg,
-            golden.avalanche,
-            network,
-            &mut out,
-        )
-        .await;
+        run_evm::<Avalanche>("avalanche", cfg, golden.avalanche, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Avalanche, &mut out);
+        mark_not_configured("avalanche", &mut out);
     }
     if let Some(cfg) = &fc.adi {
-        run_evm::<Adi>(ForeignChain::Adi, cfg, golden.adi, network, &mut out).await;
+        run_evm::<Adi>("adi", cfg, golden.adi, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Adi, &mut out);
+        mark_not_configured("adi", &mut out);
     }
     if let Some(cfg) = &fc.abstract_chain {
-        run_evm::<Abstract>(
-            ForeignChain::Abstract,
-            cfg,
-            golden.abstract_chain,
-            network,
-            &mut out,
-        )
-        .await;
+        run_evm::<Abstract>("abstract", cfg, golden.abstract_chain, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Abstract, &mut out);
+        mark_not_configured("abstract", &mut out);
     }
     if let Some(cfg) = &fc.bitcoin {
         run_bitcoin(cfg, golden.bitcoin, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Bitcoin, &mut out);
+        mark_not_configured("bitcoin", &mut out);
     }
     if let Some(cfg) = &fc.starknet {
         run_starknet(cfg, golden.starknet, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Starknet, &mut out);
+        mark_not_configured("starknet", &mut out);
     }
     if let Some(cfg) = &fc.aptos {
         run_aptos(cfg, golden.aptos, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Aptos, &mut out);
+        mark_not_configured("aptos", &mut out);
     }
     if let Some(cfg) = &fc.sui {
         run_sui(cfg, golden.sui, network, &mut out).await;
     } else {
-        mark_not_configured(ForeignChain::Sui, &mut out);
+        mark_not_configured("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(
-            ForeignChain::Solana,
-            cfg,
-            "not yet supported by the node",
-            &mut out,
-        );
+        mark_skipped("solana", cfg, "not yet supported by the node", &mut out);
     } else {
-        mark_not_configured(ForeignChain::Solana, &mut out);
+        mark_not_configured("solana", &mut out);
     }
 
     out
@@ -213,7 +172,7 @@ async fn run_check(timeout: Duration, fut: impl Future<Output = anyhow::Result<(
 }
 
 async fn run_evm<Chain: EvmChain + Send + Sync>(
-    chain: ForeignChain,
+    chain: &'static str,
     cfg: &ForeignChainConfig,
     vector: Option<BlockHashVector>,
     network: Network,
@@ -235,7 +194,7 @@ async fn run_evm<Chain: EvmChain + Send + Sync>(
             }
         };
         out.push(ProviderResult {
-            chain: chain.label(),
+            chain,
             provider: provider_name(name),
             status,
         });
@@ -249,12 +208,7 @@ async fn run_bitcoin(
     out: &mut Vec<ProviderResult>,
 ) {
     let Some(vector) = vector else {
-        mark_skipped(
-            ForeignChain::Bitcoin,
-            cfg,
-            &no_reference_reason(network),
-            out,
-        );
+        mark_skipped("bitcoin", cfg, &no_reference_reason(network), out);
         return;
     };
     let timeout = timeout_of(cfg);
@@ -269,7 +223,7 @@ async fn run_bitcoin(
             }
         };
         out.push(ProviderResult {
-            chain: ForeignChain::Bitcoin.label(),
+            chain: "bitcoin",
             provider: provider_name(name),
             status,
         });
@@ -283,12 +237,7 @@ async fn run_starknet(
     out: &mut Vec<ProviderResult>,
 ) {
     let Some(vector) = vector else {
-        mark_skipped(
-            ForeignChain::Starknet,
-            cfg,
-            &no_reference_reason(network),
-            out,
-        );
+        mark_skipped("starknet", cfg, &no_reference_reason(network), out);
         return;
     };
     let timeout = timeout_of(cfg);
@@ -303,7 +252,7 @@ async fn run_starknet(
             }
         };
         out.push(ProviderResult {
-            chain: ForeignChain::Starknet.label(),
+            chain: "starknet",
             provider: provider_name(name),
             status,
         });
@@ -317,7 +266,7 @@ async fn run_aptos(
     out: &mut Vec<ProviderResult>,
 ) {
     let Some(vector) = vector else {
-        mark_skipped(ForeignChain::Aptos, cfg, &no_reference_reason(network), out);
+        mark_skipped("aptos", cfg, &no_reference_reason(network), out);
         return;
     };
     let timeout = timeout_of(cfg);
@@ -342,7 +291,7 @@ async fn run_aptos(
             }
         };
         out.push(ProviderResult {
-            chain: ForeignChain::Aptos.label(),
+            chain: "aptos",
             provider: provider_name(name),
             status,
         });
@@ -360,7 +309,7 @@ async fn run_sui(
     out: &mut Vec<ProviderResult>,
 ) {
     let Some(vector) = vector else {
-        mark_skipped(ForeignChain::Sui, cfg, &no_reference_reason(network), out);
+        mark_skipped("sui", cfg, &no_reference_reason(network), out);
         return;
     };
     let timeout = timeout_of(cfg);
@@ -370,7 +319,7 @@ async fn run_sui(
             Ok(client) => run_check(timeout, checks::check_sui(client, vector.chain_id)).await,
         };
         out.push(ProviderResult {
-            chain: ForeignChain::Sui.label(),
+            chain: "sui",
             provider: provider_name(name),
             status,
         });
@@ -395,25 +344,21 @@ fn prepare_sui(
 }
 
 fn mark_skipped(
-    chain: ForeignChain,
+    chain: &'static str,
     cfg: &ForeignChainConfig,
     reason: &str,
     out: &mut Vec<ProviderResult>,
 ) {
     for name in cfg.providers.keys() {
-        out.push(ProviderResult::skipped(
-            chain.label(),
-            provider_name(name),
-            reason,
-        ));
+        out.push(ProviderResult::skipped(chain, 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: ForeignChain, out: &mut Vec<ProviderResult>) {
+fn mark_not_configured(chain: &'static str, out: &mut Vec<ProviderResult>) {
     out.push(ProviderResult::skipped(
-        chain.label(),
+        chain,
         "-".to_string(),
         "not configured",
     ));