apollo_consensus_orchestrator: split consensus config into static and dynamic configs

Author: guy-starkware

crates/apollo_consensus_manager/src/consensus_manager.rs

@@ -270,7 +270,7 @@ impl ConsensusManager {
             SequencerConsensusContextDeps {
                 transaction_converter: Arc::new(TransactionConverter::new(
                     Arc::clone(&self.class_manager_client),
-                    self.config.context_config.chain_id.clone(),
+                    self.config.context_config.static_config.chain_id.clone(),
                 )),
                 state_sync_client: Arc::clone(&self.state_sync_client),
                 batcher: Arc::clone(&self.batcher_client),

crates/apollo_consensus_orchestrator/src/build_proposal_test.rs

@@ -13,7 +13,7 @@ use apollo_class_manager_types::transaction_converter::{
     TransactionConverterError,
 };
 use apollo_consensus::types::{ProposalCommitment as ConsensusProposalCommitment, Round};
-use apollo_consensus_orchestrator_config::config::ContextConfig;
+use apollo_consensus_orchestrator_config::config::{ContextConfig, ContextDynamicConfig};
 use apollo_infra::component_client::ClientError;
 use apollo_protobuf::consensus::{ConsensusBlockInfo, ProposalInit, ProposalPart};
 use apollo_state_sync_types::communication::StateSyncClientError;
@@ -99,7 +99,7 @@ fn create_proposal_build_arguments() -> (TestProposalBuildArguments, mpsc::Recei
     let stream_sender = StreamSender { proposal_sender };
     let context_config = ContextConfig::default();
 
-    let gas_price_params = make_gas_price_params(&context_config);
+    let gas_price_params = make_gas_price_params(&context_config.dynamic_config);
     let valid_proposals = Arc::new(Mutex::new(BuiltProposals::new()));
     let proposal_id = ProposalId(1);
     let cende_write_success = AbortOnDropHandle::new(tokio::spawn(async { true }));

crates/apollo_consensus_orchestrator/src/sequencer_consensus_context.rs

@@ -182,13 +182,13 @@ pub struct SequencerConsensusContextDeps {
 impl SequencerConsensusContext {
     pub fn new(config: ContextConfig, deps: SequencerConsensusContextDeps) -> Self {
         register_metrics();
-        let num_validators = config.num_validators;
-        let l1_da_mode = if config.l1_da_mode {
+        let num_validators = config.static_config.num_validators;
+        let l1_da_mode = if config.static_config.l1_da_mode {
             L1DataAvailabilityMode::Blob
         } else {
             L1DataAvailabilityMode::Calldata
         };
-        let validators = if let Some(ids) = config.validator_ids.clone() {
+        let validators = if let Some(ids) = config.static_config.validator_ids.clone() {
             ids.into_iter().collect()
         } else {
             (0..num_validators).map(|i| ValidatorId::from(DEFAULT_VALIDATOR_ID + i)).collect()
@@ -211,7 +211,8 @@ impl SequencerConsensusContext {
     }
 
     async fn start_stream(&mut self, stream_id: HeightAndRound) -> StreamSender {
-        let (proposal_sender, proposal_receiver) = mpsc::channel(self.config.proposal_buffer_size);
+        let (proposal_sender, proposal_receiver) =
+            mpsc::channel(self.config.static_config.proposal_buffer_size);
         self.deps
             .outbound_proposal_sender
             .send((stream_id, proposal_receiver))
@@ -279,27 +280,29 @@ impl ConsensusContext for SequencerConsensusContext {
         let (fin_sender, fin_receiver) = oneshot::channel();
         let proposal_id = ProposalId(self.proposal_id);
         self.proposal_id += 1;
-        assert!(timeout > self.config.build_proposal_margin_millis);
+        assert!(timeout > self.config.static_config.build_proposal_margin_millis);
         let stream_id = HeightAndRound(proposal_init.height.0, proposal_init.round);
         let stream_sender = self.start_stream(stream_id).await;
 
         info!(?proposal_init, ?timeout, %proposal_id, "Start building proposal");
         let cancel_token = CancellationToken::new();
         let cancel_token_clone = cancel_token.clone();
-        let gas_price_params = make_gas_price_params(&self.config);
+        let gas_price_params = make_gas_price_params(&self.config.dynamic_config);
         let mut l2_gas_price = self.l2_gas_price;
-        if let Some(override_value) = self.config.override_l2_gas_price_fri {
+        if let Some(override_value) = self.config.dynamic_config.override_l2_gas_price_fri {
             info!("Overriding L2 gas price to {override_value} fri");
             l2_gas_price = GasPrice(override_value);
         }
 
         // The following calculations will panic on overflow/negative result.
-        let total_build_proposal_time = timeout - self.config.build_proposal_margin_millis;
+        let total_build_proposal_time =
+            timeout - self.config.static_config.build_proposal_margin_millis;
         let time_now = self.deps.clock.now();
         let batcher_deadline = time_now + total_build_proposal_time;
         let retrospective_block_hash_deadline = time_now
-            + total_build_proposal_time
-                .mul_f32(self.config.build_proposal_time_ratio_for_retrospective_block_hash);
+            + total_build_proposal_time.mul_f32(
+                self.config.static_config.build_proposal_time_ratio_for_retrospective_block_hash,
+            );
 
         let args = ProposalBuildArguments {
             deps: self.deps.clone(),
@@ -312,13 +315,14 @@ impl ConsensusContext for SequencerConsensusContext {
             proposal_id,
             cende_write_success,
             l2_gas_price,
-            builder_address: self.config.builder_address,
+            builder_address: self.config.static_config.builder_address,
             cancel_token,
             previous_block_info: self.previous_block_info.clone(),
             proposal_round: self.current_round,
             retrospective_block_hash_deadline,
             retrospective_block_hash_retry_interval_millis: self
                 .config
+                .static_config
                 .retrospective_block_hash_retry_interval_millis,
         };
         let handle = tokio::spawn(
@@ -377,11 +381,15 @@ impl ConsensusContext for SequencerConsensusContext {
             std::cmp::Ordering::Equal => {
                 let block_info_validation = BlockInfoValidation {
                     height: proposal_init.height,
-                    block_timestamp_window_seconds: self.config.block_timestamp_window_seconds,
+                    block_timestamp_window_seconds: self
+                        .config
+                        .static_config
+                        .block_timestamp_window_seconds,
                     previous_block_info: self.previous_block_info.clone(),
                     l1_da_mode: self.l1_da_mode,
                     l2_gas_price_fri: self
                         .config
+                        .dynamic_config
                         .override_l2_gas_price_fri
                         .map(GasPrice)
                         .unwrap_or(self.l2_gas_price),
@@ -390,7 +398,7 @@ impl ConsensusContext for SequencerConsensusContext {
                     block_info_validation,
                     proposal_init.proposer,
                     timeout,
-                    self.config.validate_proposal_margin_millis,
+                    self.config.static_config.validate_proposal_margin_millis,
                     content_receiver,
                     fin_sender,
                 )
@@ -542,7 +550,7 @@ impl ConsensusContext for SequencerConsensusContext {
             })?;
 
         let gas_target = VersionedConstants::latest_constants().gas_target;
-        if let Some(override_value) = self.config.override_l2_gas_price_fri {
+        if let Some(override_value) = self.config.dynamic_config.override_l2_gas_price_fri {
             info!(
                 "L2 gas price ({}) is not updated, remains on override value of {override_value} \
                  fri",
@@ -666,15 +674,15 @@ impl ConsensusContext for SequencerConsensusContext {
         let now: u64 = self.deps.clock.unix_now();
         if !(block_number == height
             && timestamp.0 >= last_block_timestamp
-            && timestamp.0 <= now + self.config.block_timestamp_window_seconds)
+            && timestamp.0 <= now + self.config.static_config.block_timestamp_window_seconds)
         {
             warn!(
                 "Invalid block info: expected block number {}, got {}, expected timestamp range \
                  [{}, {}], got {}",
                 height,
                 block_number,
                 last_block_timestamp,
-                now + self.config.block_timestamp_window_seconds,
+                now + self.config.static_config.block_timestamp_window_seconds,
                 timestamp.0,
             );
             return false;
@@ -737,16 +745,24 @@ impl ConsensusContext for SequencerConsensusContext {
         };
         let block_info_validation = BlockInfoValidation {
             height,
-            block_timestamp_window_seconds: self.config.block_timestamp_window_seconds,
+            block_timestamp_window_seconds: self
+                .config
+                .static_config
+                .block_timestamp_window_seconds,
             previous_block_info: self.previous_block_info.clone(),
             l1_da_mode: self.l1_da_mode,
-            l2_gas_price_fri: self.l2_gas_price,
+            l2_gas_price_fri: self
+                .config
+                .dynamic_config
+                .override_l2_gas_price_fri
+                .map(GasPrice)
+                .unwrap_or(self.l2_gas_price),
         };
         self.validate_current_round_proposal(
             block_info_validation,
             validator,
             timeout,
-            self.config.validate_proposal_margin_millis,
+            self.config.static_config.validate_proposal_margin_millis,
             content,
             fin_sender,
         )
@@ -770,7 +786,7 @@ impl SequencerConsensusContext {
 
         let cancel_token = CancellationToken::new();
         let cancel_token_clone = cancel_token.clone();
-        let gas_price_params = make_gas_price_params(&self.config);
+        let gas_price_params = make_gas_price_params(&self.config.dynamic_config);
         let args = ProposalValidateArguments {
             deps: self.deps.clone(),
             block_info_validation,

crates/apollo_consensus_orchestrator/src/sequencer_consensus_context_test.rs

@@ -5,7 +5,7 @@ use apollo_batcher_types::batcher_types::{CentralObjects, DecisionReachedRespons
 use apollo_batcher_types::communication::BatcherClientError;
 use apollo_batcher_types::errors::BatcherError;
 use apollo_consensus::types::{ConsensusContext, Round};
-use apollo_consensus_orchestrator_config::config::ContextConfig;
+use apollo_consensus_orchestrator_config::config::{ContextConfig, ContextDynamicConfig};
 use apollo_infra::component_client::ClientError;
 use apollo_l1_gas_price_types::errors::{
     EthToStrkOracleClientError,
@@ -80,7 +80,8 @@ async fn validate_proposal_success() {
     // Initialize the context for a specific height, starting with round 0.
     context.set_height_and_round(BlockNumber(0), 0).await;
 
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     content_sender.send(ProposalPart::BlockInfo(block_info(BlockNumber(0)))).await.unwrap();
     content_sender
         .send(ProposalPart::Transactions(TransactionBatch { transactions: TX_BATCH.to_vec() }))
@@ -116,7 +117,8 @@ async fn dont_send_block_info() {
     // Initialize the context for a specific height, starting with round 0.
     context.set_height_and_round(BlockNumber(0), 0).await;
 
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     let fin_receiver =
         context.validate_proposal(ProposalInit::default(), TIMEOUT, content_receiver).await;
     content_sender.close_channel();
@@ -143,7 +145,8 @@ async fn validate_then_repropose(#[case] execute_all_txs: bool) {
     context.set_height_and_round(BlockNumber(0), 0).await;
 
     // Receive a valid proposal.
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     let block_info = ProposalPart::BlockInfo(block_info(BlockNumber(0)));
     content_sender.send(block_info.clone()).await.unwrap();
     let transactions =
@@ -198,7 +201,8 @@ async fn proposals_from_different_rounds() {
     });
 
     // The proposal from the past round is ignored.
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     content_sender.send(ProposalPart::BlockInfo(block_info(BlockNumber(0)))).await.unwrap();
     content_sender.send(prop_part_txs.clone()).await.unwrap();
     content_sender.send(prop_part_executed_count.clone()).await.unwrap();
@@ -209,7 +213,8 @@ async fn proposals_from_different_rounds() {
     assert!(fin_receiver_past_round.await.is_err());
 
     // The proposal from the current round should be validated.
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     content_sender.send(ProposalPart::BlockInfo(block_info(BlockNumber(0)))).await.unwrap();
     content_sender.send(prop_part_txs.clone()).await.unwrap();
     content_sender.send(prop_part_executed_count.clone()).await.unwrap();
@@ -219,7 +224,8 @@ async fn proposals_from_different_rounds() {
     assert_eq!(fin_receiver_curr_round.await.unwrap().0, STATE_DIFF_COMMITMENT.0.0);
 
     // The proposal from the future round should not be processed.
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     content_sender.send(ProposalPart::BlockInfo(block_info(BlockNumber(0)))).await.unwrap();
     content_sender.send(prop_part_txs.clone()).await.unwrap();
     content_sender.send(prop_part_executed_count.clone()).await.unwrap();
@@ -247,12 +253,12 @@ async fn interrupt_active_proposal() {
     // Keep the sender open, as closing it or sending Fin would cause the validate to complete
     // without needing interrupt.
     let (mut _content_sender_0, content_receiver) =
-        mpsc::channel(context.config.proposal_buffer_size);
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     let fin_receiver_0 =
         context.validate_proposal(ProposalInit::default(), TIMEOUT, content_receiver).await;
 
     let (mut content_sender_1, content_receiver) =
-        mpsc::channel(context.config.proposal_buffer_size);
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     content_sender_1.send(ProposalPart::BlockInfo(block_info(BlockNumber(0)))).await.unwrap();
     content_sender_1
         .send(ProposalPart::Transactions(TransactionBatch { transactions: TX_BATCH.to_vec() }))
@@ -482,7 +488,7 @@ async fn batcher_not_ready(#[case] proposer: bool) {
         assert_eq!(fin_receiver.await, Err(Canceled));
     } else {
         let (mut content_sender, content_receiver) =
-            mpsc::channel(context.config.proposal_buffer_size);
+            mpsc::channel(context.config.static_config.proposal_buffer_size);
         content_sender.send(ProposalPart::BlockInfo(block_info(BlockNumber(0)))).await.unwrap();
 
         let fin_receiver =
@@ -547,7 +553,8 @@ async fn eth_to_fri_rate_out_of_range() {
         .return_const(Ok(()));
     let mut context = deps.build_context();
     context.set_height_and_round(BlockNumber(0), 0).await;
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     // Send a block info with an eth_to_fri_rate that is outside the margin of error.
     let mut block_info = block_info(BlockNumber(0));
     block_info.eth_to_fri_rate *= 2;
@@ -567,7 +574,7 @@ async fn eth_to_fri_rate_out_of_range() {
 async fn gas_price_limits(#[case] maximum: bool) {
     let (mut deps, _network) = create_test_and_network_deps();
     deps.setup_deps_for_validate(BlockNumber(0), INTERNAL_TX_BATCH.len(), 1);
-    let context_config = ContextConfig::default();
+    let context_config = ContextDynamicConfig::default();
     let min_gas_price = context_config.min_l1_gas_price_wei;
     let min_data_price = context_config.min_l1_data_gas_price_wei;
     let max_gas_price = context_config.max_l1_gas_price_wei;
@@ -591,7 +598,8 @@ async fn gas_price_limits(#[case] maximum: bool) {
     let mut context = deps.build_context();
 
     context.set_height_and_round(BlockNumber(0), 0).await;
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
 
     let mut block_info = block_info(BlockNumber(0));
 
@@ -730,7 +738,7 @@ async fn oracle_fails_on_startup(#[case] l1_oracle_failure: bool) {
         panic!("Expected ProposalPart::BlockInfo");
     };
 
-    let default_context_config = ContextConfig::default();
+    let default_context_config = ContextDynamicConfig::default();
     assert_eq!(info.eth_to_fri_rate, DEFAULT_ETH_TO_FRI_RATE);
     // Despite the l1_gas_price_provider being set up not to fail, we still expect the default
     // values because eth_to_strk_rate_oracle_client failed.
@@ -827,7 +835,8 @@ async fn oracle_fails_on_second_block(#[case] l1_oracle_failure: bool) {
     // Initialize the context for a specific height, starting with round 0.
     context.set_height_and_round(BlockNumber(0), 0).await;
 
-    let (mut content_sender, content_receiver) = mpsc::channel(context.config.proposal_buffer_size);
+    let (mut content_sender, content_receiver) =
+        mpsc::channel(context.config.static_config.proposal_buffer_size);
     content_sender.send(ProposalPart::BlockInfo(block_info(BlockNumber(0)))).await.unwrap();
     content_sender
         .send(ProposalPart::Transactions(TransactionBatch { transactions: TX_BATCH.to_vec() }))
@@ -974,17 +983,20 @@ async fn override_prices_behavior(
     deps.cende_ambassador.expect_prepare_blob_for_next_height().return_once(|_| Ok(()));
 
     let context_config = ContextConfig {
-        override_l2_gas_price_fri,
-        override_l1_gas_price_wei,
-        override_l1_data_gas_price_wei,
-        override_eth_to_fri_rate,
+        dynamic_config: ContextDynamicConfig {
+            override_l2_gas_price_fri,
+            override_l1_gas_price_wei,
+            override_l1_data_gas_price_wei,
+            override_eth_to_fri_rate,
+            ..Default::default()
+        },
         ..Default::default()
     };
     let mut context = deps.build_context();
     context.config = context_config;
 
     let min_gas_price = VersionedConstants::latest_constants().min_gas_price.0;
-    let gas_price_params = make_gas_price_params(&context.config);
+    let gas_price_params = make_gas_price_params(&context.config.dynamic_config);
     let mut expected_l1_prices = PriceInfo {
         base_fee_per_gas: GasPrice(TEMP_ETH_GAS_FEE_IN_WEI),
         blob_fee: GasPrice(TEMP_ETH_BLOB_GAS_FEE_IN_WEI),