feat(forge): loosen tx gas limit restrictions ahead of Osaka + make enforceable w/ --enable-tx-gas-limit (#11427)

Author: zerosnacks

crates/anvil/src/config.rs

@@ -98,6 +98,8 @@ pub struct NodeConfig {
     pub gas_limit: Option<u64>,
     /// If set to `true`, disables the block gas limit
     pub disable_block_gas_limit: bool,
+    /// If set to `true`, enables the tx gas limit as imposed by Osaka (EIP-7825)
+    pub enable_tx_gas_limit: bool,
     /// Default gas price for all txs
     pub gas_price: Option<u128>,
     /// Default base fee
@@ -443,6 +445,7 @@ impl Default for NodeConfig {
             chain_id: None,
             gas_limit: None,
             disable_block_gas_limit: false,
+            enable_tx_gas_limit: false,
             gas_price: None,
             hardfork: None,
             signer_accounts: genesis_accounts.clone(),
@@ -622,6 +625,15 @@ impl NodeConfig {
         self
     }
 
+    /// Enable tx gas limit check
+    ///
+    /// If set to `true`, enables the tx gas limit as imposed by Osaka (EIP-7825)
+    #[must_use]
+    pub fn enable_tx_gas_limit(mut self, enable_tx_gas_limit: bool) -> Self {
+        self.enable_tx_gas_limit = enable_tx_gas_limit;
+        self
+    }
+
     /// Sets the gas price
     #[must_use]
     pub fn with_gas_price(mut self, gas_price: Option<u128>) -> Self {
@@ -1068,6 +1080,10 @@ impl NodeConfig {
         cfg.disable_eip3607 = true;
         cfg.disable_block_gas_limit = self.disable_block_gas_limit;
 
+        if !self.enable_tx_gas_limit {
+            cfg.tx_gas_limit_cap = Some(u64::MAX);
+        }
+
         if let Some(value) = self.memory_limit {
             cfg.memory_limit = value;
         }

crates/anvil/src/eth/backend/executor.rs

@@ -40,7 +40,7 @@ use foundry_evm_core::{either_evm::EitherEvm, precompiles::EC_RECOVER};
 use op_revm::{L1BlockInfo, OpContext, precompiles::OpPrecompiles};
 use revm::{
     Database, DatabaseRef, Inspector, Journal,
-    context::{Block as RevmBlock, BlockEnv, CfgEnv, Evm as RevmEvm, JournalTr, LocalContext},
+    context::{Block as RevmBlock, BlockEnv, Cfg, CfgEnv, Evm as RevmEvm, JournalTr, LocalContext},
     context_interface::result::{EVMError, ExecutionResult, Output},
     database::WrapDatabaseRef,
     handler::{EthPrecompiles, instructions::EthInstructions},
@@ -174,14 +174,18 @@ impl<DB: Db + ?Sized, V: TransactionValidator> TransactionExecutor<'_, DB, V> {
                     included.push(tx.transaction.clone());
                     tx
                 }
-                TransactionExecutionOutcome::Exhausted(tx) => {
+                TransactionExecutionOutcome::BlockGasExhausted(tx) => {
                     trace!(target: "backend",  tx_gas_limit = %tx.pending_transaction.transaction.gas_limit(), ?tx,  "block gas limit exhausting, skipping transaction");
                     continue;
                 }
                 TransactionExecutionOutcome::BlobGasExhausted(tx) => {
                     trace!(target: "backend",  blob_gas = %tx.pending_transaction.transaction.blob_gas().unwrap_or_default(), ?tx,  "block blob gas limit exhausting, skipping transaction");
                     continue;
                 }
+                TransactionExecutionOutcome::TransactionGasExhausted(tx) => {
+                    trace!(target: "backend",  tx_gas_limit = %tx.pending_transaction.transaction.gas_limit(), ?tx,  "transaction gas limit exhausting, skipping transaction");
+                    continue;
+                }
                 TransactionExecutionOutcome::Invalid(tx, _) => {
                     trace!(target: "backend", ?tx,  "skipping invalid transaction");
                     invalid.push(tx);
@@ -285,10 +289,12 @@ pub enum TransactionExecutionOutcome {
     Executed(ExecutedTransaction),
     /// Invalid transaction not executed
     Invalid(Arc<PoolTransaction>, InvalidTransactionError),
-    /// Execution skipped because could exceed gas limit
-    Exhausted(Arc<PoolTransaction>),
+    /// Execution skipped because could exceed block gas limit
+    BlockGasExhausted(Arc<PoolTransaction>),
     /// Execution skipped because it exceeded the blob gas limit
     BlobGasExhausted(Arc<PoolTransaction>),
+    /// Execution skipped because it exceeded the transaction gas limit
+    TransactionGasExhausted(Arc<PoolTransaction>),
     /// When an error occurred during execution
     DatabaseError(Arc<PoolTransaction>, DatabaseError),
 }
@@ -306,10 +312,19 @@ impl<DB: Db + ?Sized, V: TransactionValidator> Iterator for &mut TransactionExec
         let env = self.env_for(&transaction.pending_transaction);
 
         // check that we comply with the block's gas limit, if not disabled
-        let max_gas = self.gas_used.saturating_add(env.tx.base.gas_limit);
-        if !env.evm_env.cfg_env.disable_block_gas_limit && max_gas > env.evm_env.block_env.gas_limit
+        let max_block_gas = self.gas_used.saturating_add(env.tx.base.gas_limit);
+        if !env.evm_env.cfg_env.disable_block_gas_limit
+            && max_block_gas > env.evm_env.block_env.gas_limit
+        {
+            return Some(TransactionExecutionOutcome::BlockGasExhausted(transaction));
+        }
+
+        // check that we comply with the transaction's gas limit as imposed by Osaka (EIP-7825)
+        if env.evm_env.cfg_env.tx_gas_limit_cap.is_none()
+            && transaction.pending_transaction.transaction.gas_limit()
+                > env.evm_env.cfg_env().tx_gas_limit_cap()
         {
-            return Some(TransactionExecutionOutcome::Exhausted(transaction));
+            return Some(TransactionExecutionOutcome::TransactionGasExhausted(transaction));
         }
 
         // check that we comply with the block's blob gas limit

crates/anvil/src/eth/backend/mem/mod.rs

@@ -108,7 +108,7 @@ use op_revm::{
 use parking_lot::{Mutex, RwLock};
 use revm::{
     DatabaseCommit, Inspector,
-    context::{Block as RevmBlock, BlockEnv, TxEnv},
+    context::{Block as RevmBlock, BlockEnv, Cfg, TxEnv},
     context_interface::{
         block::BlobExcessGasAndPrice,
         result::{ExecutionResult, Output, ResultAndState},
@@ -1534,6 +1534,7 @@ impl Backend {
     ///
     ///  - `disable_eip3607` is set to `true`
     ///  - `disable_base_fee` is set to `true`
+    ///  - `tx_gas_limit_cap` is set to `Some(u64::MAX)` indicating no gas limit cap
     ///  - `nonce` check is skipped if `request.nonce` is None
     fn build_call_env(
         &self,
@@ -1576,6 +1577,7 @@ impl Backend {
         // we want to disable this in eth_call, since this is common practice used by other node
         // impls and providers <https://github.com/foundry-rs/foundry/issues/4388>
         env.evm_env.cfg_env.disable_block_gas_limit = true;
+        env.evm_env.cfg_env.tx_gas_limit_cap = Some(u64::MAX);
 
         // The basefee should be ignored for calls against state for
         // - eth_call
@@ -3422,7 +3424,7 @@ impl TransactionValidator for Backend {
                 return Err(InvalidTransactionError::GasTooLow);
             }
 
-            // Check gas limit against block gas limit, if block gas limit is set.
+            // Check tx gas limit against block gas limit, if block gas limit is set.
             if !env.evm_env.cfg_env.disable_block_gas_limit
                 && tx.gas_limit() > env.evm_env.block_env.gas_limit
             {
@@ -3432,7 +3434,17 @@ impl TransactionValidator for Backend {
                 }));
             }
 
-            // EIP-1559 fee validation (London hard fork and later)
+            // Check tx gas limit against tx gas limit cap (Osaka hard fork and later).
+            if env.evm_env.cfg_env.tx_gas_limit_cap.is_none()
+                && tx.gas_limit() > env.evm_env.cfg_env().tx_gas_limit_cap()
+            {
+                warn!(target: "backend", "[{:?}] gas too high", tx.hash());
+                return Err(InvalidTransactionError::GasTooHigh(ErrDetail {
+                    detail: String::from("tx.gas_limit > env.cfg.tx_gas_limit_cap"),
+                }));
+            }
+
+            // EIP-1559 fee validation (London hard fork and later).
             if env.evm_env.cfg_env.spec >= SpecId::LONDON {
                 if tx.gas_price() < env.evm_env.block_env.basefee.into() && !is_deposit_tx {
                     warn!(target: "backend", "max fee per gas={}, too low, block basefee={}",tx.gas_price(),  env.evm_env.block_env.basefee);

crates/anvil/tests/it/transaction.rs

@@ -16,6 +16,7 @@ use alloy_sol_types::SolValue;
 use anvil::{NodeConfig, spawn};
 use eyre::Ok;
 use futures::{FutureExt, StreamExt, future::join_all};
+use revm::primitives::eip7825::TX_GAS_LIMIT_CAP;
 use std::{str::FromStr, time::Duration};
 use tokio::time::timeout;
 
@@ -1296,7 +1297,7 @@ async fn can_mine_multiple_in_block() {
 
 // ensures that the gas estimate is running on pending block by default
 #[tokio::test(flavor = "multi_thread")]
-async fn estimates_gas_prague() {
+async fn can_estimate_gas_prague() {
     let (api, _handle) =
         spawn(NodeConfig::test().with_hardfork(Some(EthereumHardfork::Prague.into()))).await;
 
@@ -1308,3 +1309,75 @@ async fn estimates_gas_prague() {
         .with_to(address!("0x70997970c51812dc3a010c7d01b50e0d17dc79c8"));
     api.estimate_gas(WithOtherFields::new(req), None, EvmOverrides::default()).await.unwrap();
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn can_send_tx_osaka_valid_with_limit_enabled() {
+    let (_api, handle) = spawn(
+        NodeConfig::test()
+            .enable_tx_gas_limit(true)
+            .with_hardfork(Some(EthereumHardfork::Osaka.into())),
+    )
+    .await;
+    let provider = handle.http_provider();
+    let wallet = handle.dev_wallets().next().unwrap();
+    let sender = wallet.address();
+    let recipient = Address::random();
+
+    let base_tx = TransactionRequest::default().from(sender).to(recipient).value(U256::from(1e18));
+
+    // gas limit below the cap is accepted
+    let tx = base_tx.clone().gas_limit(TX_GAS_LIMIT_CAP - 1);
+    let tx = WithOtherFields::new(tx);
+    let pending_tx = provider.send_transaction(tx).await.unwrap();
+    let tx_receipt = pending_tx.get_receipt().await.unwrap();
+    assert!(tx_receipt.inner.inner.is_success());
+
+    // gas limit at the cap is accepted
+    let tx = base_tx.clone().gas_limit(TX_GAS_LIMIT_CAP);
+    let tx = WithOtherFields::new(tx);
+    let pending_tx = provider.send_transaction(tx).await.unwrap();
+    let tx_receipt = pending_tx.get_receipt().await.unwrap();
+    assert!(tx_receipt.inner.inner.is_success());
+
+    // gas limit above the cap is rejected
+    let tx = base_tx.clone().gas_limit(TX_GAS_LIMIT_CAP + 1);
+    let tx = WithOtherFields::new(tx);
+    let err = provider.send_transaction(tx).await.unwrap_err().to_string();
+    assert!(
+        err.contains("intrinsic gas too high -- tx.gas_limit > env.cfg.tx_gas_limit_cap"),
+        "{err}"
+    );
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn can_send_tx_osaka_valid_with_limit_disabled() {
+    let (_api, handle) =
+        spawn(NodeConfig::test().with_hardfork(Some(EthereumHardfork::Osaka.into()))).await;
+    let provider = handle.http_provider();
+    let wallet = handle.dev_wallets().next().unwrap();
+    let sender = wallet.address();
+    let recipient = Address::random();
+
+    let base_tx = TransactionRequest::default().from(sender).to(recipient).value(U256::from(1e18));
+
+    // gas limit below the cap is accepted
+    let tx = base_tx.clone().gas_limit(TX_GAS_LIMIT_CAP - 1);
+    let tx = WithOtherFields::new(tx);
+    let pending_tx = provider.send_transaction(tx).await.unwrap();
+    let tx_receipt = pending_tx.get_receipt().await.unwrap();
+    assert!(tx_receipt.inner.inner.is_success());
+
+    // gas limit at the cap is accepted
+    let tx = base_tx.clone().gas_limit(TX_GAS_LIMIT_CAP);
+    let tx = WithOtherFields::new(tx);
+    let pending_tx = provider.send_transaction(tx).await.unwrap();
+    let tx_receipt = pending_tx.get_receipt().await.unwrap();
+    assert!(tx_receipt.inner.inner.is_success());
+
+    // gas limit above the cap is accepted when the limit is disabled
+    let tx = base_tx.clone().gas_limit(TX_GAS_LIMIT_CAP + 1);
+    let tx = WithOtherFields::new(tx);
+    let pending_tx = provider.send_transaction(tx).await.unwrap();
+    let tx_receipt = pending_tx.get_receipt().await.unwrap();
+    assert!(tx_receipt.inner.inner.is_success());
+}

crates/cast/src/cmd/call.rs

@@ -264,6 +264,7 @@ impl CallArgs {
 
             // modify settings that usually set in eth_call
             env.evm_env.cfg_env.disable_block_gas_limit = true;
+            env.evm_env.cfg_env.tx_gas_limit_cap = Some(u64::MAX);
             env.evm_env.block_env.gas_limit = u64::MAX;
 
             // Apply the block overrides.

crates/cast/src/cmd/run.rs

@@ -105,6 +105,10 @@ pub struct RunArgs {
     /// Disable block gas limit check.
     #[arg(long)]
     pub disable_block_gas_limit: bool,
+
+    /// Enable the tx gas limit checks as imposed by Osaka (EIP-7825).
+    #[arg(long)]
+    pub enable_tx_gas_limit: bool,
 }
 
 impl RunArgs {
@@ -162,6 +166,13 @@ impl RunArgs {
         let mut evm_version = self.evm_version;
 
         env.evm_env.cfg_env.disable_block_gas_limit = self.disable_block_gas_limit;
+
+        // By default do not enforce transaction gas limits imposed by Osaka (EIP-7825).
+        // Users can opt-in to enable these limits by setting `enable_tx_gas_limit` to true.
+        if !self.enable_tx_gas_limit {
+            env.evm_env.cfg_env.tx_gas_limit_cap = Some(u64::MAX);
+        }
+
         env.evm_env.cfg_env.limit_contract_code_size = None;
         env.evm_env.block_env.number = U256::from(tx_block_number);
 

crates/common/src/evm.rs

@@ -252,7 +252,7 @@ pub struct EnvArgs {
     pub block_prevrandao: Option<B256>,
 
     /// The block gas limit.
-    #[arg(long, visible_alias = "gas-limit", value_name = "GAS_LIMIT")]
+    #[arg(long, visible_aliases = &["block-gas-limit", "gas-limit"], value_name = "BLOCK_GAS_LIMIT")]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub block_gas_limit: Option<u64>,
 
@@ -265,9 +265,14 @@ pub struct EnvArgs {
     pub memory_limit: Option<u64>,
 
     /// Whether to disable the block gas limit checks.
-    #[arg(long, visible_alias = "no-gas-limit")]
+    #[arg(long, visible_aliases = &["no-block-gas-limit", "no-gas-limit"])]
     #[serde(skip_serializing_if = "std::ops::Not::not")]
     pub disable_block_gas_limit: bool,
+
+    /// Whether to enable tx gas limit checks as imposed by Osaka (EIP-7825).
+    #[arg(long, visible_alias = "tx-gas-limit")]
+    #[serde(skip_serializing_if = "std::ops::Not::not")]
+    pub enable_tx_gas_limit: bool,
 }
 
 impl EvmArgs {

crates/config/src/lib.rs

@@ -487,9 +487,12 @@ pub struct Config {
     /// Useful for more correct gas accounting and EVM behavior in general.
     pub isolate: bool,
 
-    /// Whether to disable the block gas limit.
+    /// Whether to disable the block gas limit checks.
     pub disable_block_gas_limit: bool,
 
+    /// Whether to enable the tx gas limit checks as imposed by Osaka (EIP-7825).
+    pub enable_tx_gas_limit: bool,
+
     /// Address labels
     pub labels: AddressHashMap<String>,
 
@@ -2382,6 +2385,7 @@ impl Default for Config {
             block_prevrandao: Default::default(),
             block_gas_limit: None,
             disable_block_gas_limit: false,
+            enable_tx_gas_limit: false,
             memory_limit: 1 << 27, // 2**27 = 128MiB = 134_217_728 bytes
             eth_rpc_url: None,
             eth_rpc_accept_invalid_certs: false,

crates/evm/core/src/fork/init.rs

@@ -9,6 +9,7 @@ use revm::context::{BlockEnv, CfgEnv, TxEnv};
 
 /// Initializes a REVM block environment based on a forked
 /// ethereum provider.
+#[allow(clippy::too_many_arguments)]
 pub async fn environment<N: Network, P: Provider<N>>(
     provider: &P,
     memory_limit: u64,
@@ -17,6 +18,7 @@ pub async fn environment<N: Network, P: Provider<N>>(
     pin_block: Option<u64>,
     origin: Address,
     disable_block_gas_limit: bool,
+    enable_tx_gas_limit: bool,
 ) -> eyre::Result<(Env, N::BlockResponse)> {
     let block_number = if let Some(pin_block) = pin_block {
         pin_block
@@ -50,6 +52,7 @@ pub async fn environment<N: Network, P: Provider<N>>(
         override_chain_id.unwrap_or(rpc_chain_id),
         memory_limit,
         disable_block_gas_limit,
+        enable_tx_gas_limit,
     );
 
     let mut env = Env {
@@ -81,7 +84,12 @@ pub async fn environment<N: Network, P: Provider<N>>(
 }
 
 /// Configures the environment for the given chain id and memory limit.
-pub fn configure_env(chain_id: u64, memory_limit: u64, disable_block_gas_limit: bool) -> CfgEnv {
+pub fn configure_env(
+    chain_id: u64,
+    memory_limit: u64,
+    disable_block_gas_limit: bool,
+    enable_tx_gas_limit: bool,
+) -> CfgEnv {
     let mut cfg = CfgEnv::default();
     cfg.chain_id = chain_id;
     cfg.memory_limit = memory_limit;
@@ -92,7 +100,10 @@ pub fn configure_env(chain_id: u64, memory_limit: u64, disable_block_gas_limit:
     cfg.disable_eip3607 = true;
     cfg.disable_block_gas_limit = disable_block_gas_limit;
     cfg.disable_nonce_check = true;
-    // For Osaka EIP-7825
-    cfg.tx_gas_limit_cap = Some(u64::MAX);
+    // By default do not enforce transaction gas limits imposed by Osaka (EIP-7825).
+    // Users can opt-in to enable these limits by setting `enable_tx_gas_limit` to true.
+    if !enable_tx_gas_limit {
+        cfg.tx_gas_limit_cap = Some(u64::MAX);
+    }
     cfg
 }