apollo_consensus_orchestrator: add min gas price to fee market calculation

Author: ayeletstarkware

Cargo.lock

@@ -35,3 +35,4 @@ apollo_node_config = { workspace = true, features = ["testing"] }
 starknet_api.workspace = true
 tempfile.workspace = true
 tracing-test.workspace = true
+validator.workspace = true

crates/apollo_config_manager/Cargo.toml

@@ -1,7 +1,13 @@
 use apollo_config_manager_config::config::ConfigManagerConfig;
 use apollo_consensus_config::config::ConsensusDynamicConfig;
 use apollo_consensus_config::ValidatorId;
+use apollo_consensus_orchestrator_config::config::{
+    parse_price_per_height,
+    ContextDynamicConfig,
+    PricePerHeight,
+};
 use apollo_node_config::node_config::NodeDynamicConfig;
+use validator::Validate;
 
 use crate::config_manager::ConfigManager;
 
@@ -54,3 +60,108 @@ async fn config_manager_update_config() {
         new_consensus_dynamic_config
     );
 }
+
+#[test]
+fn test_context_dynamic_config_serialize_deserialize() {
+    let config = ContextDynamicConfig {
+        min_l2_gas_price_per_height: vec![
+            PricePerHeight { height: 100, price: 10_000_000_000 },
+            PricePerHeight { height: 500, price: 20_000_000_000 },
+            PricePerHeight { height: 1000, price: 30_000_000_000 },
+        ],
+    };
+
+    // Serialize to JSON
+    let json = serde_json::to_string(&config).expect("Failed to serialize");
+
+    // Deserialize back
+    let deserialized: ContextDynamicConfig =
+        serde_json::from_str(&json).expect("Failed to deserialize");
+
+    // Should match original
+    assert_eq!(deserialized, config);
+}
+
+#[test]
+fn test_context_dynamic_config_serialize_deserialize_empty() {
+    let config = ContextDynamicConfig { min_l2_gas_price_per_height: vec![] };
+
+    let json = serde_json::to_string(&config).expect("Failed to serialize");
+    let deserialized: ContextDynamicConfig =
+        serde_json::from_str(&json).expect("Failed to deserialize");
+
+    assert_eq!(deserialized, config);
+}
+
+#[test]
+fn test_parse_price_per_height_with_whitespace() {
+    // Test that whitespace is properly trimmed during parsing
+    let data = " 100 : 10000000000 , 500 :  20000000000 ";
+    // This func is used for deserialization of the min_l2_gas_price_per_height field.
+    let result = parse_price_per_height(data).expect("Failed to parse");
+
+    assert_eq!(result.len(), 2);
+    assert_eq!(result[0].height, 100);
+    assert_eq!(result[0].price, 10_000_000_000);
+    assert_eq!(result[1].height, 500);
+    assert_eq!(result[1].price, 20_000_000_000);
+}
+
+#[test]
+fn test_context_dynamic_config_validation_valid() {
+    let config = ContextDynamicConfig {
+        min_l2_gas_price_per_height: vec![
+            PricePerHeight { height: 100, price: 10_000_000_000 },
+            PricePerHeight { height: 500, price: 20_000_000_000 },
+            PricePerHeight { height: 1000, price: 30_000_000_000 },
+        ],
+    };
+
+    assert!(config.validate().is_ok());
+}
+
+#[test]
+fn test_context_dynamic_config_validation_price_below_minimum() {
+    let config = ContextDynamicConfig {
+        min_l2_gas_price_per_height: vec![
+            PricePerHeight { height: 100, price: 500_000_000 }, // Below 8 gwei
+        ],
+    };
+
+    assert!(config.validate().is_err());
+}
+
+#[test]
+fn test_context_dynamic_config_validation_heights_not_in_order() {
+    let config = ContextDynamicConfig {
+        min_l2_gas_price_per_height: vec![
+            PricePerHeight { height: 500, price: 10_000_000_000 },
+            PricePerHeight { height: 100, price: 20_000_000_000 }, // Out of order
+        ],
+    };
+
+    assert!(config.validate().is_err());
+}
+
+#[test]
+fn test_context_dynamic_config_validation_duplicate_heights() {
+    let config = ContextDynamicConfig {
+        min_l2_gas_price_per_height: vec![
+            PricePerHeight { height: 100, price: 10_000_000_000 },
+            PricePerHeight { height: 100, price: 20_000_000_000 }, // Duplicate
+        ],
+    };
+
+    assert!(config.validate().is_err());
+}
+
+#[test]
+fn test_context_dynamic_config_validation_price_at_minimum() {
+    let config = ContextDynamicConfig {
+        min_l2_gas_price_per_height: vec![
+            PricePerHeight { height: 100, price: 8_000_000_000 }, // Exactly 8 gwei
+        ],
+    };
+
+    assert!(config.validate().is_ok());
+}

crates/apollo_config_manager/src/config_manager_tests.rs

@@ -1,10 +1,12 @@
 use std::cmp::max;
 
+use apollo_consensus_orchestrator_config::config::PricePerHeight;
 use ethnum::U256;
 use serde::Serialize;
-use starknet_api::block::GasPrice;
+use starknet_api::block::{BlockNumber, GasPrice};
 use starknet_api::execution_resources::GasAmount;
 use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
+use tracing::info;
 
 use crate::orchestrator_versioned_constants;
 
@@ -20,35 +22,67 @@ pub struct FeeMarketInfo {
     pub next_l2_gas_price: GasPrice,
 }
 
+/// Get the minimum gas price for a given block height from the min_l2_gas_price_per_height
+/// configuration. If not exist for the given height, use versioned constants min_gas_price as
+/// fallback.
+///
+/// # Parameters
+/// - `height`: The block height to look up.
+/// - `min_l2_gas_price_per_height`: List of height-price pairs from configuration, assumed to be
+///   sorted by height in ascending order.
+pub fn get_min_gas_price_for_height(
+    height: BlockNumber,
+    min_l2_gas_price_per_height: &[PricePerHeight],
+) -> GasPrice {
+    let fallback_min_gas_price =
+        orchestrator_versioned_constants::VersionedConstants::latest_constants().min_gas_price;
+    min_l2_gas_price_per_height
+        .iter()
+        .rev()
+        .find(|e| e.height <= height.0)
+        .map(|e| GasPrice(e.price))
+        .unwrap_or(fallback_min_gas_price)
+}
+
 /// Calculate the base gas price for the next block according to EIP-1559.
 ///
 /// # Parameters
 /// - `price`: The base gas price per unit (in fri) of the current block.
 /// - `gas_used`: The total gas used in the current block.
 /// - `gas_target`: The target gas usage per block.
+/// - `min_gas_price`: The minimum gas price to enforce.
 pub fn calculate_next_base_gas_price(
     price: GasPrice,
     gas_used: GasAmount,
     gas_target: GasAmount,
+    min_gas_price: GasPrice,
 ) -> GasPrice {
     let versioned_constants =
         orchestrator_versioned_constants::VersionedConstants::latest_constants();
     assert!(
         gas_target < versioned_constants.max_block_size,
         "Gas target must be lower than max block size."
     );
-    // A minimum gas price prevents precision loss. Additionally, a minimum gas price helps avoid
-    // extended periods of low pricing.
-    assert!(
-        price >= versioned_constants.min_gas_price,
-        "The gas price must be at least the minimum to prevent precision loss."
-    );
     assert!(gas_target.0 > 0, "Gas target must be greater than zero.");
     assert!(
         versioned_constants.gas_price_max_change_denominator > 0,
         "Denominator constant must be greater than zero."
     );
 
+    // If the current price is below the minimum, apply a gradual adjustment and return early.
+    // This allows the price to increase by at most 1/gas_price_max_change_denominator per block.
+    if price < min_gas_price {
+        let max_increase = price.0 / versioned_constants.gas_price_max_change_denominator;
+        let adjusted = price.0 + max_increase;
+        // Cap at min_gas_price to avoid overshooting
+        let adjusted_price = adjusted.min(min_gas_price.0);
+        info!(
+            "Fee Market: Price {} below minimum gas price {}, adjusted price: {} )",
+            price.0, min_gas_price.0, adjusted_price
+        );
+        return GasPrice(adjusted_price);
+    }
+
     // Use U256 to avoid overflow, as multiplying a u128 by a u64 remains within U256 bounds.
     let gas_delta = U256::from(gas_used.0.abs_diff(gas_target.0));
     let gas_target_u256 = U256::from(gas_target.0);
@@ -71,5 +105,5 @@ pub fn calculate_next_base_gas_price(
 
     // Price should not realistically exceed u128::MAX, bound to avoid theoretical overflow.
     let adjusted_price = u128::try_from(adjusted_price_u256).unwrap_or(u128::MAX);
-    GasPrice(max(adjusted_price, versioned_constants.min_gas_price.0))
+    GasPrice(max(adjusted_price, min_gas_price.0))
 }