apollo_node_config,apollo_config_manager,apollo_integration_tests: retire preset config-generation path

Delete the flat-preset config generation now that everything loads native: remove
ConfigPointersMap and DeploymentBaseAppConfig::{as_value, dump_config_file,
config_pointers_map, get/modify_config_pointers, validate_all_pointer_targets_set}.
Migrate the integration-test setup and config_manager_runner_tests off the pointer-
resolved as_value path to the native as_native_value path (the config_manager test was
already failing at HEAD: it passed a single --config_file but native load requires two).
Promote normalize_pointer_groups to a shared cfg(testing/test) helper in config_utils.
create_node_config now sets validator_id directly on the real struct (the native dump
ignored the pointer map).

This unblocks deleting CONFIG_POINTERS (its only remaining consumers are the secrets-schema
bin + the transient equivalence test). apollo_config_manager 15/15, apollo_node_config
34/34, apollo_deployments 8/8 green; integration bins compile.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: nimrod-starkware

crates/apollo_config_manager/src/config_manager_runner_tests.rs

@@ -1,4 +1,3 @@
-use std::fs;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -9,77 +8,138 @@ use apollo_config_manager_types::communication::{
     SharedConfigManagerClient,
 };
 use apollo_consensus_config::config::ConsensusDynamicConfig;
-use apollo_node_config::config_utils::DeploymentBaseAppConfig;
-use apollo_node_config::definitions::ConfigPointersMap;
+use apollo_node_config::config_utils::normalize_pointer_groups;
 use apollo_node_config::node_config::{NodeDynamicConfig, SequencerNodeConfig};
 use serde_json::Value;
 use starknet_api::core::ContractAddress;
-use tempfile::NamedTempFile;
+use tempfile::TempDir;
 use tokio::sync::mpsc::channel;
 use tokio::task::yield_now;
 use tokio::time::{interval, timeout};
 use tracing_test::traced_test;
 
 use crate::config_manager_runner::ConfigManagerRunner;
 
-// An arbitrary hex-str config entry to be replaced.
-const VALIDATOR_ID_CONFIG_ENTRY: &str = "validator_id";
+// The nested native path of the validator id within the `SequencerNodeConfig` field hierarchy.
+const VALIDATOR_ID_CONFIG_PATH: &[&str] =
+    &["consensus_manager_config", "consensus_manager_config", "dynamic_config", "validator_id"];
 const TEST_TIMEOUT_SECS: u64 = 1;
+const BASE_CONFIG_FILE_NAME: &str = "base_config.json";
+const SECRETS_CONFIG_FILE_NAME: &str = "secrets_config.json";
+
+// `Sensitive<T>` fields whose derived `Serialize` emits an asymmetric wire shape (a JSON array or
+// `null`) that their string-reading `deserialize_with` cannot consume, and whose deserializer maps
+// the empty string back to `None`. A whole-config `to_value`/`from_value` round-trip fails on them
+// unless they are rewritten to that empty string (see
+// `apollo_node_config::config_serde_symmetry_test` and `apollo_config::converters`). The native
+// node loader avoids this in production by overlaying real values from the secrets file; this test
+// carries no secrets, so it neutralizes them instead.
+const NONE_ABLE_SENSITIVE_KEYS: &[&str] = &["secret_key", "url_header_list"];
+
+// `EthereumBaseLayerConfig::ordered_l1_endpoint_urls: Vec<Sensitive<Url>>` shares the same
+// serialize-array/deserialize-string asymmetry, but its deserializer reads a (space-separated) URL
+// list and `validate_node_config` rejects an empty list, so it has no `None`/empty form to
+// substitute. Rewrite it to a single valid URL string so the config both round-trips and validates.
+const ENDPOINT_URLS_KEY: &str = "ordered_l1_endpoint_urls";
+const PLACEHOLDER_ENDPOINT_URL: &str = "https://localhost:8545";
+
+/// Recursively rewrites the asymmetric `Sensitive` fields in a nested native config map to the
+/// string wire shape their deserializers read, so the config round-trips through serde and passes
+/// validation.
+fn neutralize_sensitive_fields(config: &mut Value) {
+    match config {
+        Value::Object(map) => {
+            for (key, value) in map.iter_mut() {
+                if NONE_ABLE_SENSITIVE_KEYS.contains(&key.as_str()) {
+                    *value = Value::String(String::new());
+                } else if key == ENDPOINT_URLS_KEY {
+                    *value = Value::String(PLACEHOLDER_ENDPOINT_URL.to_string());
+                } else {
+                    neutralize_sensitive_fields(value);
+                }
+            }
+        }
+        Value::Array(items) => items.iter_mut().for_each(neutralize_sensitive_fields),
+        _ => {}
+    }
+}
 
-/// Creates a temporary config file with specific test values and returns CLI args pointing to it.
-fn create_temp_config_file_and_args() -> (NamedTempFile, Vec<String>, String) {
-    let config = SequencerNodeConfig::default();
-    let config_pointers_map = ConfigPointersMap::create_for_testing();
-
-    let base_app_config = DeploymentBaseAppConfig::new(config, config_pointers_map);
+/// Returns a mutable reference to the leaf `validator_id` value within a nested native config map.
+fn validator_id_entry(config: &mut Value) -> &mut Value {
+    let mut entry = config;
+    for segment in VALIDATOR_ID_CONFIG_PATH {
+        entry = entry
+            .as_object_mut()
+            .expect("Native config node must be a JSON object")
+            .get_mut(*segment)
+            .unwrap_or_else(|| panic!("Missing native config segment {segment:?}"));
+    }
+    entry
+}
 
-    // Create a temporary file
-    let temp_file = NamedTempFile::new().expect("Failed to create temporary config file");
+/// Creates a temporary directory holding a native base config file and an (empty) secrets file,
+/// and returns CLI args pointing the native loader at both. The directory handle is returned so the
+/// files outlive the test. Also returns the validator id read from the base config.
+fn create_temp_config_files_and_args() -> (TempDir, Vec<String>, String) {
+    let mut config = SequencerNodeConfig::default();
+    // `SequencerNodeConfig::default()` does not have internally consistent pointer-group values
+    // (chain_id, fee tokens, etc.); reconcile them so the loaded config passes the cross-component
+    // equality validation, mirroring what pointer resolution did at load time.
+    normalize_pointer_groups(&mut config);
+    let mut base_config =
+        serde_json::to_value(&config).expect("Should be able to serialize config to value");
+    neutralize_sensitive_fields(&mut base_config);
+
+    let validator_id = validator_id_entry(&mut base_config)
+        .as_str()
+        .expect("validator_id must be a string")
+        .to_string();
 
-    base_app_config.dump_config_file(temp_file.path());
+    let temp_dir = TempDir::new().expect("Failed to create temporary config dir");
+    let base_config_path = temp_dir.path().join(BASE_CONFIG_FILE_NAME);
+    let secrets_config_path = temp_dir.path().join(SECRETS_CONFIG_FILE_NAME);
 
-    let current_validator_id = base_app_config
-        .as_value()
-        .get(VALIDATOR_ID_CONFIG_ENTRY)
-        .and_then(|v| v.as_str())
-        .expect("Missing or non-string hex value at VALIDATOR_ID_CONFIG_ENTRY")
-        .to_string();
+    let base_content =
+        serde_json::to_string_pretty(&base_config).expect("Failed to serialize base config");
+    std::fs::write(&base_config_path, base_content).expect("Failed to write base config file");
+    // The native loader requires a secrets file overlaid onto the base; the test carries none.
+    std::fs::write(&secrets_config_path, "{}").expect("Failed to write secrets config file");
 
-    // Create cli args pointing to the temp file
+    // The native loader expects two files: the nested base config and the flat secrets config.
     let cli_args = vec![
         "test_node".to_string(),
         CONFIG_FILE_ARG.to_string(),
-        temp_file.path().to_string_lossy().to_string(),
+        base_config_path.to_string_lossy().to_string(),
+        CONFIG_FILE_ARG.to_string(),
+        secrets_config_path.to_string_lossy().to_string(),
     ];
 
-    (temp_file, cli_args, current_validator_id)
+    (temp_dir, cli_args, validator_id)
 }
 
-fn update_config_file(temp_file: &NamedTempFile) -> String {
+/// Bumps the validator id in the native base config file by one and returns the new value.
+fn update_config_file(temp_dir: &TempDir) -> String {
+    let base_config_path = temp_dir.path().join(BASE_CONFIG_FILE_NAME);
     let current_content =
-        fs::read_to_string(temp_file.path()).expect("Failed to read temp config file");
+        std::fs::read_to_string(&base_config_path).expect("Failed to read base config file");
 
-    // Parse JSON (expects a top-level object/map)
-    let mut root: Value = serde_json::from_str(&current_content).expect("Config is not valid JSON");
-    let obj = root.as_object_mut().expect("Config root must be a JSON object");
+    let mut base_config: Value =
+        serde_json::from_str(&current_content).expect("Config is not valid JSON");
 
-    // Get the hex string at the key VALIDATOR_ID_CONFIG_ENTRY (e.g., "validator_id": "0x00ff")
-    let current_validator_id = obj
-        .get(VALIDATOR_ID_CONFIG_ENTRY)
-        .and_then(|v| v.as_str())
-        .expect("Missing or non-string hex value at VALIDATOR_ID_CONFIG_ENTRY");
+    let validator_id_value = validator_id_entry(&mut base_config);
+    let current_validator_id = validator_id_value.as_str().expect("validator_id must be a string");
     assert!(current_validator_id.starts_with("0x"), "Expected a 0x-prefixed hex string");
 
-    // Bump by 1 and preserve width
+    // Bump by 1 and preserve width.
     let hex = &current_validator_id[2..]; // drop "0x"
     let n = u128::from_str_radix(hex, 16).unwrap() + 1;
     let new_validator_id = format!("0x{:0x}", n);
 
-    // Update JSON and write back
-    obj.insert(VALIDATOR_ID_CONFIG_ENTRY.to_string(), Value::String(new_validator_id.clone()));
-    let updated_content = serde_json::to_string_pretty(&root).expect("Failed to serialize JSON");
-    fs::write(temp_file.path(), updated_content)
-        .expect("Failed to write updated config to temp file");
+    *validator_id_value = Value::String(new_validator_id.clone());
+    let updated_content =
+        serde_json::to_string_pretty(&base_config).expect("Failed to serialize JSON");
+    std::fs::write(&base_config_path, updated_content)
+        .expect("Failed to write updated config to base config file");
 
     new_validator_id
 }
@@ -94,8 +154,8 @@ async fn config_manager_runner_update_config_with_changed_values() {
     // Set a config manager config.
     let config_manager_config = ConfigManagerConfig::default();
 
-    // Create a temporary config file and get the validator id value.
-    let (temp_file, cli_args, validator_id_value) = create_temp_config_file_and_args();
+    // Create temporary config files and get the validator id value.
+    let (temp_dir, cli_args, validator_id_value) = create_temp_config_files_and_args();
 
     let node_dynamic_config = NodeDynamicConfig::default();
 
@@ -128,7 +188,7 @@ async fn config_manager_runner_update_config_with_changed_values() {
     );
 
     // Edit the config file and then trigger a config update, expecting the new validator id.
-    let new_validator_id = update_config_file(&temp_file);
+    let new_validator_id = update_config_file(&temp_dir);
     let expected_validator_id = ContractAddress::from(hex_to_u128(new_validator_id.as_str()));
 
     let second_update_config_result = config_manager_runner.update_config().await;
@@ -145,8 +205,8 @@ async fn config_manager_runner_update_config_with_changed_values() {
 
 #[tokio::test]
 async fn watcher_triggers_update_on_file_change() {
-    // Prepare temp config file and CLI args.
-    let (temp_file, cli_args, _) = create_temp_config_file_and_args();
+    // Prepare temp config files and CLI args.
+    let (temp_dir, cli_args, _) = create_temp_config_files_and_args();
 
     // Channel to observe that update_config was called.
     let (tx, mut rx) = channel(1);
@@ -174,7 +234,7 @@ async fn watcher_triggers_update_on_file_change() {
     yield_now().await;
 
     // Modify the config file to trigger an event.
-    let _ = update_config_file(&temp_file);
+    let _ = update_config_file(&temp_dir);
 
     // Wait until the update call is observed or timeout.
     timeout(Duration::from_secs(TEST_TIMEOUT_SECS), rx.recv())

crates/apollo_integration_tests/src/bin/sequencer_node_end_to_end_integration_tests/integration_test_revert_flow.rs

@@ -5,9 +5,7 @@ use apollo_infra_utils::test_utils::TestIdentifier;
 use apollo_integration_tests::integration_test_manager::IntegrationTestManager;
 use apollo_integration_tests::integration_test_utils::integration_test_setup;
 use apollo_integration_tests::utils::NodeDescriptor;
-use apollo_node_config::definitions::ConfigPointersMap;
 use apollo_node_config::node_config::SequencerNodeConfig;
-use serde_json::Value;
 use starknet_api::block::BlockNumber;
 use tracing::info;
 
@@ -142,34 +140,11 @@ fn modify_revert_config_idle_nodes(
     node_indices: HashSet<usize>,
     revert_up_to_and_including: Option<BlockNumber>,
 ) {
-    integration_test_manager.modify_config_pointers_idle_nodes(
-        node_indices.clone(),
-        |config_pointers| {
-            modify_revert_config_pointers(config_pointers, revert_up_to_and_including)
-        },
-    );
-    integration_test_manager.modify_config_idle_nodes(node_indices, |config_pointers| {
-        modify_revert_config(config_pointers, revert_up_to_and_including)
+    integration_test_manager.modify_config_idle_nodes(node_indices, |config| {
+        modify_revert_config(config, revert_up_to_and_including)
     });
 }
 
-fn modify_revert_config_pointers(
-    config_pointers: &mut ConfigPointersMap,
-    revert_up_to_and_including: Option<BlockNumber>,
-) {
-    let should_revert = revert_up_to_and_including.is_some();
-    config_pointers.change_target_value("revert_config.should_revert", Value::from(should_revert));
-
-    // If should revert is false, the revert_up_to_and_including value is irrelevant.
-    if should_revert {
-        let revert_up_to_and_including = revert_up_to_and_including.unwrap();
-        config_pointers.change_target_value(
-            "revert_config.revert_up_to_and_including",
-            Value::from(revert_up_to_and_including.0),
-        );
-    }
-}
-
 fn modify_revert_config(
     config: &mut SequencerNodeConfig,
     revert_up_to_and_including: Option<BlockNumber>,

crates/apollo_integration_tests/src/executable_setup.rs

@@ -5,7 +5,6 @@ use apollo_monitoring_endpoint::test_utils::MonitoringClient;
 use apollo_monitoring_endpoint_config::config::MonitoringEndpointConfig;
 use apollo_node::test_utils::node_runner::NodeRunner;
 use apollo_node_config::config_utils::DeploymentBaseAppConfig;
-use apollo_node_config::definitions::ConfigPointersMap;
 use apollo_node_config::node_config::SequencerNodeConfig;
 use tempfile::{tempdir, TempDir};
 use tokio::fs::create_dir_all;
@@ -118,14 +117,6 @@ impl ExecutableSetup {
         self.dump_config_file_changes();
     }
 
-    pub fn modify_config_pointers<F>(&mut self, modify_config_pointers_fn: F)
-    where
-        F: Fn(&mut ConfigPointersMap),
-    {
-        self.base_app_config.modify_config_pointers(modify_config_pointers_fn);
-        self.dump_config_file_changes();
-    }
-
     pub fn get_config(&self) -> &SequencerNodeConfig {
         self.base_app_config.get_config()
     }

crates/apollo_integration_tests/src/flow_test_setup.rs

@@ -307,7 +307,7 @@ impl FlowSequencerSetup {
         };
 
         // Derive the configuration for the sequencer node.
-        let (mut node_config, _config_pointers_map) = create_node_config(
+        let mut node_config = create_node_config(
             &mut available_ports,
             chain_info,
             storage_config,

crates/apollo_integration_tests/src/integration_test_manager.rs

@@ -21,7 +21,6 @@ use apollo_node_config::component_execution_config::{
     ReactiveComponentExecutionConfig,
 };
 use apollo_node_config::config_utils::DeploymentBaseAppConfig;
-use apollo_node_config::definitions::ConfigPointersMap;
 use apollo_node_config::node_config::SequencerNodeConfig;
 use apollo_storage::storage_reader_server_test_utils::send_storage_reader_http_request;
 use apollo_storage::storage_reader_types::{StorageReaderRequest, StorageReaderResponse};
@@ -564,27 +563,6 @@ impl IntegrationTestManager {
         });
     }
 
-    pub fn modify_config_pointers_idle_nodes<F>(
-        &mut self,
-        nodes_to_modify_config_pointers: HashSet<usize>,
-        modify_config_pointers_fn: F,
-    ) where
-        F: Fn(&mut ConfigPointersMap) + Copy,
-    {
-        info!("Modifying specified nodes config pointers.");
-
-        nodes_to_modify_config_pointers.into_iter().for_each(|node_index| {
-            let node_setup = self
-                .idle_nodes
-                .get_mut(&node_index)
-                .unwrap_or_else(|| panic!("Node {node_index} does not exist in idle_nodes."));
-            node_setup.get_executables_mut().for_each(|executable| {
-                info!("Modifying {} config pointers.", executable.node_executable_id);
-                executable.modify_config_pointers(modify_config_pointers_fn);
-            });
-        });
-    }
-
     pub async fn await_revert_all_running_nodes(
         &self,
         expected_block_number: BlockNumber,
@@ -1407,7 +1385,7 @@ async fn get_sequencer_setup_configs(
                 ..Default::default()
             };
 
-            let (config, config_pointers_map) = create_node_config(
+            let config = create_node_config(
                 &mut config_available_ports,
                 chain_info.clone(),
                 storage_setup.storage_config.clone(),
@@ -1426,7 +1404,7 @@ async fn get_sequencer_setup_configs(
                 !is_proof_flow,
             );
 
-            let base_app_config = DeploymentBaseAppConfig::new(config, config_pointers_map);
+            let base_app_config = DeploymentBaseAppConfig::new(config);
 
             let node_executable_id = NodeExecutableId::new(
                 node_index,