chore: bump revm 31 (#12461)

* chore: bump revm 31

* use transfer in Celo precompile, temp commit to clarify blockers

* access journaled_state directly to set storage of account

* fixes

* fixes

---------

Co-authored-by: zerosnacks <[email protected]>
Co-authored-by: Oliver Nordbjerg <[email protected]>

Author: 3 people

Cargo.lock

@@ -228,7 +228,7 @@ foundry-compilers = { version = "0.19.5", default-features = false, features = [
     "rustls",
     "svm-solc",
 ] }
-foundry-fork-db = "0.19"
+foundry-fork-db = "0.20"
 solang-parser = { version = "=0.3.9", package = "foundry-solang-parser" }
 solar = { package = "solar-compiler", version = "=0.1.8", default-features = false }
 svm = { package = "svm-rs", version = "0.5", default-features = false, features = [
@@ -281,17 +281,17 @@ alloy-rlp = "0.3"
 alloy-trie = "0.9"
 
 ## op-alloy
-op-alloy-consensus = "0.20.0"
-op-alloy-rpc-types = "0.20.0"
+op-alloy-consensus = "0.22.0"
+op-alloy-rpc-types = "0.22.0"
 op-alloy-flz = "0.13.1"
 
 ## revm
-revm = { version = "30.2.0", default-features = false }
-revm-inspectors = { version = "0.31.2", features = ["serde"] }
-op-revm = { version = "11.1.2", default-features = false }
+revm = { version = "31.0.0", default-features = false }
+revm-inspectors = { version = "0.32.0", features = ["serde"] }
+op-revm = { version = "12.0.0", default-features = false }
 ## alloy-evm
-alloy-evm = "0.22.3"
-alloy-op-evm = "0.22.3"
+alloy-evm = "0.23.1"
+alloy-op-evm = "0.23.1"
 
 ## cli
 anstream = "0.6"

Cargo.toml

@@ -165,6 +165,7 @@ where
                 OpTransactionError::HaltedDepositPostRegolith => {
                     Self::DepositTransactionUnsupported
                 }
+                OpTransactionError::MissingEnvelopedTx => Self::InvalidTransaction(err.into()),
             },
             EVMError::Header(err) => match err {
                 InvalidHeader::ExcessBlobGasNotSet => Self::ExcessBlobGasNotSet,
@@ -320,6 +321,9 @@ pub enum InvalidTransactionError {
     /// Deposit transaction error post regolith
     #[error("op-deposit failure post regolith")]
     DepositTxErrorPostRegolith,
+    /// Missing enveloped transaction
+    #[error("missing enveloped transaction")]
+    MissingEnvelopedTx,
 }
 
 impl From<InvalidTransaction> for InvalidTransactionError {
@@ -384,6 +388,7 @@ impl From<OpTransactionError> for InvalidTransactionError {
             OpTransactionError::Base(err) => err.into(),
             OpTransactionError::DepositSystemTxPostRegolith
             | OpTransactionError::HaltedDepositPostRegolith => Self::DepositTxErrorPostRegolith,
+            OpTransactionError::MissingEnvelopedTx => Self::MissingEnvelopedTx,
         }
     }
 }

crates/anvil/src/eth/error.rs

@@ -62,7 +62,6 @@ use revm::{
         interpreter_types::{Jumps, LoopControl, MemoryTr},
     },
     primitives::hardfork::SpecId,
-    state::EvmStorageSlot,
 };
 use serde_json::Value;
 use std::{
@@ -317,8 +316,10 @@ impl ArbitraryStorage {
     /// - update account's storage with given value.
     pub fn save(&mut self, ecx: Ecx, address: Address, slot: U256, data: U256) {
         self.values.get_mut(&address).expect("missing arbitrary address entry").insert(slot, data);
-        if let Ok(mut account) = ecx.journaled_state.load_account(address) {
-            account.storage.insert(slot, EvmStorageSlot::new(data, 0));
+        if ecx.journaled_state.load_account(address).is_ok() {
+            ecx.journaled_state
+                .sstore(address, slot, data)
+                .expect("could not set arbitrary storage value");
         }
     }
 
@@ -335,15 +336,17 @@ impl ArbitraryStorage {
             None => {
                 storage_cache.insert(slot, new_value);
                 // Update source storage with new value.
-                if let Ok(mut source_account) = ecx.journaled_state.load_account(*source) {
-                    source_account.storage.insert(slot, EvmStorageSlot::new(new_value, 0));
+                if ecx.journaled_state.load_account(*source).is_ok() {
+                    ecx.journaled_state
+                        .sstore(*source, slot, new_value)
+                        .expect("could not copy arbitrary storage value");
                 }
                 new_value
             }
         };
         // Update target storage with new value.
-        if let Ok(mut target_account) = ecx.journaled_state.load_account(target) {
-            target_account.storage.insert(slot, EvmStorageSlot::new(value, 0));
+        if ecx.journaled_state.load_account(target).is_ok() {
+            ecx.journaled_state.sstore(target, slot, value).expect("could not set storage");
         }
         value
     }

crates/cheatcodes/src/inspector.rs

@@ -260,8 +260,9 @@ impl Cheatcode for copyStorageCall {
 
         if let Ok(from_account) = ccx.ecx.journaled_state.load_account(*from) {
             let from_storage = from_account.storage.clone();
-            if let Ok(mut to_account) = ccx.ecx.journaled_state.load_account(*to) {
-                to_account.storage = from_storage;
+            if ccx.ecx.journaled_state.load_account(*to).is_ok() {
+                // SAFETY: We ensured the account was already loaded.
+                ccx.ecx.journaled_state.state.get_mut(to).unwrap().storage = from_storage;
                 if let Some(arbitrary_storage) = &mut ccx.state.arbitrary_storage {
                     arbitrary_storage.mark_copy(from, to);
                 }

crates/cheatcodes/src/utils.rs

@@ -1423,39 +1423,37 @@ impl DatabaseExt for Backend {
     ) -> Result<(), BackendError> {
         // Fetch the account from the journaled state. Will create a new account if it does
         // not already exist.
-        let mut state_acc = journaled_state.load_account(self, *target)?;
+        let mut state_acc = journaled_state.load_account_mut(self, *target)?;
 
         // Set the account's bytecode and code hash, if the `bytecode` field is present.
         if let Some(bytecode) = source.code.as_ref() {
-            state_acc.info.code_hash = keccak256(bytecode);
+            let bytecode_hash = keccak256(bytecode);
             let bytecode = Bytecode::new_raw(bytecode.0.clone().into());
-            state_acc.info.code = Some(bytecode);
+            state_acc.set_code(bytecode_hash, bytecode);
         }
 
+        // Set the account's balance.
+        state_acc.set_balance(source.balance);
+
         // Set the account's storage, if the `storage` field is present.
-        if let Some(storage) = source.storage.as_ref() {
-            state_acc.storage = storage
-                .iter()
-                .map(|(slot, value)| {
+        if let Some(acc) = journaled_state.state.get_mut(target) {
+            if let Some(storage) = source.storage.as_ref() {
+                for (slot, value) in storage {
                     let slot = U256::from_be_bytes(slot.0);
-                    (
+                    acc.storage.insert(
                         slot,
                         EvmStorageSlot::new_changed(
-                            state_acc
-                                .storage
-                                .get(&slot)
-                                .map(|s| s.present_value)
-                                .unwrap_or_default(),
+                            acc.storage.get(&slot).map(|s| s.present_value).unwrap_or_default(),
                             U256::from_be_bytes(value.0),
                             0,
                         ),
-                    )
-                })
-                .collect();
-        }
-        // Set the account's nonce and balance.
-        state_acc.info.nonce = source.nonce.unwrap_or_default();
-        state_acc.info.balance = source.balance;
+                    );
+                }
+            }
+
+            // Set the account's nonce.
+            acc.info.nonce = source.nonce.unwrap_or_default();
+        };
 
         // Touch the account to ensure the loaded information persists if called in `setUp`.
         journaled_state.touch(*target);

crates/evm/core/src/backend/mod.rs

@@ -8,7 +8,6 @@ use crate::Env;
 use alloy_consensus::BlockHeader;
 use alloy_primitives::{U256, map::HashMap};
 use alloy_provider::network::BlockResponse;
-use foundry_common::provider::RetryProvider;
 use foundry_config::Config;
 use foundry_fork_db::{BackendHandler, BlockchainDb, SharedBackend, cache::BlockchainDbMeta};
 use futures::{
@@ -202,8 +201,7 @@ impl MultiFork {
     }
 }
 
-type Handler = BackendHandler<RetryProvider>;
-
+type Handler = BackendHandler;
 type CreateFuture =
     Pin<Box<dyn Future<Output = eyre::Result<(ForkId, CreatedFork, Handler)>> + Send>>;
 type CreateSender = OneshotSender<eyre::Result<(ForkId, SharedBackend, Env)>>;

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

@@ -38,7 +38,7 @@ pub fn precompile() -> DynPrecompile {
 /// Celo transfer precompile implementation.
 ///
 /// Uses load_account to modify balances directly, making it compatible with PrecompilesMap.
-pub fn celo_transfer_precompile(input: PrecompileInput<'_>) -> PrecompileResult {
+pub fn celo_transfer_precompile(mut input: PrecompileInput<'_>) -> PrecompileResult {
     // Check minimum gas requirement
     if input.gas < CELO_TRANSFER_GAS_COST {
         return Err(PrecompileError::OutOfGas);
@@ -62,44 +62,39 @@ pub fn celo_transfer_precompile(input: PrecompileInput<'_>) -> PrecompileResult
     let value = U256::from_be_slice(value_bytes);
 
     // Perform the transfer using load_account to modify balances directly
-    let mut internals = input.internals;
+    let internals = input.internals_mut();
 
     // Load and check the from account balance first
-    {
-        let from_account = match internals.load_account(from_address) {
-            Ok(account) => account,
-            Err(e) => {
-                return Err(PrecompileError::Other(format!("Failed to load from account: {e:?}")));
-            }
-        };
-
-        // Check if from account has sufficient balance
-        if from_account.data.info.balance < value {
-            return Err(PrecompileError::Other("Insufficient balance".into()));
+
+    let from_account = match internals.load_account(from_address) {
+        Ok(account) => account,
+        Err(e) => {
+            return Err(PrecompileError::Other(format!("Failed to load from account: {e:?}")));
         }
+    };
 
-        // Deduct balance from the from account
-        from_account.data.info.balance -= value;
+    // Check if from account has sufficient balance
+    if from_account.data.info.balance < value {
+        return Err(PrecompileError::Other("Insufficient balance".into()));
     }
 
-    // Load and update the to account
-    {
-        let to_account = match internals.load_account(to_address) {
-            Ok(account) => account,
-            Err(e) => {
-                return Err(PrecompileError::Other(format!("Failed to load to account: {e:?}")));
-            }
-        };
-
-        // Check for overflow in to account
-        if to_account.data.info.balance.checked_add(value).is_none() {
-            return Err(PrecompileError::Other("Balance overflow in to account".into()));
+    let to_account = match internals.load_account(to_address) {
+        Ok(account) => account,
+        Err(e) => {
+            return Err(PrecompileError::Other(format!("Failed to load to account: {e:?}")));
         }
+    };
 
-        // Add balance to the to account
-        to_account.data.info.balance += value;
+    // Check for overflow in to account
+    if to_account.data.info.balance.checked_add(value).is_none() {
+        return Err(PrecompileError::Other("Balance overflow in to account".into()));
     }
 
+    // Transfer the value between accounts
+    internals
+        .transfer(from_address, to_address, value)
+        .map_err(|e| PrecompileError::Other(format!("Failed to perform transfer: {e:?}")))?;
+
     // No output data for successful transfer
     Ok(PrecompileOutput::new(CELO_TRANSFER_GAS_COST, alloy_primitives::Bytes::new()))
 }