Add verification on transaction dry_run that they don't spend more than block gas limit

CHANGELOG.md

@@ -8,7 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 - [2135](https://github.com/FuelLabs/fuel-core/pull/2135): Added metrics logging for number of blocks served over the p2p req/res protocol.
-
+- [2151](https://github.com/FuelLabs/fuel-core/pull/2151): Added limitations on gas used during dry_run in API.
 
 ## [Version 0.35.0]
 

crates/fuel-core/src/schema/tx.rs

@@ -49,6 +49,7 @@ use fuel_core_txpool::{
 use fuel_core_types::{
     fuel_tx::{
         Cacheable,
+        Chargeable,
         Transaction as FuelTx,
         UniqueIdentifier,
     },
@@ -276,16 +277,48 @@ impl TxMutation {
         gas_price: Option<U64>,
     ) -> async_graphql::Result<Vec<DryRunTransactionExecutionStatus>> {
         let block_producer = ctx.data_unchecked::<BlockProducer>();
-        let params = ctx
+        let consensus_params = ctx
             .data_unchecked::<ConsensusProvider>()
             .latest_consensus_params();
+        let block_gas_limit = consensus_params.block_gas_limit();
 
+        let mut max_gas_usable: u64 = 0;
         let mut transactions = txs
             .iter()
             .map(|tx| FuelTx::from_bytes(&tx.0))
             .collect::<Result<Vec<FuelTx>, _>>()?;
+        let fee = consensus_params.fee_params();
         for transaction in &mut transactions {
-            transaction.precompute(&params.chain_id())?;
+            match transaction {
+                FuelTx::Script(tx) => {
+                    max_gas_usable = max_gas_usable
+                        .saturating_add(tx.max_gas(consensus_params.gas_costs(), fee));
+                }
+                FuelTx::Create(tx) => {
+                    max_gas_usable = max_gas_usable
+                        .saturating_add(tx.max_gas(consensus_params.gas_costs(), fee));
+                }
+                FuelTx::Mint(_) => {
+                    // Mint transactions doesn't consume gas and so we will add a flat 10% of the block gas limit
+                    max_gas_usable = max_gas_usable.saturating_add(block_gas_limit / 10);
+                }
+                FuelTx::Upgrade(tx) => {
+                    max_gas_usable = max_gas_usable
+                        .saturating_add(tx.max_gas(consensus_params.gas_costs(), fee));
+                }
+                FuelTx::Upload(tx) => {
+                    max_gas_usable = max_gas_usable
+                        .saturating_add(tx.max_gas(consensus_params.gas_costs(), fee));
+                }
+                FuelTx::Blob(tx) => {
+                    max_gas_usable = max_gas_usable
+                        .saturating_add(tx.max_gas(consensus_params.gas_costs(), fee));
+                }
+            };
+            if max_gas_usable > block_gas_limit {
+                return Err(anyhow::anyhow!("The sum of the gas usable by the transactions is greater than the block gas limit").into());
+            }
+            transaction.precompute(&consensus_params.chain_id())?;
         }
 
         let tx_statuses = block_producer

crates/services/producer/src/block_producer.rs

@@ -280,6 +280,7 @@ where
         gas_price: Option<u64>,
     ) -> anyhow::Result<Vec<TransactionExecutionStatus>> {
         let view = self.view_provider.latest_view()?;
+
         let height = height.unwrap_or_else(|| {
             view.latest_height()
                 .unwrap_or_default()

tests/tests/tx.rs

@@ -145,6 +145,44 @@ async fn dry_run_create() {
     assert_eq!(err.kind(), NotFound);
 }
 
+#[tokio::test]
+async fn dry_run_above_block_gas_limit() {
+    let config = Config::local_node();
+    let srv = FuelService::new_node(config).await.unwrap();
+    let client = FuelClient::from(srv.bound_address);
+
+    // Given
+    let gas_limit = client
+        .consensus_parameters(0)
+        .await
+        .unwrap()
+        .unwrap()
+        .block_gas_limit();
+    let maturity = Default::default();
+
+    let script = [
+        op::addi(0x10, RegId::ZERO, 0xca),
+        op::addi(0x11, RegId::ZERO, 0xba),
+        op::log(0x10, 0x11, RegId::ZERO, RegId::ZERO),
+        op::ret(RegId::ONE),
+    ];
+    let script: Vec<u8> = script
+        .iter()
+        .flat_map(|op| u32::from(*op).to_be_bytes())
+        .collect();
+
+    let tx = TransactionBuilder::script(script, vec![])
+        .script_gas_limit(gas_limit)
+        .maturity(maturity)
+        .add_random_fee_input()
+        .finalize_as_transaction();
+
+    // When
+    client.dry_run(&[tx.clone()]).await
+    // Then
+    .expect_err("Dry run should return an error because transaction is using too much gas");
+}
+
 #[tokio::test]
 async fn submit() {
     let srv = FuelService::new_node(Config::local_node()).await.unwrap();