Merge remote-tracking branch 'origin/main' into refactor_fatal_error

Author: rakita

crates/interpreter/src/host.rs

@@ -37,12 +37,7 @@ pub trait Host {
     /// Set storage value of account address at index.
     ///
     /// Returns (original, present, new, is_cold).
-    fn sstore(
-        &mut self,
-        address: Address,
-        index: U256,
-        value: U256,
-    ) -> Option<(U256, U256, U256, bool)>;
+    fn sstore(&mut self, address: Address, index: U256, value: U256) -> Option<SStoreResult>;
 
     /// Get the transient storage value of `address` at `index`.
     fn tload(&mut self, address: Address, index: U256) -> U256;
@@ -56,3 +51,17 @@ pub trait Host {
     /// Mark `address` to be deleted, with funds transferred to `target`.
     fn selfdestruct(&mut self, address: Address, target: Address) -> Option<SelfDestructResult>;
 }
+
+/// Represents the result of an `sstore` operation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct SStoreResult {
+    /// Value of the storage when it is first read
+    pub original_value: U256,
+    /// Current value of the storage
+    pub present_value: U256,
+    /// New value that is set
+    pub new_value: U256,
+    /// Is storage slot loaded from database
+    pub is_cold: bool,
+}

crates/interpreter/src/host/dummy.rs

@@ -1,7 +1,7 @@
 use crate::primitives::{hash_map::Entry, Bytecode, HashMap, U256};
 use crate::{
     primitives::{Address, Env, Log, B256, KECCAK_EMPTY},
-    Host, SelfDestructResult,
+    Host, SStoreResult, SelfDestructResult,
 };
 use std::vec::Vec;
 
@@ -80,12 +80,7 @@ impl Host for DummyHost {
     }
 
     #[inline]
-    fn sstore(
-        &mut self,
-        _address: Address,
-        index: U256,
-        value: U256,
-    ) -> Option<(U256, U256, U256, bool)> {
+    fn sstore(&mut self, _address: Address, index: U256, value: U256) -> Option<SStoreResult> {
         let (present, is_cold) = match self.storage.entry(index) {
             Entry::Occupied(mut entry) => (entry.insert(value), false),
             Entry::Vacant(entry) => {
@@ -94,7 +89,12 @@ impl Host for DummyHost {
             }
         };
 
-        Some((U256::ZERO, present, value, is_cold))
+        Some(SStoreResult {
+            original_value: U256::ZERO,
+            present_value: present,
+            new_value: value,
+            is_cold,
+        })
     }
 
     #[inline]

crates/interpreter/src/instructions/host.rs

@@ -7,7 +7,7 @@ use crate::{
     interpreter::{Interpreter, InterpreterAction},
     primitives::{Address, Bytes, Log, LogData, Spec, SpecId::*, B256, U256},
     CallContext, CallInputs, CallScheme, CreateInputs, CreateScheme, Host, InstructionResult,
-    Transfer, MAX_INITCODE_SIZE,
+    SStoreResult, Transfer, MAX_INITCODE_SIZE,
 };
 use core::cmp::min;
 use revm_primitives::BLOCK_HASH_HISTORY;
@@ -154,8 +154,12 @@ pub fn sstore<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut H)
     check_staticcall!(interpreter);
 
     pop!(interpreter, index, value);
-    let Some((original, old, new, is_cold)) =
-        host.sstore(interpreter.contract.address, index, value)
+    let Some(SStoreResult {
+        original_value: original,
+        present_value: old,
+        new_value: new,
+        is_cold,
+    }) = host.sstore(interpreter.contract.address, index, value)
     else {
         interpreter.instruction_result = InstructionResult::FatalExternalError;
         return;

crates/interpreter/src/interpreter.rs

@@ -156,8 +156,9 @@ impl Interpreter {
     /// - Updates gas costs and records refunds in the interpreter's `gas` field.
     /// - May alter `instruction_result` in case of external errors.
     pub fn insert_create_outcome(&mut self, create_outcome: CreateOutcome) {
-        let instruction_result = create_outcome.instruction_result();
+        self.instruction_result = InstructionResult::Continue;
 
+        let instruction_result = create_outcome.instruction_result();
         self.return_data_buffer = if instruction_result.is_revert() {
             // Save data to return data buffer if the create reverted
             create_outcome.output().to_owned()
@@ -213,6 +214,7 @@ impl Interpreter {
         shared_memory: &mut SharedMemory,
         call_outcome: CallOutcome,
     ) {
+        self.instruction_result = InstructionResult::Continue;
         let out_offset = call_outcome.memory_start();
         let out_len = call_outcome.memory_length();
 
@@ -314,7 +316,6 @@ impl Interpreter {
         FN: Fn(&mut Interpreter, &mut H),
     {
         self.next_action = InterpreterAction::None;
-        self.instruction_result = InstructionResult::Continue;
         self.shared_memory = shared_memory;
         // main loop
         while self.instruction_result == InstructionResult::Continue {

crates/interpreter/src/lib.rs

@@ -25,7 +25,7 @@ mod interpreter;
 pub use call_outcome::CallOutcome;
 pub use create_outcome::CreateOutcome;
 pub use gas::Gas;
-pub use host::{DummyHost, Host};
+pub use host::{DummyHost, Host, SStoreResult};
 pub use inner_models::*;
 pub use instruction_result::*;
 pub use instructions::{opcode, Instruction, OpCode, OPCODE_JUMPMAP};

crates/revm/src/context.rs

@@ -12,6 +12,7 @@ use crate::{
     },
     FrameOrResult, JournalCheckpoint, CALL_STACK_LIMIT,
 };
+use revm_interpreter::SStoreResult;
 use std::boxed::Box;
 
 /// Main Context structure that contains both EvmContext and External context.
@@ -245,7 +246,7 @@ impl<DB: Database> EvmContext<DB> {
         address: Address,
         index: U256,
         value: U256,
-    ) -> Result<(U256, U256, U256, bool), EVMError<DB::Error>> {
+    ) -> Result<SStoreResult, EVMError<DB::Error>> {
         self.journaled_state
             .sstore(address, index, value, &mut self.db)
     }

crates/revm/src/db/ethersdb.rs

@@ -3,47 +3,39 @@ use crate::{Database, DatabaseRef};
 use ethers_core::types::{BlockId, H160 as eH160, H256, U64 as eU64};
 use ethers_providers::Middleware;
 use std::sync::Arc;
-use tokio::runtime::{Handle, Runtime};
 
 #[derive(Debug)]
 pub struct EthersDB<M: Middleware> {
     client: Arc<M>,
-    runtime: Option<Runtime>,
     block_number: Option<BlockId>,
 }
 
 impl<M: Middleware> EthersDB<M> {
     /// create ethers db connector inputs are url and block on what we are basing our database (None for latest)
     pub fn new(client: Arc<M>, block_number: Option<BlockId>) -> Option<Self> {
-        let runtime = Handle::try_current()
-            .is_err()
-            .then(|| Runtime::new().unwrap());
-
         let client = client;
 
         let mut out = Self {
             client,
-            runtime,
             block_number: None,
         };
 
-        out.block_number = if block_number.is_some() {
-            block_number
+        out.block_number = if let Some(bn) = block_number {
+            Some(bn)
         } else {
-            Some(BlockId::from(
-                out.block_on(out.client.get_block_number()).ok()?,
-            ))
+            let current_block_number = tokio::runtime::Handle::current()
+                .block_on(out.client.get_block_number())
+                .ok()?;
+
+            Some(BlockId::from(current_block_number))
         };
 
         Some(out)
     }
 
     /// internal utility function to call tokio feature and wait for output
     fn block_on<F: core::future::Future>(&self, f: F) -> F::Output {
-        match &self.runtime {
-            Some(runtime) => runtime.block_on(f),
-            None => futures::executor::block_on(f),
-        }
+        tokio::runtime::Handle::current().block_on(f)
     }
 }
 

crates/revm/src/db/in_memory_db.rs

@@ -19,7 +19,7 @@ pub type InMemoryDB = CacheDB<EmptyDB>;
 /// The [DbAccount] holds the code hash of the contract, which is used to look up the contract in the `contracts` map.
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct CacheDB<ExtDB: DatabaseRef> {
+pub struct CacheDB<ExtDB> {
     /// Account info where None means it is not existing. Not existing state is needed for Pre TANGERINE forks.
     /// `code` is always `None`, and bytecode can be found in `contracts`.
     pub accounts: HashMap<Address, DbAccount>,
@@ -35,13 +35,13 @@ pub struct CacheDB<ExtDB: DatabaseRef> {
     pub db: ExtDB,
 }
 
-impl<ExtDB: DatabaseRef + Default> Default for CacheDB<ExtDB> {
+impl<ExtDB: Default> Default for CacheDB<ExtDB> {
     fn default() -> Self {
         Self::new(ExtDB::default())
     }
 }
 
-impl<ExtDB: DatabaseRef> CacheDB<ExtDB> {
+impl<ExtDB> CacheDB<ExtDB> {
     pub fn new(db: ExtDB) -> Self {
         let mut contracts = HashMap::new();
         contracts.insert(KECCAK_EMPTY, Bytecode::new());
@@ -81,7 +81,9 @@ impl<ExtDB: DatabaseRef> CacheDB<ExtDB> {
         self.insert_contract(&mut info);
         self.accounts.entry(address).or_default().info = info;
     }
+}
 
+impl<ExtDB: DatabaseRef> CacheDB<ExtDB> {
     /// Returns the account for the given address.
     ///
     /// If the account was not found in the cache, it will be loaded from the underlying database.
@@ -125,7 +127,7 @@ impl<ExtDB: DatabaseRef> CacheDB<ExtDB> {
     }
 }
 
-impl<ExtDB: DatabaseRef> DatabaseCommit for CacheDB<ExtDB> {
+impl<ExtDB> DatabaseCommit for CacheDB<ExtDB> {
     fn commit(&mut self, changes: HashMap<Address, Account>) {
         for (address, mut account) in changes {
             if !account.is_touched() {

crates/revm/src/evm.rs

@@ -3,8 +3,8 @@ use crate::{
     db::{Database, DatabaseCommit, EmptyDB},
     handler::Handler,
     interpreter::{
-        opcode::InstructionTables, Host, Interpreter, InterpreterAction, SelfDestructResult,
-        SharedMemory,
+        opcode::InstructionTables, Host, Interpreter, InterpreterAction, SStoreResult,
+        SelfDestructResult, SharedMemory,
     },
     primitives::{
         specification::SpecId, Address, BlockEnv, Bytecode, CfgEnv, EVMError, EVMResult, Env,
@@ -425,12 +425,7 @@ impl<EXT, DB: Database> Host for Evm<'_, EXT, DB> {
             .ok()
     }
 
-    fn sstore(
-        &mut self,
-        address: Address,
-        index: U256,
-        value: U256,
-    ) -> Option<(U256, U256, U256, bool)> {
+    fn sstore(&mut self, address: Address, index: U256, value: U256) -> Option<SStoreResult> {
         self.context
             .evm
             .sstore(address, index, value)

crates/revm/src/journaled_state.rs

@@ -5,6 +5,7 @@ use crate::primitives::{
 };
 use core::mem;
 use revm_interpreter::primitives::SpecId;
+use revm_interpreter::SStoreResult;
 use std::vec::Vec;
 
 /// JournalState is internal EVM state that is used to contain state and track changes to that state.
@@ -655,7 +656,7 @@ impl JournaledState {
         key: U256,
         new: U256,
         db: &mut DB,
-    ) -> Result<(U256, U256, U256, bool), EVMError<DB::Error>> {
+    ) -> Result<SStoreResult, EVMError<DB::Error>> {
         // assume that acc exists and load the slot.
         let (present, is_cold) = self.sload(address, key, db)?;
         let acc = self.state.get_mut(&address).unwrap();
@@ -665,7 +666,12 @@ impl JournaledState {
 
         // new value is same as present, we don't need to do anything
         if present == new {
-            return Ok((slot.previous_or_original_value, present, new, is_cold));
+            return Ok(SStoreResult {
+                original_value: slot.previous_or_original_value,
+                present_value: present,
+                new_value: new,
+                is_cold,
+            });
         }
 
         self.journal
@@ -678,7 +684,12 @@ impl JournaledState {
             });
         // insert value into present state.
         slot.present_value = new;
-        Ok((slot.previous_or_original_value, present, new, is_cold))
+        Ok(SStoreResult {
+            original_value: slot.previous_or_original_value,
+            present_value: present,
+            new_value: new,
+            is_cold,
+        })
     }
 
     /// Read transient storage tied to the account.