some work on extcall

crates/interpreter/src/instructions/contract.rs

@@ -1,6 +1,8 @@
 mod call_helpers;
 
-pub use call_helpers::{calc_call_gas, get_memory_input_and_out_ranges};
+pub use call_helpers::{
+    calc_call_gas, get_memory_input_and_out_ranges, resize_memory_and_return_range,
+};
 use revm_primitives::keccak256;
 
 use crate::{
@@ -162,30 +164,45 @@ pub fn extcall<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut H)
     error_on_disabled_eof!(interpreter);
     panic_on_eof!(interpreter);
     pop_address!(interpreter, to);
-    pop!(interpreter, value);
+    pop!(interpreter, input_offset, input_size, value);
     if interpreter.is_static && value != U256::ZERO {
         interpreter.instruction_result = InstructionResult::CallNotAllowedInsideStatic;
         return;
     }
 
-    // TODO(EOF) check if destination is EOF.
-    let Some((input, return_memory_offset)) = get_memory_input_and_out_ranges(interpreter) else {
+    let Some(return_memory_offset) =
+        resize_memory_and_return_range(interpreter, input_offset, input_size)
+    else {
         return;
     };
 
-    let Some(mut gas_limit) = calc_call_gas::<H, SPEC>(
-        interpreter,
-        host,
-        to,
-        value != U256::ZERO,
-        u64::MAX,
-        true,
-        true,
-    ) else {
+    // TODO(EOF) check if destination is EOF.
+    let Some(load_result) = host.load_account(to) else {
+        interpreter.instruction_result = InstructionResult::FatalExternalError;
         return;
     };
+    // TODO(EOF) is EOF!
+    if load_result.is_cold {
+        //gas!(interpreter, gas::COLD_ACCOUNT_ACCESS);
+        return;
+    }
+
+    let is_new = !load_result.is_not_existing;
+    let call_cost =
+        gas::call_cost::<SPEC>(value != U256::ZERO, is_new, load_result.is_cold, true, true);
+    gas!(interpreter, call_cost);
 
-    let mut gas_limit = max(gas_limit, 5000);
+    // 7. Calculate the gas available to callee as caller’s
+    // remaining gas reduced by max(ceil(gas/64), MIN_RETAINED_GAS) (MIN_RETAINED_GAS is 5000).
+    let gas_reduce = max(interpreter.gas.remaining() / 64, 5000);
+    let gas_limit = interpreter.gas().remaining().saturating_sub(gas_reduce);
+
+    if gas_limit < 2300 {
+        interpreter.instruction_result = InstructionResult::CallNotAllowedInsideStatic;
+        // TODO(EOF) error;
+        // interpreter.instruction_result = InstructionResult::CallGasTooLow;
+        return;
+    }
     gas!(interpreter, gas_limit);
 
     // Call host to interact with target contract
@@ -308,10 +325,14 @@ pub fn call<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut H) {
         return;
     };
 
+    let Some(load_result) = host.load_account(to) else {
+        interpreter.instruction_result = InstructionResult::FatalExternalError;
+        return;
+    };
+
     let Some(mut gas_limit) = calc_call_gas::<H, SPEC>(
         interpreter,
-        host,
-        to,
+        load_result,
         value != U256::ZERO,
         local_gas_limit,
         true,
@@ -364,10 +385,14 @@ pub fn call_code<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut
         return;
     };
 
+    let Some(load_result) = host.load_account(to) else {
+        interpreter.instruction_result = InstructionResult::FatalExternalError;
+        return;
+    };
+
     let Some(mut gas_limit) = calc_call_gas::<H, SPEC>(
         interpreter,
-        host,
-        to,
+        load_result,
         value != U256::ZERO,
         local_gas_limit,
         true,
@@ -420,9 +445,19 @@ pub fn delegate_call<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &
         return;
     };
 
-    let Some(gas_limit) =
-        calc_call_gas::<H, SPEC>(interpreter, host, to, false, local_gas_limit, false, false)
-    else {
+    let Some(load_result) = host.load_account(to) else {
+        interpreter.instruction_result = InstructionResult::FatalExternalError;
+        return;
+    };
+
+    let Some(gas_limit) = calc_call_gas::<H, SPEC>(
+        interpreter,
+        load_result,
+        false,
+        local_gas_limit,
+        false,
+        false,
+    ) else {
         return;
     };
 
@@ -468,9 +503,19 @@ pub fn static_call<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mu
         return;
     };
 
-    let Some(gas_limit) =
-        calc_call_gas::<H, SPEC>(interpreter, host, to, false, local_gas_limit, false, true)
-    else {
+    let Some(load_result) = host.load_account(to) else {
+        interpreter.instruction_result = InstructionResult::FatalExternalError;
+        return;
+    };
+
+    let Some(gas_limit) = calc_call_gas::<H, SPEC>(
+        interpreter,
+        load_result,
+        false,
+        local_gas_limit,
+        false,
+        true,
+    ) else {
         return;
     };
     gas!(interpreter, gas_limit);

crates/interpreter/src/instructions/contract/call_helpers.rs

@@ -1,8 +1,10 @@
+use revm_primitives::U256;
+
 use crate::{
-    gas::{self},
+    gas,
     interpreter::Interpreter,
-    primitives::{Address, Bytes, Spec, SpecId::*},
-    Host, InstructionResult,
+    primitives::{Bytes, Spec, SpecId::*},
+    Host, InstructionResult, LoadAccountResult,
 };
 use core::{cmp::min, ops::Range};
 
@@ -12,66 +14,64 @@ pub fn get_memory_input_and_out_ranges(
 ) -> Option<(Bytes, Range<usize>)> {
     pop_ret!(interpreter, in_offset, in_len, out_offset, out_len, None);
 
-    let in_len = as_usize_or_fail_ret!(interpreter, in_len, None);
-    let input = if in_len != 0 {
-        let in_offset = as_usize_or_fail_ret!(interpreter, in_offset, None);
-        shared_memory_resize!(interpreter, in_offset, in_len, None);
-        Bytes::copy_from_slice(interpreter.shared_memory.slice(in_offset, in_len))
-    } else {
-        Bytes::new()
-    };
+    let in_range = resize_memory_and_return_range(interpreter, in_offset, in_len)?;
+
+    let mut input = Bytes::new();
+    if !in_range.is_empty() {
+        input = Bytes::copy_from_slice(interpreter.shared_memory.slice_range(in_range));
+    }
+
+    let ret_range = resize_memory_and_return_range(interpreter, out_offset, out_len)?;
+    Some((input, ret_range))
+}
 
-    let out_len = as_usize_or_fail_ret!(interpreter, out_len, None);
-    let out_offset = if out_len != 0 {
-        let out_offset = as_usize_or_fail_ret!(interpreter, out_offset, None);
-        shared_memory_resize!(interpreter, out_offset, out_len, None);
-        out_offset
+/// Resize memory and return range of memory.
+/// If `len` is 0 dont touch memory and return `usize::MAX` as offset and 0 as length.
+#[inline]
+pub fn resize_memory_and_return_range(
+    interpreter: &mut Interpreter,
+    offset: U256,
+    len: U256,
+) -> Option<Range<usize>> {
+    let len = as_usize_or_fail_ret!(interpreter, len, None);
+    let offset = if len != 0 {
+        let offset = as_usize_or_fail_ret!(interpreter, offset, None);
+        shared_memory_resize!(interpreter, offset, len, None);
+        offset
     } else {
         usize::MAX //unrealistic value so we are sure it is not used
     };
-
-    Some((input, out_offset..out_offset + out_len))
+    Some(offset..offset + len)
 }
 
 #[inline]
 pub fn calc_call_gas<H: Host, SPEC: Spec>(
     interpreter: &mut Interpreter,
-    host: &mut H,
-    to: Address,
+    load_result: LoadAccountResult,
     has_transfer: bool,
     local_gas_limit: u64,
     is_call_or_callcode: bool,
     is_call_or_staticcall: bool,
 ) -> Option<u64> {
-    let Some(load_result) = host.load_account(to) else {
-        interpreter.instruction_result = InstructionResult::FatalExternalError;
-        return None;
-    };
     let is_new = !load_result.is_not_existing;
+    let call_cost = gas::call_cost::<SPEC>(
+        has_transfer,
+        is_new,
+        load_result.is_cold,
+        is_call_or_callcode,
+        is_call_or_staticcall,
+    );
 
-    if interpreter.is_eof {
-        // TODO(EOF)
-        None
-    } else {
-        let call_cost = gas::call_cost::<SPEC>(
-            has_transfer,
-            is_new,
-            load_result.is_cold,
-            is_call_or_callcode,
-            is_call_or_staticcall,
-        );
-
-        gas!(interpreter, call_cost, None);
+    gas!(interpreter, call_cost, None);
 
-        // EIP-150: Gas cost changes for IO-heavy operations
-        let gas_limit = if SPEC::enabled(TANGERINE) {
-            let gas = interpreter.gas().remaining();
-            // take l64 part of gas_limit
-            min(gas - gas / 64, local_gas_limit)
-        } else {
-            local_gas_limit
-        };
+    // EIP-150: Gas cost changes for IO-heavy operations
+    let gas_limit = if SPEC::enabled(TANGERINE) {
+        let gas = interpreter.gas().remaining();
+        // take l64 part of gas_limit
+        min(gas - gas / 64, local_gas_limit)
+    } else {
+        local_gas_limit
+    };
 
-        Some(gas_limit)
-    }
+    Some(gas_limit)
 }

crates/interpreter/src/interpreter/shared_memory.rs

@@ -3,7 +3,7 @@ use revm_primitives::{B256, U256};
 use core::{
     cmp::min,
     fmt,
-    ops::{BitAnd, Not},
+    ops::{BitAnd, Not, Range},
 };
 use std::vec::Vec;
 
@@ -142,13 +142,23 @@ impl SharedMemory {
     #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     pub fn slice(&self, offset: usize, size: usize) -> &[u8] {
-        let end = offset + size;
+        self.slice_range(offset..offset + size)
+    }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    pub fn slice_range(&self, range: Range<usize>) -> &[u8] {
         let last_checkpoint = self.last_checkpoint;
 
         self.buffer
-            .get(last_checkpoint + offset..last_checkpoint + offset + size)
+            .get(last_checkpoint + range.start..last_checkpoint + range.end)
             .unwrap_or_else(|| {
-                debug_unreachable!("slice OOB: {offset}..{end}; len: {}", self.len())
+                debug_unreachable!(
+                    "slice OOB: {}..{}; len: {}",
+                    range.start,
+                    range.end,
+                    self.len()
+                )
             })
     }