apollo_consensus_orchestrator: add SNIP-35 fee_proposals sliding window

Author: sirandreww-starkware

crates/apollo_consensus_orchestrator/src/sequencer_consensus_context.rs

@@ -6,7 +6,7 @@
 mod sequencer_consensus_context_test;
 
 use std::cmp::max;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap, HashMap, VecDeque};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -91,6 +91,7 @@ use crate::metrics::{
     register_metrics,
     CONSENSUS_L2_GAS_PRICE,
 };
+use crate::snip35::FEE_PROPOSAL_WINDOW_SIZE;
 use crate::utils::{
     convert_to_sn_api_block_info,
     make_gas_price_params,
@@ -234,6 +235,8 @@ pub struct SequencerConsensusContext {
     l2_gas_price: GasPrice,
     l1_da_mode: L1DataAvailabilityMode,
     previous_proposal_init: Option<PreviousProposalInitInfo>,
+    /// SNIP-35: sliding window of recent fee_proposal values (size from config).
+    fee_proposals_window: VecDeque<GasPrice>,
 }
 
 #[derive(Clone)]
@@ -282,9 +285,21 @@ impl SequencerConsensusContext {
             l2_gas_price: VersionedConstants::latest_constants().min_gas_price,
             l1_da_mode,
             previous_proposal_init: None,
+            fee_proposals_window: VecDeque::with_capacity(FEE_PROPOSAL_WINDOW_SIZE),
         }
     }
 
+    /// SNIP-35: FIFO append into the fee_proposal sliding window. When the window is at
+    /// `FEE_PROPOSAL_WINDOW_SIZE` the oldest entry is evicted so the window always holds the
+    /// `FEE_PROPOSAL_WINDOW_SIZE` most-recently-committed `fee_proposal` values; the median of
+    /// this window is the `fee_actual` that both proposer and validator use.
+    fn push_fee_proposal(&mut self, fee_proposal: GasPrice) {
+        if self.fee_proposals_window.len() >= FEE_PROPOSAL_WINDOW_SIZE {
+            self.fee_proposals_window.pop_front();
+        }
+        self.fee_proposals_window.push_back(fee_proposal);
+    }
+
     async fn start_stream(&mut self, stream_id: HeightAndRound) -> StreamSender {
         let (proposal_sender, proposal_receiver) =
             mpsc::channel(self.config.static_config.proposal_buffer_size);
@@ -387,6 +402,9 @@ impl SequencerConsensusContext {
         let DecisionReachedResponse { state_diff, central_objects } = decision_reached_response;
 
         self.update_l2_gas_price(height, l2_gas_used);
+        if let Some(fee_proposal) = init.fee_proposal_fri {
+            self.push_fee_proposal(fee_proposal);
+        }
 
         // A hash map of (possibly failed) transactions, where the key is the transaction hash
         // and the value is the transaction itself.
@@ -839,6 +857,12 @@ impl ConsensusContext for SequencerConsensusContext {
             sync_block.block_header_without_hash.next_l2_gas_price,
             VersionedConstants::latest_constants().min_gas_price,
         );
+        // SNIP-35: push fee_proposal from synced block into the sliding window.
+        // Pre-V0_14_3 blocks don't carry a fee_proposal; skip them.
+        if let Some(fee_proposal) = sync_block.block_header_without_hash.fee_proposal_fri {
+            self.push_fee_proposal(fee_proposal);
+        }
+
         // TODO(Asmaa): validate starknet_version and parent_hash when they are stored.
         let block_number = sync_block.block_header_without_hash.block_number;
         let timestamp = sync_block.block_header_without_hash.timestamp;
@@ -895,6 +919,37 @@ impl ConsensusContext for SequencerConsensusContext {
                 let gas_price_u64 = u64::try_from(self.l2_gas_price.0).unwrap_or(u64::MAX);
                 CONSENSUS_L2_GAS_PRICE.set_lossy(gas_price_u64);
             }
+            // SNIP-35: on first height (startup), backfill the fee_proposals window from stored
+            // blocks so fee_actual can be computed immediately. Sequential to maintain insertion
+            // order (oldest first).
+            if self.current_height.is_none() && self.fee_proposals_window.is_empty() {
+                let window_size = u64::try_from(FEE_PROPOSAL_WINDOW_SIZE)
+                    .expect("FEE_PROPOSAL_WINDOW_SIZE fits in u64");
+                let start = height.0.saturating_sub(window_size);
+                for h in start..height.0 {
+                    match self.deps.state_sync_client.get_block(BlockNumber(h)).await {
+                        Ok(block) => {
+                            if let Some(fee_proposal) =
+                                block.block_header_without_hash.fee_proposal_fri
+                            {
+                                self.push_fee_proposal(fee_proposal);
+                            }
+                        }
+                        Err(e) => {
+                            // Stop backfilling on the first error (likely `BlockNotFound` for
+                            // heights before the chain was SNIP-35-enabled). The remaining window
+                            // slots stay empty and `fee_actual` will be `None` until enough blocks
+                            // are committed, falling back to `l2_gas_price`.
+                            warn!(
+                                "SNIP-35 backfill stopped at block {h}: {e:?}. Window has {} / \
+                                 {FEE_PROPOSAL_WINDOW_SIZE} entries.",
+                                self.fee_proposals_window.len()
+                            );
+                            break;
+                        }
+                    }
+                }
+            }
             self.current_height = Some(height);
             self.current_round = round;
             self.queued_proposals.clear();

crates/apollo_consensus_orchestrator/src/sequencer_consensus_context_test.rs

@@ -1493,15 +1493,17 @@ async fn test_first_height_keeps_sync_provided_l2_gas_price() {
     const CONFIG_MIN_PRICE_AT_250: u128 = 25_000_000_000;
 
     let (mut deps, _network) = create_test_and_network_deps();
-    deps.setup_default_expectations();
-    deps.batcher.expect_add_sync_block().times(1).return_once(|_| Ok(()));
-    deps.batcher.expect_start_height().times(2).returning(|_| Ok(()));
+    // Specific get_block expectation must be registered before setup_default_expectations, which
+    // installs a catch-all BlockNotFound handler for SNIP-35 backfill.
     deps.state_sync_client.expect_get_block().times(1).return_once(|height| {
         let mut sync_block = SyncBlock::default();
         sync_block.block_header_without_hash.block_number = height;
         sync_block.block_header_without_hash.next_l2_gas_price = GasPrice(SYNCED_NEXT_L2_GAS_PRICE);
         Ok(sync_block)
     });
+    deps.setup_default_expectations();
+    deps.batcher.expect_add_sync_block().times(1).return_once(|_| Ok(()));
+    deps.batcher.expect_start_height().times(2).returning(|_| Ok(()));
 
     let mut context = deps.build_context();
     context.config.dynamic_config.min_l2_gas_price_per_height =

crates/apollo_consensus_orchestrator/src/snip35/mod.rs

@@ -24,6 +24,9 @@ const FRI_DECIMALS_SCALE: u128 = 10u128.pow(18);
 /// Denominator for parts-per-thousand calculations in SNIP-35 fee_proposal bounds.
 pub(crate) const PPT_DENOMINATOR: u128 = 1000;
 
+/// Number of fee_proposal values used to compute fee_actual (SNIP-35).
+pub(crate) const FEE_PROPOSAL_WINDOW_SIZE: usize = 10;
+
 /// Compute fee_actual from the last `window_size` `fee_proposal` values (SNIP-35).
 ///
 /// Median rule: for even `window_size`, the average of the two middle values rounded

crates/apollo_consensus_orchestrator/src/snip35/test.rs

@@ -29,6 +29,12 @@ fn test_compute_fee_actual_random_window() {
     assert_eq!(compute_fee_actual(&proposals, 12), Some(GasPrice(292)));
 }
 
+#[test]
+fn test_compute_fee_actual_window_size_one_returns_most_recent() {
+    let proposals = vec![GasPrice(100), GasPrice(200), GasPrice(300)];
+    assert_eq!(compute_fee_actual(&proposals, 1), Some(GasPrice(300)));
+}
+
 #[rstest]
 #[case::window_size_zero(vec![GasPrice(100); 10], 0)]
 #[case::fewer_proposals_than_window(vec![GasPrice(100); 9], 10)]

crates/apollo_consensus_orchestrator/src/test_utils.rs

@@ -173,6 +173,7 @@ impl TestDeps {
         self.setup_default_transaction_converter();
         self.setup_default_cende_ambassador();
         self.setup_default_gas_price_provider();
+        self.setup_default_state_sync_get_block();
     }
 
     pub(crate) fn setup_deps_for_build(&mut self, args: SetupDepsArgs) {
@@ -324,24 +325,37 @@ impl TestDeps {
         self.l1_gas_price_provider.expect_get_rate().return_const(Ok(ETH_TO_FRI_RATE));
     }
 
+    /// Default get_block returns NotFound for all blocks. Used by SNIP-35 backfill on startup.
+    fn setup_default_state_sync_get_block(&mut self) {
+        self.state_sync_client.expect_get_block().returning(|block_number| {
+            Err(apollo_state_sync_types::communication::StateSyncClientError::StateSyncError(
+                apollo_state_sync_types::errors::StateSyncError::BlockNotFound(block_number),
+            ))
+        });
+    }
+
     pub(crate) fn setup_default_batcher_get_block_hash(&mut self) {
         self.batcher.expect_get_block_hash().returning(|block_number| {
             Err(BatcherClientError::BatcherError(BatcherError::BlockHashNotFound(block_number)))
         });
     }
 
     pub(crate) fn build_context(self) -> SequencerConsensusContext {
-        SequencerConsensusContext::new(
-            ContextConfig {
-                static_config: ContextStaticConfig {
-                    proposal_buffer_size: CHANNEL_SIZE,
-                    chain_id: CHAIN_ID,
-                    ..Default::default()
-                },
+        self.build_context_with_config(ContextConfig {
+            static_config: ContextStaticConfig {
+                proposal_buffer_size: CHANNEL_SIZE,
+                chain_id: CHAIN_ID,
                 ..Default::default()
             },
-            self.into(),
-        )
+            ..Default::default()
+        })
+    }
+
+    pub(crate) fn build_context_with_config(
+        self,
+        config: ContextConfig,
+    ) -> SequencerConsensusContext {
+        SequencerConsensusContext::new(config, self.into())
     }
 }