feat(sidecar): add max_committed_gas_per_slot to sidecar Limits

bolt-sidecar/bin/sidecar.rs

@@ -28,8 +28,7 @@ async fn main() -> eyre::Result<()> {
     let signer = Signer::new(config.private_key.clone().unwrap());
 
     let state_client = StateClient::new(config.execution_api_url.clone());
-    let mut execution_state =
-        ExecutionState::new(state_client, config.limits.max_commitments_per_slot).await?;
+    let mut execution_state = ExecutionState::new(state_client, config.limits).await?;
 
     let mevboost_client = MevBoostClient::new(config.mevboost_url.clone());
     let beacon_client = BeaconClient::new(config.beacon_api_url.clone());

bolt-sidecar/src/builder/template.rs

@@ -111,6 +111,18 @@ impl BlockTemplate {
             .fold(0, |acc, sc| acc + sc.message.constraints.len())
     }
 
+    /// Returns the committed gas in the block template.
+    #[inline]
+    pub fn committed_gas(&self) -> u64 {
+        self.signed_constraints_list.iter().fold(0, |acc, sc| {
+            acc + sc
+                .message
+                .constraints
+                .iter()
+                .fold(0, |acc, c| acc + &c.transaction.gas_limit())
+        })
+    }
+
     /// Returns the blob count of the block template.
     #[inline]
     pub fn blob_count(&self) -> usize {

bolt-sidecar/src/config/mod.rs

@@ -47,6 +47,9 @@ pub struct Opts {
     /// Max number of commitments to accept per block
     #[clap(short = 'm', long)]
     pub(super) max_commitments: Option<NonZero<usize>>,
+    /// Max committed gas per slot
+    #[clap(short = 'g', long)]
+    pub(super) max_committed_gas: Option<NonZero<u64>>,
     /// Validator indexes of connected validators that the sidecar
     /// should accept commitments on behalf of. Accepted values:
     /// - a comma-separated list of indexes (e.g. "1,2,3,4")
@@ -133,16 +136,18 @@ impl Default for Config {
 }
 
 /// Limits for the sidecar.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub struct Limits {
     /// Maximum number of commitments to accept per block
     pub max_commitments_per_slot: NonZero<usize>,
+    pub max_committed_gas_per_slot: NonZero<u64>,
 }
 
 impl Default for Limits {
     fn default() -> Self {
         Self {
             max_commitments_per_slot: NonZero::new(6).expect("Valid non-zero"),
+            max_committed_gas_per_slot: NonZero::new(10_000_000).expect("Valid non-zero"),
         }
     }
 }
@@ -169,6 +174,10 @@ impl TryFrom<Opts> for Config {
             config.limits.max_commitments_per_slot = max_commitments;
         }
 
+        if let Some(max_committed_gas) = opts.max_committed_gas {
+            config.limits.max_committed_gas_per_slot = max_committed_gas;
+        }
+
         config.commit_boost_url = opts
             .signing
             .commit_boost_url

bolt-sidecar/src/state/execution.rs

@@ -4,12 +4,13 @@ use alloy_transport::TransportError;
 use reth_primitives::{
     revm_primitives::EnvKzgSettings, BlobTransactionValidationError, PooledTransactionsElement,
 };
-use std::{collections::HashMap, num::NonZero};
+use std::collections::HashMap;
 use thiserror::Error;
 
 use crate::{
     builder::BlockTemplate,
     common::{calculate_max_basefee, validate_transaction},
+    config::Limits,
     primitives::{AccountState, CommitmentRequest, SignedConstraints, Slot, TransactionExt},
 };
 
@@ -60,6 +61,9 @@ pub enum ValidationError {
     /// The maximum commitments have been reached for the slot.
     #[error("Max commitments reached for slot {0}: {1}")]
     MaxCommitmentsReachedForSlot(u64, usize),
+    /// The maximum committed gas has been reached for the slot.
+    #[error("Max committed gas reached for slot {0}: {1}")]
+    MaxCommittedGasReachedForSlot(u64, u64),
     /// The signature is invalid.
     #[error("Signature error: {0:?}")]
     Signature(#[from] SignatureError),
@@ -111,8 +115,8 @@ pub struct ExecutionState<C> {
     block_templates: HashMap<Slot, BlockTemplate>,
     /// The chain ID of the chain (constant).
     chain_id: u64,
-    /// The maximum number of commitments per slot.
-    max_commitments_per_slot: NonZero<usize>,
+    /// The limits set for the sidecar.
+    limits: Limits,
     /// The KZG settings for validating blobs.
     kzg_settings: EnvKzgSettings,
     /// The state fetcher client.
@@ -142,10 +146,7 @@ impl Default for ValidationParams {
 impl<C: StateFetcher> ExecutionState<C> {
     /// Creates a new state with the given client, initializing the
     /// basefee and head block number.
-    pub async fn new(
-        client: C,
-        max_commitments_per_slot: NonZero<usize>,
-    ) -> Result<Self, TransportError> {
+    pub async fn new(client: C, limits: Limits) -> Result<Self, TransportError> {
         let (basefee, blob_basefee, block_number, chain_id) = tokio::try_join!(
             client.get_basefee(None),
             client.get_blob_basefee(None),
@@ -158,7 +159,7 @@ impl<C: StateFetcher> ExecutionState<C> {
             blob_basefee,
             block_number,
             chain_id,
-            max_commitments_per_slot,
+            limits,
             client,
             slot: 0,
             account_states: HashMap::new(),
@@ -202,14 +203,28 @@ impl<C: StateFetcher> ExecutionState<C> {
 
         // Check if there is room for more commitments
         if let Some(template) = self.get_block_template(target_slot) {
-            if template.transactions_len() >= self.max_commitments_per_slot.get() {
+            if template.transactions_len() >= self.limits.max_commitments_per_slot.get() {
                 return Err(ValidationError::MaxCommitmentsReachedForSlot(
                     self.slot,
-                    self.max_commitments_per_slot.get(),
+                    self.limits.max_commitments_per_slot.get(),
                 ));
             }
         }
 
+        // Check if the committed gas exceeds the maximum
+        let template_committed_gas = self
+            .get_block_template(target_slot)
+            .map(|t| t.committed_gas())
+            .unwrap_or(0);
+        if template_committed_gas + req.tx.gas_limit()
+            >= self.limits.max_committed_gas_per_slot.get()
+        {
+            return Err(ValidationError::MaxCommittedGasReachedForSlot(
+                self.slot,
+                self.limits.max_committed_gas_per_slot.get(),
+            ));
+        }
+
         // Check if the transaction size exceeds the maximum
         if req.tx.size() > self.validation_params.max_tx_input_bytes {
             return Err(ValidationError::TransactionSizeTooHigh);
@@ -460,8 +475,7 @@ mod tests {
         let anvil = launch_anvil();
         let client = StateClient::new(anvil.endpoint_url());
 
-        let max_comms = NonZero::new(10).unwrap();
-        let mut state = ExecutionState::new(client.clone(), max_comms).await?;
+        let mut state = ExecutionState::new(client.clone(), Limits::default()).await?;
 
         let sender = anvil.addresses().first().unwrap();
         let sender_pk = anvil.keys().first().unwrap();
@@ -486,8 +500,7 @@ mod tests {
         let anvil = launch_anvil();
         let client = StateClient::new(anvil.endpoint_url());
 
-        let max_comms = NonZero::new(10).unwrap();
-        let mut state = ExecutionState::new(client.clone(), max_comms).await?;
+        let mut state = ExecutionState::new(client.clone(), Limits::default()).await?;
 
         let sender = anvil.addresses().first().unwrap();
         let sender_pk = anvil.keys().first().unwrap();
@@ -527,8 +540,7 @@ mod tests {
         let anvil = launch_anvil();
         let client = StateClient::new(anvil.endpoint_url());
 
-        let max_comms = NonZero::new(10).unwrap();
-        let mut state = ExecutionState::new(client.clone(), max_comms).await?;
+        let mut state = ExecutionState::new(client.clone(), Limits::default()).await?;
 
         let sender = anvil.addresses().first().unwrap();
         let sender_pk = anvil.keys().first().unwrap();
@@ -580,8 +592,11 @@ mod tests {
         let anvil = launch_anvil();
         let client = StateClient::new(anvil.endpoint_url());
 
-        let max_comms = NonZero::new(10).unwrap();
-        let mut state = ExecutionState::new(client.clone(), max_comms).await?;
+        let limits: Limits = Limits {
+            max_commitments_per_slot: NonZero::new(10).unwrap(),
+            max_committed_gas_per_slot: NonZero::new(10_000_000).unwrap(),
+        };
+        let mut state = ExecutionState::new(client.clone(), limits).await?;
 
         let sender = anvil.addresses().first().unwrap();
         let sender_pk = anvil.keys().first().unwrap();
@@ -611,8 +626,7 @@ mod tests {
         let anvil = launch_anvil();
         let client = StateClient::new(anvil.endpoint_url());
 
-        let max_comms = NonZero::new(10).unwrap();
-        let mut state = ExecutionState::new(client.clone(), max_comms).await?;
+        let mut state = ExecutionState::new(client.clone(), Limits::default()).await?;
 
         let sender = anvil.addresses().first().unwrap();
         let sender_pk = anvil.keys().first().unwrap();
@@ -674,8 +688,7 @@ mod tests {
         let anvil = launch_anvil();
         let client = StateClient::new(anvil.endpoint_url());
 
-        let max_comms = NonZero::new(10).unwrap();
-        let mut state = ExecutionState::new(client.clone(), max_comms).await?;
+        let mut state = ExecutionState::new(client.clone(), Limits::default()).await?;
 
         let basefee = state.basefee();
 
@@ -701,6 +714,38 @@ mod tests {
         Ok(())
     }
 
+    #[tokio::test]
+    async fn test_invalid_inclusion_request_with_excess_gas() -> eyre::Result<()> {
+        let _ = tracing_subscriber::fmt::try_init();
+
+        let anvil = launch_anvil();
+        let client = StateClient::new(anvil.endpoint_url());
+
+        let limits: Limits = Limits {
+            max_commitments_per_slot: NonZero::new(10).unwrap(),
+            max_committed_gas_per_slot: NonZero::new(5_000_000).unwrap(),
+        };
+        let mut state = ExecutionState::new(client.clone(), limits).await?;
+
+        let sender = anvil.addresses().first().unwrap();
+        let sender_pk = anvil.keys().first().unwrap();
+
+        // initialize the state by updating the head once
+        let slot = client.get_head().await?;
+        state.update_head(None, slot).await?;
+
+        let tx = default_test_transaction(*sender, None).with_gas_limit(6_000_000);
+
+        let request = create_signed_commitment_request(tx, sender_pk, 10).await?;
+
+        assert!(matches!(
+            state.validate_commitment_request(&request).await,
+            Err(ValidationError::MaxCommittedGasReachedForSlot(_, 5_000_000))
+        ));
+
+        Ok(())
+    }
+
     #[tokio::test]
     async fn test_invalidate_inclusion_request() -> eyre::Result<()> {
         let _ = tracing_subscriber::fmt::try_init();
@@ -709,8 +754,7 @@ mod tests {
         let client = StateClient::new(anvil.endpoint_url());
         let provider = ProviderBuilder::new().on_http(anvil.endpoint_url());
 
-        let max_comms = NonZero::new(10).unwrap();
-        let mut state = ExecutionState::new(client.clone(), max_comms).await?;
+        let mut state = ExecutionState::new(client.clone(), Limits::default()).await?;
 
         let sender = anvil.addresses().first().unwrap();
         let sender_pk = anvil.keys().first().unwrap();
@@ -776,8 +820,7 @@ mod tests {
         let anvil = launch_anvil();
         let client = StateClient::new(anvil.endpoint_url());
 
-        let max_comms = NonZero::new(10).unwrap();
-        let mut state = ExecutionState::new(client.clone(), max_comms).await?;
+        let mut state = ExecutionState::new(client.clone(), Limits::default()).await?;
 
         let sender = anvil.addresses().first().unwrap();
         let sender_pk = anvil.keys().first().unwrap();
@@ -817,4 +860,60 @@ mod tests {
 
         Ok(())
     }
+
+    #[tokio::test]
+    async fn test_invalidate_inclusion_request_with_excess_gas() -> eyre::Result<()> {
+        let _ = tracing_subscriber::fmt::try_init();
+
+        let anvil = launch_anvil();
+        let client = StateClient::new(anvil.endpoint_url());
+
+        let limits: Limits = Limits {
+            max_commitments_per_slot: NonZero::new(10).unwrap(),
+            max_committed_gas_per_slot: NonZero::new(5_000_000).unwrap(),
+        };
+        let mut state = ExecutionState::new(client.clone(), limits).await?;
+
+        let sender = anvil.addresses().first().unwrap();
+        let sender_pk = anvil.keys().first().unwrap();
+
+        // initialize the state by updating the head once
+        let slot = client.get_head().await?;
+        state.update_head(None, slot).await?;
+
+        let tx = default_test_transaction(*sender, None).with_gas_limit(4_999_999);
+
+        let target_slot = 10;
+        let request = create_signed_commitment_request(tx, sender_pk, target_slot).await?;
+        let inclusion_request = request.as_inclusion_request().unwrap().clone();
+
+        assert!(state.validate_commitment_request(&request).await.is_ok());
+
+        let bls_signer = Signer::random();
+        let message = ConstraintsMessage::build(0, inclusion_request);
+        let signature = bls_signer.sign(&message.digest()).unwrap().to_string();
+        let signed_constraints = SignedConstraints { message, signature };
+
+        state.add_constraint(target_slot, signed_constraints);
+
+        assert!(
+            state
+                .get_block_template(target_slot)
+                .unwrap()
+                .transactions_len()
+                == 1
+        );
+
+        // This tx will exceed the committed gas limit
+        let tx = default_test_transaction(*sender, Some(1));
+
+        let request = create_signed_commitment_request(tx, sender_pk, 10).await?;
+
+        assert!(matches!(
+            state.validate_commitment_request(&request).await,
+            Err(ValidationError::MaxCommittedGasReachedForSlot(_, 5_000_000))
+        ));
+
+        Ok(())
+    }
 }