chore: bump revm

Cargo.toml

@@ -211,3 +211,6 @@ alloy-dyn-abi = { git = "https://github.com/alloy-rs/core/" }
 alloy-primitives = { git = "https://github.com/alloy-rs/core/" }
 alloy-json-abi = { git = "https://github.com/alloy-rs/core/" }
 alloy-sol-types = { git = "https://github.com/alloy-rs/core/" }
+
+revm = { git = "https://github.com/bluealloy/revm", rev = "1609e07c68048909ad1682c98cf2b9baa76310b5" }
+revm-primitives = { git = "https://github.com/bluealloy/revm", rev = "1609e07c68048909ad1682c98cf2b9baa76310b5" }

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

@@ -136,7 +136,7 @@ pub trait Db:
     /// Deserialize and add all chain data to the backend storage
     fn load_state(&mut self, state: SerializableState) -> DatabaseResult<bool> {
         for (addr, account) in state.accounts.into_iter() {
-            let old_account_nonce = DatabaseRef::basic(self, addr.to_alloy())
+            let old_account_nonce = DatabaseRef::basic_ref(self, addr.to_alloy())
                 .ok()
                 .and_then(|acc| acc.map(|acc| acc.nonce))
                 .unwrap_or_default();
@@ -288,20 +288,20 @@ impl StateDb {
 
 impl DatabaseRef for StateDb {
     type Error = DatabaseError;
-    fn basic(&self, address: B160) -> DatabaseResult<Option<AccountInfo>> {
-        self.0.basic(address)
+    fn basic_ref(&self, address: B160) -> DatabaseResult<Option<AccountInfo>> {
+        self.0.basic_ref(address)
     }
 
-    fn code_by_hash(&self, code_hash: B256) -> DatabaseResult<Bytecode> {
-        self.0.code_by_hash(code_hash)
+    fn code_by_hash_ref(&self, code_hash: B256) -> DatabaseResult<Bytecode> {
+        self.0.code_by_hash_ref(code_hash)
     }
 
-    fn storage(&self, address: B160, index: rU256) -> DatabaseResult<rU256> {
-        self.0.storage(address, index)
+    fn storage_ref(&self, address: B160, index: rU256) -> DatabaseResult<rU256> {
+        self.0.storage_ref(address, index)
     }
 
-    fn block_hash(&self, number: rU256) -> DatabaseResult<B256> {
-        self.0.block_hash(number)
+    fn block_hash_ref(&self, number: rU256) -> DatabaseResult<B256> {
+        self.0.block_hash_ref(number)
     }
 }
 

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

@@ -103,21 +103,21 @@ pub(crate) struct AtGenesisStateDb<'a> {
 
 impl<'a> DatabaseRef for AtGenesisStateDb<'a> {
     type Error = DatabaseError;
-    fn basic(&self, address: aAddress) -> DatabaseResult<Option<AccountInfo>> {
+    fn basic_ref(&self, address: aAddress) -> DatabaseResult<Option<AccountInfo>> {
         if let Some(acc) = self.accounts.get(&(address.to_ethers())).cloned() {
             return Ok(Some(acc))
         }
-        self.db.basic(address)
+        self.db.basic_ref(address)
     }
 
-    fn code_by_hash(&self, code_hash: B256) -> DatabaseResult<Bytecode> {
+    fn code_by_hash_ref(&self, code_hash: B256) -> DatabaseResult<Bytecode> {
         if let Some((_, acc)) = self.accounts.iter().find(|(_, acc)| acc.code_hash == code_hash) {
             return Ok(acc.code.clone().unwrap_or_default())
         }
-        self.db.code_by_hash(code_hash)
+        self.db.code_by_hash_ref(code_hash)
     }
 
-    fn storage(&self, address: aAddress, index: U256) -> DatabaseResult<U256> {
+    fn storage_ref(&self, address: aAddress, index: U256) -> DatabaseResult<U256> {
         if let Some(acc) = self
             .genesis
             .as_ref()
@@ -130,11 +130,11 @@ impl<'a> DatabaseRef for AtGenesisStateDb<'a> {
                 .unwrap_or_default();
             return Ok(value.into_uint().to_alloy())
         }
-        self.db.storage(address, index)
+        self.db.storage_ref(address, index)
     }
 
-    fn block_hash(&self, number: U256) -> DatabaseResult<B256> {
-        self.db.block_hash(number)
+    fn block_hash_ref(&self, number: U256) -> DatabaseResult<B256> {
+        self.db.block_hash_ref(number)
     }
 }
 

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

@@ -42,7 +42,7 @@ impl Db for MemDb {
                 let code = if let Some(code) = v.info.code {
                     code
                 } else {
-                    self.inner.code_by_hash(v.info.code_hash)?
+                    self.inner.code_by_hash_ref(v.info.code_hash)?
                 }
                 .to_checked();
                 Ok((
@@ -177,13 +177,13 @@ mod tests {
 
         load_db.load_state(state).unwrap();
 
-        let loaded_account = load_db.basic(test_addr.to_alloy()).unwrap().unwrap();
+        let loaded_account = load_db.basic_ref(test_addr.to_alloy()).unwrap().unwrap();
 
         assert_eq!(loaded_account.balance, rU256::from(123456));
-        assert_eq!(load_db.code_by_hash(loaded_account.code_hash).unwrap(), contract_code);
+        assert_eq!(load_db.code_by_hash_ref(loaded_account.code_hash).unwrap(), contract_code);
         assert_eq!(loaded_account.nonce, 1234);
         assert_eq!(
-            load_db.storage(test_addr.to_alloy(), rU256::from(1234567)).unwrap(),
+            load_db.storage_ref(test_addr.to_alloy(), rU256::from(1234567)).unwrap(),
             rU256::from(1)
         );
     }
@@ -241,15 +241,21 @@ mod tests {
 
         db.load_state(new_state).unwrap();
 
-        let loaded_account = db.basic(test_addr.to_alloy()).unwrap().unwrap();
-        let loaded_account2 = db.basic(test_addr2.to_alloy()).unwrap().unwrap();
+        let loaded_account = db.basic_ref(test_addr.to_alloy()).unwrap().unwrap();
+        let loaded_account2 = db.basic_ref(test_addr2.to_alloy()).unwrap().unwrap();
 
         assert_eq!(loaded_account2.nonce, 1);
 
         assert_eq!(loaded_account.balance, rU256::from(100100));
-        assert_eq!(db.code_by_hash(loaded_account.code_hash).unwrap(), contract_code);
+        assert_eq!(db.code_by_hash_ref(loaded_account.code_hash).unwrap(), contract_code);
         assert_eq!(loaded_account.nonce, 1234);
-        assert_eq!(db.storage(test_addr.to_alloy(), rU256::from(1234567)).unwrap(), rU256::from(1));
-        assert_eq!(db.storage(test_addr.to_alloy(), rU256::from(1234568)).unwrap(), rU256::from(5));
+        assert_eq!(
+            db.storage_ref(test_addr.to_alloy(), rU256::from(1234567)).unwrap(),
+            rU256::from(1)
+        );
+        assert_eq!(
+            db.storage_ref(test_addr.to_alloy(), rU256::from(1234568)).unwrap(),
+            rU256::from(5)
+        );
     }
 }

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

@@ -48,23 +48,17 @@ impl Inspector {
 
 impl<DB: Database> revm::Inspector<DB> for Inspector {
     #[inline]
-    fn initialize_interp(
-        &mut self,
-        interp: &mut Interpreter,
-        data: &mut EVMData<'_, DB>,
-    ) -> InstructionResult {
+    fn initialize_interp(&mut self, interp: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>) {
         call_inspectors!([&mut self.tracer], |inspector| {
             inspector.initialize_interp(interp, data);
         });
-        InstructionResult::Continue
     }
 
     #[inline]
-    fn step(&mut self, interp: &mut Interpreter, data: &mut EVMData<'_, DB>) -> InstructionResult {
+    fn step(&mut self, interp: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>) {
         call_inspectors!([&mut self.tracer], |inspector| {
             inspector.step(interp, data);
         });
-        InstructionResult::Continue
     }
 
     #[inline]
@@ -81,16 +75,10 @@ impl<DB: Database> revm::Inspector<DB> for Inspector {
     }
 
     #[inline]
-    fn step_end(
-        &mut self,
-        interp: &mut Interpreter,
-        data: &mut EVMData<'_, DB>,
-        eval: InstructionResult,
-    ) -> InstructionResult {
+    fn step_end(&mut self, interp: &mut Interpreter<'_>, data: &mut EVMData<'_, DB>) {
         call_inspectors!([&mut self.tracer], |inspector| {
-            inspector.step_end(interp, data, eval);
+            inspector.step_end(interp, data);
         });
-        eval
     }
 
     #[inline]

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

@@ -267,7 +267,7 @@ impl Backend {
                 // accounts concurrently by spawning the job to a new task
                 genesis_accounts_futures.push(tokio::task::spawn(async move {
                     let db = db.read().await;
-                    let info = db.basic(address.to_alloy())?.unwrap_or_default();
+                    let info = db.basic_ref(address.to_alloy())?.unwrap_or_default();
                     Ok::<_, DatabaseError>((address, info))
                 }));
             }
@@ -341,7 +341,7 @@ impl Backend {
 
     /// Returns the `AccountInfo` from the database
     pub async fn get_account(&self, address: Address) -> DatabaseResult<AccountInfo> {
-        Ok(self.db.read().await.basic(address.to_alloy())?.unwrap_or_default())
+        Ok(self.db.read().await.basic_ref(address.to_alloy())?.unwrap_or_default())
     }
 
     /// Whether we're forked off some remote client
@@ -1148,7 +1148,7 @@ impl Backend {
         let to = if let Some(to) = request.to {
             to.to_alloy()
         } else {
-            let nonce = state.basic(from)?.unwrap_or_default().nonce;
+            let nonce = state.basic_ref(from)?.unwrap_or_default().nonce;
             from.create(nonce)
         };
 
@@ -1675,7 +1675,7 @@ impl Backend {
     ) -> Result<H256, BlockchainError> {
         self.with_database_at(block_request, |db, _| {
             trace!(target: "backend", "get storage for {:?} at {:?}", address, index);
-            let val = db.storage(address.to_alloy(), index.to_alloy())?;
+            let val = db.storage_ref(address.to_alloy(), index.to_alloy())?;
             Ok(u256_to_h256_be(val.to_ethers()))
         })
         .await?
@@ -1702,15 +1702,15 @@ impl Backend {
         D: DatabaseRef<Error = DatabaseError>,
     {
         trace!(target: "backend", "get code for {:?}", address);
-        let account = state.basic(address.to_alloy())?.unwrap_or_default();
+        let account = state.basic_ref(address.to_alloy())?.unwrap_or_default();
         if account.code_hash == KECCAK_EMPTY {
             // if the code hash is `KECCAK_EMPTY`, we check no further
             return Ok(Default::default())
         }
         let code = if let Some(code) = account.code {
             code
         } else {
-            state.code_by_hash(account.code_hash)?
+            state.code_by_hash_ref(account.code_hash)?
         };
         Ok(code.bytes()[..code.len()].to_vec().into())
     }
@@ -1736,7 +1736,7 @@ impl Backend {
         D: DatabaseRef<Error = DatabaseError>,
     {
         trace!(target: "backend", "get balance for {:?}", address);
-        Ok(state.basic(address.to_alloy())?.unwrap_or_default().balance.to_ethers())
+        Ok(state.basic_ref(address.to_alloy())?.unwrap_or_default().balance.to_ethers())
     }
 
     /// Returns the nonce of the address
@@ -1759,7 +1759,7 @@ impl Backend {
         };
         self.with_database_at(final_block_request, |db, _| {
             trace!(target: "backend", "get nonce for {:?}", address);
-            Ok(db.basic(address.to_alloy())?.unwrap_or_default().nonce.into())
+            Ok(db.basic_ref(address.to_alloy())?.unwrap_or_default().nonce.into())
         })
         .await?
     }

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

@@ -116,7 +116,7 @@ where
 {
     let mut cache_db = CacheDB::new(state);
     for (account, account_overrides) in overrides.iter() {
-        let mut account_info = cache_db.basic((*account).to_alloy())?.unwrap_or_default();
+        let mut account_info = cache_db.basic_ref((*account).to_alloy())?.unwrap_or_default();
 
         if let Some(nonce) = account_overrides.nonce {
             account_info.nonce = nonce;

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

@@ -478,7 +478,7 @@ mod tests {
 
         let loaded = storage.get(&one).unwrap();
 
-        let acc = loaded.basic(addr.to_alloy()).unwrap().unwrap();
+        let acc = loaded.basic_ref(addr.to_alloy()).unwrap().unwrap();
         assert_eq!(acc.balance, rU256::from(1337u64));
     }
 
@@ -508,7 +508,7 @@ mod tests {
             let hash = H256::from_uint(&U256::from(idx));
             let addr = Address::from(hash);
             let loaded = storage.get(&hash).unwrap();
-            let acc = loaded.basic(addr.to_alloy()).unwrap().unwrap();
+            let acc = loaded.basic_ref(addr.to_alloy()).unwrap().unwrap();
             let balance = (idx * 2) as u64;
             assert_eq!(acc.balance, rU256::from(balance));
         }

crates/anvil/src/eth/util.rs

@@ -1,12 +1,14 @@
-use ethers::{abi::Address, types::H160};
+use ethers::abi::Address;
 use foundry_evm::revm::{self, precompile::Precompiles, primitives::SpecId};
+use foundry_utils::types::ToEthers;
 use std::fmt;
 
 pub fn get_precompiles_for(spec_id: SpecId) -> Vec<Address> {
     Precompiles::new(to_precompile_id(spec_id))
         .addresses()
         .into_iter()
-        .map(|item| H160::from_slice(item))
+        .copied()
+        .map(|item| item.to_ethers())
         .collect()
 }