check gas before access db

Author: lightsing

crates/interpreter/src/host.rs

@@ -48,6 +48,13 @@ pub trait Host {
     /// Get code hash of `address` and if the account is cold.
     fn code_hash(&mut self, address: Address) -> Option<StateLoad<B256>>;
 
+    /// Check a storage slot is code or not without change the access status.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the account is not present in the state.
+    fn is_storage_cold(&self, address: Address, key: U256) -> bool;
+
     #[cfg(feature = "scroll")]
     /// Get code size of `address` and if the account is cold.
     fn code_size(&mut self, address: Address) -> Option<StateLoad<usize>>;

crates/interpreter/src/host/dummy.rs

@@ -75,6 +75,11 @@ impl Host for DummyHost {
         Some(StateLoad::new(0, false))
     }
 
+    #[inline]
+    fn is_storage_cold(&self, _address: Address, key: U256) -> bool {
+        self.storage.contains_key(&key)
+    }
+
     #[inline]
     fn sload(&mut self, _address: Address, index: U256) -> Option<StateLoad<U256>> {
         match self.storage.entry(index) {

crates/interpreter/src/instructions/host.rs

@@ -176,6 +176,13 @@ pub fn blockhash<H: Host + ?Sized, SPEC: Spec>(interpreter: &mut Interpreter, ho
 
 pub fn sload<H: Host + ?Sized, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut H) {
     pop_top!(interpreter, index);
+    min_gas!(
+        interpreter,
+        gas::sload_cost(
+            SPEC::SPEC_ID,
+            host.is_storage_cold(interpreter.contract.target_address, *index)
+        )
+    );
     let Some(value) = host.sload(interpreter.contract.target_address, *index) else {
         interpreter.instruction_result = InstructionResult::FatalExternalError;
         return;
@@ -194,6 +201,13 @@ pub fn sstore<H: Host + ?Sized, SPEC: Spec>(interpreter: &mut Interpreter, host:
     require_non_staticcall!(interpreter);
 
     pop!(interpreter, index, value);
+    min_gas!(
+        interpreter,
+        gas::sload_cost(
+            SPEC::SPEC_ID,
+            host.is_storage_cold(interpreter.contract.target_address, *index)
+        )
+    );
     let Some(state_load) = host.sstore(interpreter.contract.target_address, index, value) else {
         interpreter.instruction_result = InstructionResult::FatalExternalError;
         return;

crates/interpreter/src/instructions/macros.rs

@@ -61,6 +61,20 @@ macro_rules! gas {
     };
 }
 
+/// Check if a `gas` cost would exceed the available gas.
+#[macro_export]
+macro_rules! min_gas {
+    ($interp:expr, $gas:expr) => {
+        $crate::min_gas!($interp, $gas, ())
+    };
+    ($interp:expr, $gas:expr, $ret:expr) => {
+        if $interp.gas.remaining() < $gas {
+            $interp.instruction_result = $crate::InstructionResult::OutOfGas;
+            return $ret;
+        }
+    };
+}
+
 /// Records a `gas` refund.
 #[macro_export]
 macro_rules! refund {

crates/revm/src/context.rs

@@ -167,6 +167,15 @@ impl<EXT, DB: Database> Host for Context<EXT, DB> {
             .ok()
     }
 
+    /// Check a storage slot is code or not without change the access status.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the account is not present in the state.
+    fn is_storage_cold(&self, address: Address, key: U256) -> bool {
+        self.evm.is_storage_cold(address, key)
+    }
+
     fn sload(&mut self, address: Address, index: U256) -> Option<StateLoad<U256>> {
         self.evm
             .sload(address, index)

crates/revm/src/context/inner_evm_context.rs

@@ -253,6 +253,16 @@ impl<DB: Database> InnerEvmContext<DB> {
         Ok(StateLoad::new(hash, acc.is_cold))
     }
 
+    /// Check a storage slot is code or not without change the access status.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the account is not present in the state.
+    #[inline]
+    pub fn is_storage_cold(&self, address: Address, key: U256) -> bool {
+        self.journaled_state.is_storage_cold(address, key)
+    }
+
     /// Load storage slot, if storage is not present inside the account then it will be loaded from database.
     #[inline]
     pub fn sload(

crates/revm/src/journaled_state.rs

@@ -692,6 +692,22 @@ impl JournaledState {
         Ok(account_load)
     }
 
+    /// Check a storage slot is code or not without change the access status.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the account is not present in the state.
+    #[inline]
+    pub fn is_storage_cold(&self, address: Address, key: U256) -> bool {
+        // assume acc is warm
+        let account = self.state.get(&address).unwrap();
+        account
+            .storage
+            .get(&key)
+            .map(|slot| slot.is_cold)
+            .unwrap_or(true)
+    }
+
     /// Load storage slot
     ///
     /// # Panics