apollo_node_config: introduce validation only node config. (#13557)

Author: asaf-sw

crates/apollo_batcher_config/src/config.rs

@@ -247,6 +247,9 @@ pub struct BatcherStaticConfig {
     // TODO(Amos): Move to commitment manager config.
     pub first_block_with_partial_block_hash: Option<FirstBlockWithPartialBlockHash>,
     pub storage_reader_server_static_config: StorageReaderServerStaticConfig,
+    /// If true, the batcher only validates proposed blocks and cannot build proposals.
+    /// Set via the node-level validation_only config pointer.
+    pub validation_only: bool,
 }
 
 impl SerializeConfig for BatcherStaticConfig {
@@ -308,6 +311,13 @@ impl SerializeConfig for BatcherStaticConfig {
             self.storage_reader_server_static_config.dump(),
             "storage_reader_server_static_config",
         ));
+        dump.append(&mut BTreeMap::from([ser_param(
+            "validation_only",
+            &self.validation_only,
+            "If true, the batcher only validates proposed blocks and cannot build proposals. Set \
+             via the node-level validation_only config pointer.",
+            ParamPrivacyInput::Public,
+        )]));
         dump
     }
 }
@@ -336,6 +346,7 @@ impl Default for BatcherStaticConfig {
             propose_l1_txs_every: 1, // Default is to propose L1 transactions every proposal.
             first_block_with_partial_block_hash: None,
             storage_reader_server_static_config: StorageReaderServerStaticConfig::default(),
+            validation_only: false,
         }
     }
 }

crates/apollo_deployments/resources/app_configs/general_config.json

@@ -1,5 +1,6 @@
 {
   "behavior_mode": "starknet",
+  "validation_only": false,
   "chain_id": "",
   "eth_fee_token_address": "",
   "native_classes_whitelist": "[]",

crates/apollo_deployments/resources/app_configs/replacer_general_config.json

@@ -10,6 +10,7 @@
   "starknet_url": "$$$_STARKNET_URL_$$$",
   "strk_fee_token_address": "$$$_STRK_FEE_TOKEN_ADDRESS_$$$",
   "validate_resource_bounds": true,
+  "validation_only": false,
   "validator_id": "$$$_VALIDATOR_ID_$$$",
   "versioned_constants_overrides.#is_none": true,
   "versioned_constants_overrides.invoke_tx_max_n_steps": 10000000,

crates/apollo_integration_tests/src/utils.rs

@@ -363,6 +363,7 @@ pub fn create_node_config(
     let state_sync_config = wrap_if_component_config_expected!(state_sync, state_sync_config);
 
     let sequencer_node_config = SequencerNodeConfig {
+        validation_only: false,
         base_layer_config,
         batcher_config,
         class_manager_config,

crates/apollo_node/resources/config_schema.json

@@ -399,6 +399,11 @@
     "privacy": "Public",
     "value": 8091
   },
+  "batcher_config.static_config.validation_only": {
+    "description": "If true, the batcher only validates proposed blocks and cannot build proposals. Set via the node-level validation_only config pointer.",
+    "pointer_target": "validation_only",
+    "privacy": "Public"
+  },
   "behavior_mode": {
     "description": "Behavior mode: 'starknet' for production, 'echonet' for test/replay mode.",
     "privacy": "TemporaryValue",
@@ -3999,6 +4004,11 @@
     "privacy": "TemporaryValue",
     "value": true
   },
+  "validation_only": {
+    "description": "If true, the node validates proposed blocks but does not build proposals. Requires gateway, http_server, and mempool to be disabled.",
+    "privacy": "TemporaryValue",
+    "value": false
+  },
   "validator_id": {
     "description": "The ID of the validator. Also the address of this validator as a starknet contract.",
     "privacy": "TemporaryValue",

crates/apollo_node_config/src/component_execution_config.rs

@@ -21,6 +21,7 @@ pub const DEFAULT_INVALID_PORT: u16 = 0;
 
 pub trait ExpectedComponentConfig {
     fn is_running_locally(&self) -> bool;
+    fn is_disabled(&self) -> bool;
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
@@ -41,6 +42,10 @@ impl ExpectedComponentConfig for ReactiveComponentExecutionMode {
             | ReactiveComponentExecutionMode::LocalExecutionWithRemoteDisabled => true,
         }
     }
+
+    fn is_disabled(&self) -> bool {
+        *self == ReactiveComponentExecutionMode::Disabled
+    }
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
@@ -56,6 +61,10 @@ impl ExpectedComponentConfig for ActiveComponentExecutionMode {
             ActiveComponentExecutionMode::Enabled => true,
         }
     }
+
+    fn is_disabled(&self) -> bool {
+        *self == ActiveComponentExecutionMode::Disabled
+    }
 }
 
 /// Reactive component configuration.
@@ -185,6 +194,10 @@ impl ExpectedComponentConfig for ReactiveComponentExecutionConfig {
     fn is_running_locally(&self) -> bool {
         self.execution_mode.is_running_locally()
     }
+
+    fn is_disabled(&self) -> bool {
+        self.execution_mode.is_disabled()
+    }
 }
 
 /// Active component configuration.
@@ -215,6 +228,10 @@ impl ExpectedComponentConfig for ActiveComponentExecutionConfig {
     fn is_running_locally(&self) -> bool {
         self.execution_mode.is_running_locally()
     }
+
+    fn is_disabled(&self) -> bool {
+        self.execution_mode.is_disabled()
+    }
 }
 
 impl ActiveComponentExecutionConfig {

crates/apollo_node_config/src/config_test.rs

@@ -5,7 +5,9 @@ use apollo_infra_utils::dumping::serialize_to_file_test;
 use rstest::rstest;
 use validator::Validate;
 
+use crate::component_config::ComponentConfig;
 use crate::component_execution_config::{
+    ActiveComponentExecutionConfig,
     ReactiveComponentExecutionConfig,
     ReactiveComponentExecutionMode,
 };
@@ -110,3 +112,63 @@ fn monitoring_config(
     let component_exe_config = MonitoringConfig { collect_metrics, collect_profiling_metrics };
     assert_eq!(component_exe_config.validate().is_ok(), expected_successful_validation);
 }
+
+#[test]
+fn validation_only_with_gateway_enabled_fails() {
+    // gateway is running locally in the default config.
+    let config = SequencerNodeConfig { validation_only: true, ..Default::default() };
+    let err = config.validate_node_config().unwrap_err();
+    assert!(format!("{err:?}").contains("gateway"), "Unexpected error: {err:?}");
+}
+
+#[test]
+fn validation_only_with_http_server_enabled_fails() {
+    // Disable gateway to reach the http_server check; http_server is enabled in the default.
+    let config = SequencerNodeConfig {
+        validation_only: true,
+        components: ComponentConfig {
+            gateway: ReactiveComponentExecutionConfig::disabled(),
+            ..Default::default()
+        },
+        gateway_config: None,
+        ..Default::default()
+    };
+    let err = config.validate_node_config().unwrap_err();
+    assert!(format!("{err:?}").contains("http_server"), "Unexpected error: {err:?}");
+}
+
+#[test]
+fn validation_only_with_mempool_enabled_fails() {
+    // Disable gateway and http_server to reach the mempool check; mempool runs locally by default.
+    let config = SequencerNodeConfig {
+        validation_only: true,
+        components: ComponentConfig {
+            gateway: ReactiveComponentExecutionConfig::disabled(),
+            http_server: ActiveComponentExecutionConfig::disabled(),
+            ..Default::default()
+        },
+        gateway_config: None,
+        http_server_config: None,
+        ..Default::default()
+    };
+    let err = config.validate_node_config().unwrap_err();
+    assert!(format!("{err:?}").contains("mempool"), "Unexpected error: {err:?}");
+}
+
+#[test]
+fn validation_only_with_tx_ingestion_disabled_succeeds() {
+    let config = SequencerNodeConfig {
+        validation_only: true,
+        components: ComponentConfig {
+            gateway: ReactiveComponentExecutionConfig::disabled(),
+            http_server: ActiveComponentExecutionConfig::disabled(),
+            mempool: ReactiveComponentExecutionConfig::disabled(),
+            ..Default::default()
+        },
+        gateway_config: None,
+        http_server_config: None,
+        mempool_config: None,
+        ..Default::default()
+    };
+    assert!(config.validate_node_config().is_ok());
+}

crates/apollo_node_config/src/node_config.rs

@@ -12,6 +12,7 @@ use apollo_config::dumping::{
     generate_struct_pointer,
     prepend_sub_config_name,
     ser_optional_sub_config,
+    ser_param,
     ser_pointer_target_param,
     set_pointing_param_paths,
     ConfigPointers,
@@ -20,7 +21,7 @@ use apollo_config::dumping::{
 };
 use apollo_config::loading::load_and_process_config;
 use apollo_config::validators::config_validate;
-use apollo_config::{ConfigError, ParamPath, SerializedParam};
+use apollo_config::{ConfigError, ParamPath, ParamPrivacyInput, SerializedParam};
 use apollo_config_manager_config::config::ConfigManagerConfig;
 use apollo_consensus_config::config::ConsensusDynamicConfig;
 use apollo_consensus_manager_config::config::ConsensusManagerConfig;
@@ -213,6 +214,15 @@ pub static CONFIG_POINTERS: LazyLock<ConfigPointers> = LazyLock::new(|| {
             "mempool_config.static_config.behavior_mode",
         ]),
     ));
+    pointers.push((
+        ser_pointer_target_param(
+            "validation_only",
+            &false,
+            "If true, the node validates proposed blocks but does not build proposals. Requires \
+             gateway, http_server, and mempool to be disabled.",
+        ),
+        set_pointing_param_paths(&["batcher_config.static_config.validation_only"]),
+    ));
     pointers
 });
 
@@ -223,6 +233,9 @@ pub static CONFIG_NON_POINTERS_WHITELIST: LazyLock<Pointers> =
 /// The configurations of the various components of the node.
 #[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Validate)]
 pub struct SequencerNodeConfig {
+    /// If true, the node validates proposed blocks but does not build proposals.
+    /// Requires gateway, http_server, and mempool to be disabled.
+    pub validation_only: bool,
     // Infra related configs.
     #[validate(nested)]
     pub components: ComponentConfig,
@@ -269,6 +282,13 @@ pub struct SequencerNodeConfig {
 
 impl SerializeConfig for SequencerNodeConfig {
     fn dump(&self) -> BTreeMap<ParamPath, SerializedParam> {
+        let mut dump = BTreeMap::from([ser_param(
+            "validation_only",
+            &self.validation_only,
+            "If true, the node validates proposed blocks but does not build proposals. Requires \
+             gateway, http_server, and mempool to be disabled.",
+            ParamPrivacyInput::Public,
+        )]);
         let sub_configs = vec![
             // Infra related configs.
             prepend_sub_config_name(self.components.dump(), "components"),
@@ -300,13 +320,15 @@ impl SerializeConfig for SequencerNodeConfig {
             ser_optional_sub_config(&self.state_sync_config, "state_sync_config"),
         ];
 
-        sub_configs.into_iter().flatten().collect()
+        dump.extend(sub_configs.into_iter().flatten());
+        dump
     }
 }
 
 impl Default for SequencerNodeConfig {
     fn default() -> Self {
         Self {
+            validation_only: false,
             // Infra related configs.
             components: ComponentConfig::default(),
             config_manager_config: Some(ConfigManagerConfig::default()),
@@ -547,6 +569,35 @@ impl SequencerNodeConfig {
             }
         }
 
+        self.validate_validation_only_config()?;
+
+        Ok(())
+    }
+
+    /// Validates that when `validation_only=true`, all tx-ingestion components are disabled.
+    fn validate_validation_only_config(&self) -> Result<(), ConfigError> {
+        if !self.validation_only {
+            return Ok(());
+        }
+        if !self.components.gateway.is_disabled() {
+            return Err(ConfigError::ComponentConfigMismatch {
+                component_config_mismatch: "gateway must be disabled when validation_only is true"
+                    .to_string(),
+            });
+        }
+        if !self.components.http_server.is_disabled() {
+            return Err(ConfigError::ComponentConfigMismatch {
+                component_config_mismatch: "http_server must be disabled when validation_only is \
+                                            true"
+                    .to_string(),
+            });
+        }
+        if !self.components.mempool.is_disabled() {
+            return Err(ConfigError::ComponentConfigMismatch {
+                component_config_mismatch: "mempool must be disabled when validation_only is true"
+                    .to_string(),
+            });
+        }
         Ok(())
     }
 }