chore: Upstream a8dc5ae merge (#1159)

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

* fix(anvil): traces' colors (#11614)

* Fix CRLF line ending handling in stdin utilities (#11606)

Update stdin.rs

* chore: update bitflags dependency in Cargo.lock

* chore(sol_macro_gen): remove unlinked bytecode workaround (#11613)

* chore: proper ws (#11621)

* chore(lint): re-use project output (#11563)

* chore(lint): re-use project output

* patch

* upd

* fix: lower

* update, bless, fix tests to compile with solc

* pragma

* blessings

* j1

* bump

* bless

* bless

* hide

* fix: inline config path (#11626)

* chore: use Cursor::with_position (#11627)

* fix(common): incorrect error message in get_error (#11631)

* feat(`anvil`): add `eth_config` rpc endpoint (#11591)

* fix(cheatcodes): lock files on reads / writes (#11590)

* fix(cheatcodes): ensure file sync on vm.writeFile

* Consolidate common fs

* chore: update upstream version metadata to track a8dc5ae merge

* fix: add missing solar dependencies after upstream merge

* fix: resolve build.rs syntax errors and duplicate code paths from merge

* Fix version of upstream version

* fix unreachable patterns

---------

Co-authored-by: zerosnacks <[email protected]>
Co-authored-by: 0xferrous <[email protected]>
Co-authored-by: sashaodessa <[email protected]>
Co-authored-by: Mablr <[email protected]>
Co-authored-by: grandizzy <[email protected]>
Co-authored-by: DaniPopes <[email protected]>
Co-authored-by: Snezhkko <[email protected]>

Author: 8 people

.gitignore

@@ -11,4 +11,11 @@ CLAUDE.md
 node_modules
 dist
 bin
-_
+_
+*.tgz
+.zed
+.vercel
+.vite
+.wrangler
+build
+*.zip

Cargo.toml

@@ -37,7 +37,7 @@ metadata.upstream_version = "1.3.5"
 version = "0.0.28" # x-release-please-version
 edition = "2024"
 # Remember to update clippy.toml as well
-rust-version = "1.88"
+rust-version = "1.89"
 authors = ["Foundry Contributors"]
 license = "MIT OR Apache-2.0"
 homepage = "https://getfoundry.sh"
@@ -221,12 +221,11 @@ foundry-block-explorers = { version = "0.22.0", default-features = false }
 foundry-compilers = { version = "0.19.1", default-features = false }
 foundry-fork-db = "0.18"
 solang-parser = { version = "=0.3.9", package = "foundry-solang-parser" }
-solar = { package = "solar-compiler", version = "=0.1.6", default-features = false }
-# TODO: remove in next solar release: https://github.com/paradigmxyz/solar/pull/444
-solar-data-structures = { version = "=0.1.6", default-features = false }
-solar-interface = { version = "=0.1.6", default-features = false }
-solar-parse = { version = "=0.1.6", default-features = false }
-solar-sema = { version = "=0.1.6", default-features = false }
+solar = { package = "solar-compiler", version = "=0.1.7", default-features = false }
+solar-data-structures = { version = "=0.1.7", default-features = false }
+solar-interface = { version = "=0.1.7", default-features = false }
+solar-parse = { version = "=0.1.7", default-features = false }
+solar-sema = { version = "=0.1.7", default-features = false }
 
 ## alloy
 alloy-consensus = { version = "1.0.23", default-features = false }

clippy.toml

@@ -1,4 +1,4 @@
-msrv = "1.88"
+msrv = "1.89"
 
 # `bytes::Bytes` is included by default and `alloy_primitives::Bytes` is a wrapper around it,
 # so it is safe to ignore it as well.

crates/anvil/core/src/eth/mod.rs

@@ -264,6 +264,9 @@ pub enum EthRequest {
     #[serde(rename = "eth_syncing", with = "empty_params")]
     EthSyncing(()),
 
+    #[serde(rename = "eth_config", with = "empty_params")]
+    EthConfig(()),
+
     /// geth's `debug_getRawTransaction`  endpoint
     #[serde(rename = "debug_getRawTransaction", with = "sequence")]
     DebugGetRawTransaction(TxHash),

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/api.rs

@@ -34,7 +34,10 @@ use alloy_consensus::{
     transaction::{Recovered, eip4844::TxEip4844Variant},
 };
 use alloy_dyn_abi::TypedData;
-use alloy_eips::eip2718::Encodable2718;
+use alloy_eips::{
+    eip2718::Encodable2718,
+    eip7910::{EthConfig, EthForkConfig},
+};
 use alloy_evm::overrides::{OverrideBlockHashes, apply_state_overrides};
 use alloy_network::{
     AnyRpcBlock, AnyRpcTransaction, BlockResponse, Ethereum, NetworkWallet, TransactionBuilder,
@@ -313,6 +316,7 @@ impl EthApi {
             EthRequest::EthGetLogs(filter) => self.logs(filter).await.to_rpc_result(),
             EthRequest::EthGetWork(_) => self.work().to_rpc_result(),
             EthRequest::EthSyncing(_) => self.syncing().to_rpc_result(),
+            EthRequest::EthConfig(_) => self.config().to_rpc_result(),
             EthRequest::EthSubmitWork(nonce, pow, digest) => {
                 self.submit_work(nonce, pow, digest).to_rpc_result()
             }
@@ -1472,6 +1476,32 @@ impl EthApi {
         Ok(false)
     }
 
+    /// Returns the current configuration of the chain.
+    /// This is useful for finding out what precompiles and system contracts are available.
+    ///
+    /// Note: the activation timestamp is always 0 as the configuration is set at genesis.
+    /// Note: the `fork_id` is always `0x00000000` as this node does not participate in any forking
+    /// on the network.
+    /// Note: the `next` and `last` fields are always `null` as this node does not participate in
+    /// any forking on the network.
+    ///
+    /// Handler for ETH RPC call: `eth_config`
+    pub fn config(&self) -> Result<EthConfig> {
+        node_info!("eth_config");
+        Ok(EthConfig {
+            current: EthForkConfig {
+                activation_time: 0,
+                blob_schedule: self.backend.blob_params(),
+                chain_id: self.backend.env().read().evm_env.cfg_env.chain_id,
+                fork_id: Bytes::from_static(&[0; 4]),
+                precompiles: self.backend.precompiles(),
+                system_contracts: self.backend.system_contracts(),
+            },
+            next: None,
+            last: None,
+        })
+    }
+
     /// Used for submitting a proof-of-work solution.
     ///
     /// Handler for ETH RPC call: `eth_submitWork`

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/inspector.rs

@@ -112,8 +112,8 @@ fn print_traces(tracer: TracingInspector, decoder: Arc<CallTraceDecoder>) {
     });
 
     let traces = SparsedTraceArena { arena, ignored: Default::default() };
-    node_info!("Traces:");
-    node_info!("{}", render_trace_arena_inner(&traces, false, true));
+    let trace = render_trace_arena_inner(&traces, false, true);
+    node_info!(Traces = %format!("\n{}", trace));
 }
 
 impl<CTX> Inspector<CTX, EthInterpreter> for AnvilInspector

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

@@ -27,7 +27,7 @@ use crate::{
         pool::transactions::PoolTransaction,
         sign::build_typed_transaction,
     },
-    evm::celo_precompile,
+    evm::celo_precompile::{self, CELO_TRANSFER_ADDRESS},
     inject_precompiles,
     mem::{
         inspector::AnvilInspector,
@@ -41,7 +41,10 @@ use alloy_consensus::{
     proofs::{calculate_receipt_root, calculate_transaction_root},
     transaction::Recovered,
 };
-use alloy_eips::{eip1559::BaseFeeParams, eip4844::kzg_to_versioned_hash, eip7840::BlobParams};
+use alloy_eips::{
+    eip1559::BaseFeeParams, eip4844::kzg_to_versioned_hash, eip7840::BlobParams,
+    eip7910::SystemContract,
+};
 use alloy_evm::{
     Database, Evm,
     eth::EthEvmContext,
@@ -108,14 +111,18 @@ 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},
     },
     database::{CacheDB, WrapDatabaseRef},
     interpreter::InstructionResult,
-    precompile::secp256r1::{P256VERIFY, P256VERIFY_BASE_GAS_FEE},
+    precompile::{
+        PrecompileId, PrecompileSpecId, Precompiles,
+        secp256r1::{P256VERIFY, P256VERIFY_ADDRESS, P256VERIFY_BASE_GAS_FEE},
+        u64_to_address,
+    },
     primitives::{KECCAK_EMPTY, hardfork::SpecId},
     state::AccountInfo,
 };
@@ -843,6 +850,56 @@ impl Backend {
         self.env.read().is_celo
     }
 
+    /// Returns the precompiles for the current spec.
+    pub fn precompiles(&self) -> BTreeMap<String, Address> {
+        let spec_id = self.env.read().evm_env.cfg_env.spec;
+        let precompiles = Precompiles::new(PrecompileSpecId::from_spec_id(spec_id));
+
+        let mut precompiles_map = BTreeMap::<String, Address>::default();
+        for (address, precompile) in precompiles.inner() {
+            precompiles_map.insert(precompile.id().name().to_string(), *address);
+        }
+
+        if self.odyssey {
+            precompiles_map.insert(
+                PrecompileId::P256Verify.name().to_string(),
+                u64_to_address(P256VERIFY_ADDRESS),
+            );
+        }
+
+        if self.is_celo() {
+            precompiles_map.insert(
+                celo_precompile::PRECOMPILE_ID_CELO_TRANSFER.clone().name().to_string(),
+                CELO_TRANSFER_ADDRESS,
+            );
+        }
+
+        if let Some(factory) = &self.precompile_factory {
+            for (precompile, _) in &factory.precompiles() {
+                precompiles_map.insert(precompile.id().name().to_string(), *precompile.address());
+            }
+        }
+
+        precompiles_map
+    }
+
+    /// Returns the system contracts for the current spec.
+    pub fn system_contracts(&self) -> BTreeMap<SystemContract, Address> {
+        let mut system_contracts = BTreeMap::<SystemContract, Address>::default();
+
+        let spec_id = self.env.read().evm_env.cfg_env.spec;
+
+        if spec_id >= SpecId::CANCUN {
+            system_contracts.extend(SystemContract::cancun());
+        }
+
+        if spec_id >= SpecId::PRAGUE {
+            system_contracts.extend(SystemContract::prague(None));
+        }
+
+        system_contracts
+    }
+
     /// Returns [`BlobParams`] corresponding to the current spec.
     pub fn blob_params(&self) -> BlobParams {
         let spec_id = self.env.read().evm_env.cfg_env.spec;
@@ -1534,6 +1591,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 +1634,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 +3481,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 +3491,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);