Modify block producer to take into account the total gas used by the L1 transactions

CHANGELOG.md

@@ -27,6 +27,7 @@ Description of the upcoming release here.
 
 #### Breaking
 
+- [1785](https://github.com/FuelLabs/fuel-core/pull/1785): Producer will only include DA height if it has enough gas to include the associate forced transactions.
 - [#1771](https://github.com/FuelLabs/fuel-core/pull/1771): Contract 'states' and 'balances' brought back into `ContractConfig`. Parquet now writes a file per table.
 - [1779](https://github.com/FuelLabs/fuel-core/pull/1779): Modify Relayer service to order Events from L1 by block index
 - [#1783](https://github.com/FuelLabs/fuel-core/pull/1783): The PR upgrade `fuel-vm` to `0.48.0` release. Because of some breaking changes, we also adapted our codebase to follow them: 

bin/fuel-core/src/cli/run.rs

@@ -1,4 +1,5 @@
 #![allow(unused_variables)]
+
 use crate::{
     cli::{
         default_db_path,
@@ -86,18 +87,18 @@ pub struct Command {
 
     /// The maximum database cache size in bytes.
     #[arg(
-        long = "max-database-cache-size",
-        default_value_t = DEFAULT_DATABASE_CACHE_SIZE,
-        env
+    long = "max-database-cache-size",
+    default_value_t = DEFAULT_DATABASE_CACHE_SIZE,
+    env
     )]
     pub max_database_cache_size: usize,
 
     #[clap(
-        name = "DB_PATH",
-        long = "db-path",
-        value_parser,
-        default_value = default_db_path().into_os_string(),
-        env
+    name = "DB_PATH",
+    long = "db-path",
+    value_parser,
+    default_value = default_db_path().into_os_string(),
+    env
     )]
     pub database_path: PathBuf,
 
@@ -316,6 +317,7 @@ impl Command {
             tx_blacklist_messages,
             tx_blacklist_contracts,
         );
+        let block_gas_limit = chain_config.consensus_parameters.block_gas_limit();
 
         let config = Config {
             addr,
@@ -342,6 +344,7 @@ impl Command {
                 utxo_validation,
                 coinbase_recipient,
                 metrics,
+                block_gas_limit,
             },
             static_gas_price: min_gas_price,
             block_importer,

crates/fuel-core/src/service/adapters/executor.rs

@@ -69,19 +69,20 @@ impl fuel_core_executor::ports::RelayerPort for Database<Relayer> {
         }
     }
 
-    fn get_events(&self, _da_height: &DaBlockHeight) -> anyhow::Result<Vec<Event>> {
+    fn get_events(&self, da_height: &DaBlockHeight) -> anyhow::Result<Vec<Event>> {
         #[cfg(feature = "relayer")]
         {
             use fuel_core_storage::StorageAsRef;
             let events = self
                 .storage::<fuel_core_relayer::storage::EventsHistory>()
-                .get(_da_height)?
+                .get(da_height)?
                 .map(|cow| cow.into_owned())
                 .unwrap_or_default();
             Ok(events)
         }
         #[cfg(not(feature = "relayer"))]
         {
+            let _ = da_height;
             Ok(vec![])
         }
     }

crates/fuel-core/src/service/adapters/producer.rs

@@ -42,7 +42,7 @@ use fuel_core_types::{
             ConsensusParametersVersion,
             StateTransitionBytecodeVersion,
         },
-        primitives,
+        primitives::DaBlockHeight,
     },
     fuel_tx,
     fuel_tx::Transaction,
@@ -123,31 +123,53 @@ impl fuel_core_producer::ports::DryRunner for ExecutorAdapter {
 
 #[async_trait::async_trait]
 impl fuel_core_producer::ports::Relayer for MaybeRelayerAdapter {
-    async fn wait_for_at_least(
+    async fn get_latest_da_blocks_with_costs(
         &self,
-        height: &primitives::DaBlockHeight,
-    ) -> anyhow::Result<primitives::DaBlockHeight> {
+        starting_from: &DaBlockHeight,
+    ) -> anyhow::Result<Vec<(DaBlockHeight, u64)>> {
         #[cfg(feature = "relayer")]
         {
             if let Some(sync) = self.relayer_synced.as_ref() {
-                sync.await_at_least_synced(height).await?;
-                sync.get_finalized_da_height()
+                sync.await_at_least_synced(starting_from).await?;
+                let highest = sync.get_finalized_da_height()?;
+                (starting_from.0..=highest.0)
+                    .map(|height| get_gas_cost_for_height(height, sync))
+                    .collect()
             } else {
-                Ok(0u64.into())
+                Ok(Vec::new())
             }
         }
         #[cfg(not(feature = "relayer"))]
         {
             anyhow::ensure!(
-                **height == 0,
+                **starting_from == 0,
                 "Cannot have a da height above zero without a relayer"
             );
             // If the relayer is not enabled, then all blocks are zero.
-            Ok(0u64.into())
+            Ok(Vec::new())
         }
     }
 }
 
+#[cfg(feature = "relayer")]
+fn get_gas_cost_for_height(
+    height: u64,
+    sync: &fuel_core_relayer::SharedState<
+        Database<crate::database::database_description::relayer::Relayer>,
+    >,
+) -> anyhow::Result<(DaBlockHeight, u64)> {
+    let da_height = DaBlockHeight(height);
+    let cost = sync
+        .database()
+        .storage::<fuel_core_relayer::storage::EventsHistory>()
+        .get(&da_height)?
+        .map(|cow| cow.into_owned())
+        .unwrap_or_default()
+        .iter()
+        .fold(0u64, |acc, event| acc.saturating_add(event.cost()));
+    Ok((da_height, cost))
+}
+
 impl fuel_core_producer::ports::BlockProducerDatabase for Database {
     fn get_block(&self, height: &BlockHeight) -> StorageResult<Cow<CompressedBlock>> {
         self.storage::<FuelBlocks>()

crates/services/producer/src/block_producer.rs

@@ -264,7 +264,8 @@ where
         block_time: Tai64,
     ) -> anyhow::Result<PartialBlockHeader> {
         let mut block_header = self._new_header(height, block_time)?;
-        let new_da_height = self.select_new_da_height(block_header.da_height).await?;
+        let previous_da_height = block_header.da_height;
+        let new_da_height = self.select_new_da_height(previous_da_height).await?;
 
         block_header.application.da_height = new_da_height;
 
@@ -275,17 +276,31 @@ where
         &self,
         previous_da_height: DaBlockHeight,
     ) -> anyhow::Result<DaBlockHeight> {
-        let best_height = self.relayer.wait_for_at_least(&previous_da_height).await?;
-        if best_height < previous_da_height {
-            // If this happens, it could mean a block was erroneously imported
-            // without waiting for our relayer's da_height to catch up to imported da_height.
-            return Err(Error::InvalidDaFinalizationState {
-                best: best_height,
-                previous_block: previous_da_height,
+        let gas_limit = self.config.block_gas_limit;
+        let list = self
+            .relayer
+            .get_latest_da_blocks_with_costs(&previous_da_height)
+            .await?;
+        let mut new_best = previous_da_height;
+        let mut total_cost: u64 = 0;
+        for (da_height, cost) in list.iter() {
+            if da_height < &previous_da_height {
+                return Err(Error::InvalidDaFinalizationState {
+                    best: *da_height,
+                    previous_block: previous_da_height,
+                }
+                .into());
+            }
+            if da_height > &new_best {
+                total_cost = total_cost.saturating_add(*cost);
+                if total_cost > gas_limit {
+                    break;
+                } else {
+                    new_best = *da_height;
+                }
             }
-            .into())
         }
-        Ok(best_height)
+        Ok(new_best)
     }
 
     fn _new_header(