Enforce the block size limit

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ## [Unreleased]
 
 ### Added
+- [2195](https://github.com/FuelLabs/fuel-core/pull/2195): Added enforcement of the limit on the size of the L2 transactions per block according to the `block_transaction_size_limit` parameter.
 - [2131](https://github.com/FuelLabs/fuel-core/pull/2131): Add flow in TxPool in order to ask to newly connected peers to share their transaction pool
 - [2182](https://github.com/FuelLabs/fuel-core/pull/2151): Limit number of transactions that can be fetched via TxSource::next
 

bin/e2e-test-client/tests/integration_tests.rs

@@ -119,6 +119,12 @@ fn dev_config() -> Config {
         .consensus_parameters
         .set_tx_params(tx_parameters);
     chain_config.consensus_parameters.set_fee_params(fee_params);
+    if let Err(_e) = chain_config
+        .consensus_parameters
+        .set_block_transaction_size_limit(u64::MAX)
+    {
+        eprintln!("failed to set block transaction size limit");
+    }
     chain_config.state_transition_bytecode =
         fuel_core::upgradable_executor::WASM_BYTECODE.to_vec();
     let reader = reader.with_chain_config(chain_config);

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

@@ -9,15 +9,18 @@ use fuel_core_types::{
 };
 
 impl fuel_core_executor::ports::TransactionsSource for TransactionsSource {
-    // TODO: Use `size_limit` https://github.com/FuelLabs/fuel-core/issues/2133
     fn next(
         &self,
         gas_limit: u64,
         transactions_limit: u16,
-        _: u32,
+        block_transaction_size_limit: u64,
     ) -> Vec<MaybeCheckedTransaction> {
         self.txpool
-            .select_transactions(gas_limit, transactions_limit)
+            .select_transactions(
+                gas_limit,
+                transactions_limit,
+                block_transaction_size_limit,
+            )
             .into_iter()
             .map(|tx| {
                 MaybeCheckedTransaction::CheckedTransaction(
@@ -28,7 +31,6 @@ impl fuel_core_executor::ports::TransactionsSource for TransactionsSource {
             .collect()
     }
 }
-
 impl fuel_core_executor::ports::RelayerPort for ReyalerIterableKeyValueView {
     fn enabled(&self) -> bool {
         #[cfg(feature = "relayer")]

crates/services/executor/src/executor.rs

@@ -194,7 +194,7 @@ impl TransactionsSource for OnceTransactionsSource {
         &self,
         _: u64,
         transactions_limit: u16,
-        _: u32,
+        _: u64,
     ) -> Vec<MaybeCheckedTransaction> {
         let mut lock = self.transactions.lock();
         let transactions: &mut Vec<MaybeCheckedTransaction> = lock.as_mut();
@@ -209,6 +209,7 @@ impl TransactionsSource for OnceTransactionsSource {
 pub struct ExecutionData {
     coinbase: u64,
     used_gas: u64,
+    used_size: u64,
     tx_count: u16,
     found_mint: bool,
     message_ids: Vec<MessageId>,
@@ -224,6 +225,7 @@ impl ExecutionData {
         ExecutionData {
             coinbase: 0,
             used_gas: 0,
+            used_size: 0,
             tx_count: 0,
             found_mint: false,
             message_ids: Vec::new(),
@@ -296,6 +298,7 @@ where
             skipped_transactions,
             coinbase,
             used_gas,
+            used_size,
             ..
         } = execution_data;
 
@@ -306,8 +309,8 @@ where
         let finalized_block_id = block.id();
 
         debug!(
-            "Block {:#x} fees: {} gas: {}",
-            finalized_block_id, coinbase, used_gas
+            "Block {:#x} fees: {} gas: {} tx_size: {}",
+            finalized_block_id, coinbase, used_gas, used_size
         );
 
         let result = ExecutionResult {
@@ -331,6 +334,7 @@ where
         let ExecutionData {
             coinbase,
             used_gas,
+            used_size,
             tx_status,
             events,
             changes,
@@ -340,8 +344,8 @@ where
         let finalized_block_id = block.id();
 
         debug!(
-            "Block {:#x} fees: {} gas: {}",
-            finalized_block_id, coinbase, used_gas
+            "Block {:#x} fees: {} gas: {} tx_size: {}",
+            finalized_block_id, coinbase, used_gas, used_size
         );
 
         let result = ValidationResult { tx_status, events };
@@ -575,10 +579,12 @@ where
             ..
         } = components;
         let block_gas_limit = self.consensus_params.block_gas_limit();
+        let block_transaction_size_limit =
+            self.consensus_params.block_transaction_size_limit();
 
         let mut remaining_gas_limit = block_gas_limit.saturating_sub(data.used_gas);
-        // TODO: Handle `remaining_size` https://github.com/FuelLabs/fuel-core/issues/2133
-        let remaining_size = u32::MAX;
+        let mut remaining_block_transaction_size_limit =
+            block_transaction_size_limit.saturating_sub(data.used_size);
 
         // We allow at most u16::MAX transactions in a block, including the mint transaction.
         // When processing l2 transactions, we must take into account transactions from the l1
@@ -587,7 +593,11 @@ where
         let mut remaining_tx_count = MAX_TX_COUNT.saturating_sub(data.tx_count);
 
         let mut regular_tx_iter = l2_tx_source
-            .next(remaining_gas_limit, remaining_tx_count, remaining_size)
+            .next(
+                remaining_gas_limit,
+                remaining_tx_count,
+                remaining_block_transaction_size_limit,
+            )
             .into_iter()
             .take(remaining_tx_count as usize)
             .peekable();
@@ -614,11 +624,17 @@ where
                     }
                 }
                 remaining_gas_limit = block_gas_limit.saturating_sub(data.used_gas);
+                remaining_block_transaction_size_limit =
+                    block_transaction_size_limit.saturating_sub(data.used_size);
                 remaining_tx_count = MAX_TX_COUNT.saturating_sub(data.tx_count);
             }
 
             regular_tx_iter = l2_tx_source
-                .next(remaining_gas_limit, remaining_tx_count, remaining_size)
+                .next(
+                    remaining_gas_limit,
+                    remaining_tx_count,
+                    remaining_block_transaction_size_limit,
+                )
                 .into_iter()
                 .take(remaining_tx_count as usize)
                 .peekable();
@@ -1413,6 +1429,8 @@ where
         tx_id: TxId,
     ) -> ExecutorResult<()> {
         let (used_gas, tx_fee) = self.total_fee_paid(tx, &receipts, gas_price)?;
+        let used_size = tx.metered_bytes_size() as u64;
+
         execution_data.coinbase = execution_data
             .coinbase
             .checked_add(tx_fee)
@@ -1421,6 +1439,10 @@ where
             .used_gas
             .checked_add(used_gas)
             .ok_or(ExecutorError::GasOverflow)?;
+        execution_data.used_size = execution_data
+            .used_size
+            .checked_add(used_size)
+            .ok_or(ExecutorError::TxSizeOverflow)?;
 
         if !reverted {
             execution_data

crates/services/executor/src/ports.rs

@@ -115,14 +115,14 @@ impl TransactionExt for MaybeCheckedTransaction {
 }
 
 pub trait TransactionsSource {
-    /// Returns the next batch of transactions to satisfy the `gas_limit`.
+    /// Returns the next batch of transactions to satisfy the `gas_limit` and `block_transaction_size_limit`.
     /// The returned batch has at most `tx_count_limit` transactions, none
     /// of which has a size in bytes greater than `size_limit`.
     fn next(
         &self,
         gas_limit: u64,
         tx_count_limit: u16,
-        size_limit: u32,
+        block_transaction_size_limit: u64,
     ) -> Vec<MaybeCheckedTransaction>;
 }
 

crates/services/txpool/src/service.rs

@@ -41,7 +41,6 @@ use fuel_core_types::{
         txpool::{
             ArcPoolTx,
             InsertionResult,
-            PoolTransaction,
             TransactionStatus,
         },
     },
@@ -396,13 +395,14 @@ impl<P2P, ViewProvider, WasmChecker, GasPriceProvider, ConsensusProvider, MP>
         &self,
         max_gas: u64,
         transactions_limit: u16,
+        block_transaction_size_limit: u64,
     ) -> Vec<ArcPoolTx> {
         let mut guard = self.txpool.lock();
         let txs = guard.includable();
-        let sorted_txs: Vec<Arc<PoolTransaction>> = select_transactions(txs, max_gas)
-            .into_iter()
-            .take(transactions_limit as usize)
-            .collect();
+        let sorted_txs: Vec<_> =
+            select_transactions(txs, max_gas, block_transaction_size_limit)
+                .take(transactions_limit as usize)
+                .collect();
 
         for tx in sorted_txs.iter() {
             guard.remove_committed_tx(&tx.id());