RPC Resolver: Healthcheck always on (#78)

# What

This PR marks the `rpc_healthcheck_enabled` flag as deprecated and removes its functionality from the RPC health check polling logic.

Cleanup of this flag from the config will happen in a later PR

# Why

The RPC health check functionality should always be enabled, making the toggle unnecessary. Removing the conditional check simplifies the code.

# Risks

- Malfunction of the RPC Healthchecker can lead to the node going down

Author: Garandor

rust/lit-core/lit-blockchain/src/resolver/rpc/mod.rs

@@ -55,7 +55,7 @@ fn select_rpc_entry<'a>(
 ) -> &'a RpcEntry {
     assert!(!entries.is_empty(), "select_rpc_entry called with empty entries");
 
-    // Try to find the best healthy entry first
+    // Try to find the best healthy entry
     let best_healthy = entries
         .iter()
         .filter_map(|entry| match latencies.get(entry) {
@@ -74,17 +74,18 @@ fn select_rpc_entry<'a>(
         return entry;
     }
 
-    // No healthy entries. This happens when the healthcheck poller has not completed a cycle but the
-    // contract resolver immediately needs an RPC (e.g. prov bootstrap). In that case, all entries are
-    // default-unhealthy due to missing latency data. We must avoid picking a high-priority replica
-    // that may not exist; instead use the default-priority remote RPC that is most likely to be
-    // available and warn that fallback was used. This makes a priority-0 default entry mandatory
+    // No healthy entries
+    // Return the default-priority remote RPC (it is most likely to be available)
+    // This can happen when the healthcheck poller has not completed a cycle but the
+    // contract resolver immediately requests an RPC (e.g. prov bootstrap).
+    //In that case, all entries are default-unhealthy due to missing latency data.
+    // NOTE: It is mandatory to provide a priority-0 default entry in the config
     // for every chain that may be used during initialization (yellowstone, litChain)
     let fallback_entry =
         entries.iter().filter(|entry| entry.priority() == 0).min_by(|a, b| a.url().cmp(b.url()));
 
     if let Some(entry) = fallback_entry {
-        warn!(url = entry.url(), "RPC healthcheck fallback URL selected");
+        warn!(url = entry.url(), "No healthy endpoints available, returning fallback");
         return entry;
     }
 

rust/lit-node/lit-node-monitor/src/pages/network_settings/network_configuration.rs

@@ -94,6 +94,7 @@ pub async fn get_realm_config(realm_id: ethers::types::U256) -> Vec<NetworkConfi
             name: "max_presign_concurrency".to_string(),
             value: config.max_presign_concurrency.to_string(),
         },
+        // Deprecated and now unused
         NetworkConfig {
             name: "rpc_health_check_enabled".to_string(),
             value: config.rpc_healthcheck_enabled.to_string(),

rust/lit-node/lit-node/src/config/chain.rs

@@ -53,7 +53,7 @@ pub struct GenericConfig {
     pub min_presign_count: u64,
     pub peer_checking_interval_secs: u64,
     pub max_presign_concurrency: u64,
-    pub rpc_healthcheck_enabled: bool,
+    pub rpc_healthcheck_enabled: bool, // Deprecated and now unused
     pub default_key_set: Option<String>,
 }
 
@@ -178,7 +178,7 @@ impl ChainDataConfigManager {
                 min_presign_count: 10,
                 peer_checking_interval_secs: 5,
                 max_presign_concurrency: 2,
-                rpc_healthcheck_enabled: false,
+                rpc_healthcheck_enabled: false, // Deprecated and now unused
                 default_key_set: None,
             }),
             actions_config: AtomicShared::new(ActionsConfig {
@@ -640,7 +640,7 @@ impl ChainDataConfigManager {
         let min_presign_count = realm_config.min_presign_count.as_u64();
         let peer_checking_interval_secs = realm_config.peer_checking_interval_secs.as_u64();
         let max_presign_concurrency = realm_config.max_presign_concurrency.as_u64();
-        let rpc_healthcheck_enabled = realm_config.rpc_healthcheck_enabled;
+        let rpc_healthcheck_enabled = realm_config.rpc_healthcheck_enabled; // Deprecated and now unused
         let default_key_set = if realm_config.default_key_set.is_empty() {
             None
         } else {
@@ -653,7 +653,7 @@ impl ChainDataConfigManager {
         generic_config.min_presign_count = min_presign_count;
         generic_config.peer_checking_interval_secs = peer_checking_interval_secs;
         generic_config.max_presign_concurrency = max_presign_concurrency;
-        generic_config.rpc_healthcheck_enabled = rpc_healthcheck_enabled;
+        generic_config.rpc_healthcheck_enabled = rpc_healthcheck_enabled; // Deprecated and now unused
         generic_config.default_key_set = default_key_set;
 
         let lit_actions_config =

rust/lit-node/lit-node/src/tasks/mod.rs

@@ -36,7 +36,6 @@ use tokio::sync::mpsc;
 use tokio::task;
 
 use crate::tss::dkg::manager::DkgManager;
-use crate::version::DataVersionReader;
 use endpoint_channels::rounds_worker;
 use lit_blockchain::resolver::rpc::{ENDPOINT_MANAGER, RpcHealthcheckPoller};
 
@@ -130,14 +129,6 @@ pub fn launch(
                             // Continue below.
                         }
                     }
-                    let rpc_healthcheck_enabled = DataVersionReader::read_field_unchecked(
-                        &chain_data_manager_clone2.generic_config,
-                        |generic_config| generic_config.rpc_healthcheck_enabled,
-                    );
-                    if !rpc_healthcheck_enabled
-                    {
-                        continue;
-                    }
                     ENDPOINT_MANAGER.poll_rpcs_for_latency().await;
                 }
             }));