Fetch remote forkpoint and validators

Author: bamrith

Cargo.lock

@@ -89,4 +89,7 @@ pub type ForkpointConfig = monad_consensus_types::checkpoint::Checkpoint<
     ExecutionProtocolType,
 >;
 #[cfg(feature = "crypto")]
+pub type ValidatorsConfigType =
+    monad_consensus_types::validator_data::ValidatorsConfig<SignatureCollectionType>;
+#[cfg(feature = "crypto")]
 pub type MonadNodeConfig = NodeConfig<SignatureType>;

monad-node-config/src/lib.rs

@@ -51,6 +51,7 @@ opentelemetry-otlp = { workspace = true, features = ["metrics", "grpc-tonic"] }
 opentelemetry-semantic-conventions = { workspace = true }
 rand_chacha = { workspace = true }
 rayon = { workspace = true }
+reqwest = { workspace = true, features = ["blocking"] }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "signal"] }
 toml = { workspace = true }

monad-node/Cargo.toml

@@ -29,10 +29,7 @@ use clap::CommandFactory;
 use futures_util::{FutureExt, StreamExt};
 use monad_chain_config::ChainConfig;
 use monad_consensus_state::ConsensusConfig;
-use monad_consensus_types::{
-    metrics::Metrics,
-    validator_data::{ValidatorSetDataWithEpoch, ValidatorsConfig},
-};
+use monad_consensus_types::{metrics::Metrics, validator_data::ValidatorSetDataWithEpoch};
 use monad_control_panel::{ipc::ControlPanelIpcReceiver, TracingReload};
 use monad_crypto::{
     certificate_signature::{
@@ -206,13 +203,8 @@ fn setup_tracing(
 }
 
 async fn run(node_state: NodeState, reload_handle: Box<dyn TracingReload>) -> Result<(), ()> {
-    let locked_epoch_validators = ValidatorsConfig::read_from_path(&node_state.validators_path)
-        .unwrap_or_else(|err| {
-            panic!(
-                "failed to read/parse validators_path={:?}, err={:?}",
-                &node_state.validators_path, err
-            )
-        })
+    let locked_epoch_validators = node_state
+        .validators_config
         .get_locked_validator_sets(&node_state.forkpoint_config);
 
     let current_epoch = node_state
@@ -397,8 +389,8 @@ async fn run(node_state: NodeState, reload_handle: Box<dyn TracingReload>) -> Re
         key: node_state.secp256k1_identity,
         certkey: node_state.bls12_381_identity,
         beneficiary: node_state.node_config.beneficiary.into(),
-        locked_epoch_validators,
         forkpoint: node_state.forkpoint_config.into(),
+        locked_epoch_validators,
         block_sync_override_peers,
         consensus_config: ConsensusConfig {
             execution_delay: SeqNum(EXECUTION_DELAY),

monad-node/src/main.rs

@@ -14,32 +14,40 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::{
+    env,
     path::{Path, PathBuf},
+    str::FromStr,
     time::Duration,
 };
 
 use clap::{error::ErrorKind, FromArgMatches};
 use monad_bls::BlsKeyPair;
 use monad_chain_config::MonadChainConfig;
 use monad_keystore::keystore::Keystore;
-use monad_node_config::{ForkpointConfig, MonadNodeConfig};
+use monad_node_config::{ForkpointConfig, MonadNodeConfig, ValidatorsConfigType};
 use monad_secp::KeyPair;
-use tracing::info;
+use monad_types::Round;
+use reqwest::{blocking::Client, Url};
+use tracing::{info, warn};
 
 use crate::{cli::Cli, error::NodeSetupError};
 
+const REMOTE_FORKPOINT_URL_ENV: &str = "REMOTE_FORKPOINT_URL";
+const REMOTE_VALIDATORS_URL_ENV: &str = "REMOTE_VALIDATORS_URL";
+
 pub struct NodeState {
     pub node_config: MonadNodeConfig,
     pub node_config_path: PathBuf,
     pub forkpoint_config: ForkpointConfig,
-    pub validators_path: PathBuf,
+    pub validators_config: ValidatorsConfigType,
     pub chain_config: MonadChainConfig,
 
     pub secp256k1_identity: KeyPair,
     pub router_identity: KeyPair,
     pub bls12_381_identity: BlsKeyPair,
 
     pub forkpoint_path: PathBuf,
+    pub validators_path: PathBuf,
     pub wal_path: PathBuf,
     pub ledger_path: PathBuf,
     pub mempool_ipc_path: PathBuf,
@@ -60,7 +68,7 @@ impl NodeState {
             secp_identity,
             node_config: node_config_path,
             forkpoint_config: forkpoint_config_path,
-            validators_path,
+            validators_path: validators_config_path,
             devnet_chain_config_override: maybe_devnet_chain_config_override_path,
             wal_path,
             ledger_path,
@@ -101,8 +109,10 @@ impl NodeState {
 
         let node_config: MonadNodeConfig =
             toml::from_str(&std::fs::read_to_string(&node_config_path)?)?;
-        let forkpoint_config: ForkpointConfig =
-            toml::from_str(&std::fs::read_to_string(&forkpoint_config_path)?)?;
+
+        let (forkpoint_config, validators_config) =
+            get_latest_configs(&forkpoint_config_path, &validators_config_path)?;
+
         let devnet_chain_config_override =
             if let Some(devnet_override_path) = maybe_devnet_chain_config_override_path {
                 Some(toml::from_str(&std::fs::read_to_string(
@@ -141,14 +151,15 @@ impl NodeState {
             node_config,
             node_config_path,
             forkpoint_config,
-            validators_path,
+            validators_config,
             chain_config,
 
             secp256k1_identity: secp_key,
             router_identity: router_key,
             bls12_381_identity: bls_key,
 
             forkpoint_path: forkpoint_config_path,
+            validators_path: validators_config_path,
             wal_path,
             ledger_path,
             triedb_path,
@@ -164,6 +175,85 @@ impl NodeState {
     }
 }
 
+fn fetch_remote_configs() -> Result<(ForkpointConfig, ValidatorsConfigType), String> {
+    let forkpoint_url_str = env::var(REMOTE_FORKPOINT_URL_ENV)
+        .map_err(|_| format!("{REMOTE_FORKPOINT_URL_ENV} env variable unset"))?;
+    let remote_forkpoint_url = Url::from_str(&forkpoint_url_str)
+        .map_err(|err| format!("failed to parse remote forkpoint url: {err}"))?;
+
+    let validators_url_str = env::var(REMOTE_VALIDATORS_URL_ENV)
+        .map_err(|_| format!("{REMOTE_VALIDATORS_URL_ENV} env variable unset"))?;
+    let remote_validators_url = Url::from_str(&validators_url_str)
+        .map_err(|err| format!("failed to parse remote validators url: {err}"))?;
+
+    let client = Client::new();
+
+    let forkpoint_config_str = client
+        .get(remote_forkpoint_url)
+        .send()
+        .and_then(|forkpoint_response| forkpoint_response.error_for_status())
+        .and_then(|valid_forkpoint_response| valid_forkpoint_response.text())
+        .map_err(|err| format!("error fetching remote forkpoint config: {err}"))?;
+    let forkpoint_config = toml::from_str(&forkpoint_config_str)
+        .map_err(|err| format!("failed to parse remote forkpoint config: {err}"))?;
+
+    let validators_config_str = client
+        .get(remote_validators_url)
+        .send()
+        .and_then(|validators_response| validators_response.error_for_status())
+        .and_then(|valid_validators_response| valid_validators_response.text())
+        .map_err(|err| format!("error fetching remote validators config: {err}"))?;
+    let validators_config = ValidatorsConfigType::read_from_str(&validators_config_str)
+        .map_err(|err| format!("failed to parse remote validators config: {err}"))?;
+
+    Ok((forkpoint_config, validators_config))
+}
+
+fn get_latest_configs(
+    forkpoint_config_path: &Path,
+    validators_config_path: &Path,
+) -> Result<(ForkpointConfig, ValidatorsConfigType), NodeSetupError> {
+    let local_forkpoint_config: ForkpointConfig =
+        toml::from_str(&std::fs::read_to_string(forkpoint_config_path)?)?;
+    let local_validators_config = ValidatorsConfigType::read_from_path(validators_config_path)
+        .map_err(|_| NodeSetupError::Custom {
+            kind: ErrorKind::Io,
+            msg: "failed to read validators.toml file".to_owned(),
+        })?;
+
+    match fetch_remote_configs() {
+        Ok((remote_forkpoint_config, remote_validators_config)) => {
+            let local_forkpoint_round = local_forkpoint_config.high_certificate.round();
+            let remote_forkpoint_round = remote_forkpoint_config.high_certificate.round();
+
+            // if remote config is more recent, use that over local config
+            if remote_forkpoint_round > local_forkpoint_round {
+                info!(
+                    ?remote_forkpoint_round,
+                    ?local_forkpoint_round,
+                    "fetched more recent forkpoint from remote source"
+                );
+                return Ok((remote_forkpoint_config, remote_validators_config));
+            } else if remote_forkpoint_round < local_forkpoint_round - Round(200) {
+                // warn user if remote configs are stale
+                warn!(
+                    ?remote_forkpoint_round,
+                    ?local_forkpoint_round,
+                    "remote forkpoint 200 rounds older than local forkpoint"
+                );
+            }
+        }
+        Err(err) => {
+            info!(
+                err,
+                "failed to fetch remote configs, using local forkpoint and validators config"
+            );
+        }
+    }
+
+    Ok((local_forkpoint_config, local_validators_config))
+}
+
 fn load_secp256k1_keypair(path: &Path, keystore_password: &str) -> Result<KeyPair, NodeSetupError> {
     Keystore::load_secp_key(path, keystore_password).map_err(|_| NodeSetupError::Custom {
         kind: ErrorKind::ValueValidation,