feat: Gas params

crates/context/interface/src/context.rs

@@ -195,6 +195,18 @@ impl SStoreResult {
         self.new_value.const_eq(&self.present_value)
     }
 
+    /// Returns `true` if the new values changes the present value.
+    #[inline]
+    pub const fn new_values_changes_present(&self) -> bool {
+        !self.is_new_eq_present()
+    }
+
+    /// Returns `true` if the original value is zero and the new value is not zero.
+    #[inline]
+    pub const fn have_changed_from_zero(&self) -> bool {
+        self.is_original_zero() && !self.is_new_zero()
+    }
+
     /// Returns `true` if the original value is equal to the present value.
     #[inline]
     pub const fn is_original_eq_present(&self) -> bool {

crates/context/src/journal/inner.rs

@@ -499,7 +499,7 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
         address: Address,
         target: Address,
         skip_cold_load: bool,
-    ) -> Result<StateLoad<SelfDestructResult>, JournalLoadError<<DB as Database>::Error>> {
+    ) -> Result<StateLoad<SelfDestructResult>, JournalLoadError<DB::Error>> {
         let spec = self.spec;
         let account_load = self.load_account_optional(db, target, false, skip_cold_load)?;
         let is_cold = account_load.is_cold;

crates/handler/src/evm.rs

@@ -183,7 +183,13 @@ where
 
         let ctx = &mut self.ctx;
         let precompiles = &mut self.precompiles;
-        let res = Self::Frame::init_with_context(new_frame, ctx, precompiles, frame_input)?;
+        let res = Self::Frame::init_with_context(
+            new_frame,
+            ctx,
+            precompiles,
+            frame_input,
+            self.instruction.gas_params(),
+        )?;
 
         Ok(res.map_frame(|token| {
             if is_first_init {

crates/handler/src/frame.rs

@@ -12,7 +12,7 @@ use context_interface::{
 use core::cmp::min;
 use derive_where::derive_where;
 use interpreter::{
-    gas,
+    gas::{self, params::GasParams},
     interpreter::{EthInterpreter, ExtBytecode},
     interpreter_action::FrameInit,
     interpreter_types::ReturnData,
@@ -101,6 +101,7 @@ pub type ContextTrDbError<CTX> = <<CTX as ContextTr>::Db as Database>::Error;
 impl EthFrame<EthInterpreter> {
     /// Clear and initialize a frame.
     #[allow(clippy::too_many_arguments)]
+    #[inline(always)]
     pub fn clear(
         &mut self,
         data: FrameData,
@@ -113,6 +114,7 @@ impl EthFrame<EthInterpreter> {
         spec_id: SpecId,
         gas_limit: u64,
         checkpoint: JournalCheckpoint,
+        gas_params: GasParams,
     ) {
         let Self {
             data: data_ref,
@@ -126,7 +128,9 @@ impl EthFrame<EthInterpreter> {
         *input_ref = input;
         *depth_ref = depth;
         *is_finished_ref = false;
-        interpreter.clear(memory, bytecode, inputs, is_static, spec_id, gas_limit);
+        interpreter.clear(
+            memory, bytecode, inputs, is_static, spec_id, gas_limit, gas_params,
+        );
         *checkpoint_ref = checkpoint;
     }
 
@@ -143,6 +147,7 @@ impl EthFrame<EthInterpreter> {
         depth: usize,
         memory: SharedMemory,
         inputs: Box<CallInputs>,
+        gas_params: GasParams,
     ) -> Result<ItemOrResult<FrameToken, FrameResult>, ERROR> {
         let gas = Gas::new(inputs.gas_limit);
         let return_result = |instruction_result: InstructionResult| {
@@ -242,6 +247,7 @@ impl EthFrame<EthInterpreter> {
             ctx.cfg().spec().into(),
             gas_limit,
             checkpoint,
+            gas_params,
         );
         Ok(ItemOrResult::Item(this.consume()))
     }
@@ -257,6 +263,7 @@ impl EthFrame<EthInterpreter> {
         depth: usize,
         memory: SharedMemory,
         inputs: Box<CreateInputs>,
+        gas_params: GasParams,
     ) -> Result<ItemOrResult<FrameToken, FrameResult>, ERROR> {
         let spec = context.cfg().spec().into();
         let return_error = |e| {
@@ -343,6 +350,7 @@ impl EthFrame<EthInterpreter> {
             spec,
             gas_limit,
             checkpoint,
+            gas_params,
         );
         Ok(ItemOrResult::Item(this.consume()))
     }
@@ -356,6 +364,7 @@ impl EthFrame<EthInterpreter> {
         ctx: &mut CTX,
         precompiles: &mut PRECOMPILES,
         frame_init: FrameInit,
+        gas_params: GasParams,
     ) -> Result<
         ItemOrResult<FrameToken, FrameResult>,
         ContextError<<<CTX as ContextTr>::Db as Database>::Error>,
@@ -369,9 +378,11 @@ impl EthFrame<EthInterpreter> {
 
         match frame_input {
             FrameInput::Call(inputs) => {
-                Self::make_call_frame(this, ctx, precompiles, depth, memory, inputs)
+                Self::make_call_frame(this, ctx, precompiles, depth, memory, inputs, gas_params)
+            }
+            FrameInput::Create(inputs) => {
+                Self::make_create_frame(this, ctx, depth, memory, inputs, gas_params)
             }
-            FrameInput::Create(inputs) => Self::make_create_frame(this, ctx, depth, memory, inputs),
             FrameInput::Empty => unreachable!(),
         }
     }

crates/handler/src/handler.rs

@@ -1,3 +1,4 @@
+use crate::instructions::InstructionProvider;
 use crate::{
     evm::FrameTr,
     execution, post_execution,
@@ -98,13 +99,23 @@ pub trait Handler {
         &mut self,
         evm: &mut Self::Evm,
     ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error> {
+        self.configure(evm);
         // Run inner handler and catch all errors to handle cleanup.
         match self.run_without_catch_error(evm) {
             Ok(output) => Ok(output),
             Err(e) => self.catch_error(evm, e),
         }
     }
 
+    /// Configure the handler:
+    ///  * Set Instruction gas table to the spec id.
+    #[inline]
+    fn configure(&mut self, evm: &mut Self::Evm) {
+        let spec_id = evm.ctx().cfg().spec().into();
+        // sets static gas depending on the spec id.
+        evm.ctx_instructions().1.set_spec(spec_id);
+    }
+
     /// Runs the system call.
     ///
     /// System call is a special transaction where caller is a [`crate::SYSTEM_ADDRESS`]
@@ -126,6 +137,8 @@ pub trait Handler {
     ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error> {
         // dummy values that are not used.
         let init_and_floor_gas = InitialAndFloorGas::new(0, 0);
+        // configure the evm for system call.
+        self.configure(evm);
         // call execution and than output.
         match self
             .execution(evm, &init_and_floor_gas)

crates/handler/src/instructions.rs

@@ -1,12 +1,14 @@
 use auto_impl::auto_impl;
 use interpreter::{
-    instructions::{instruction_table, InstructionTable},
+    gas::params::GasParams,
+    instructions::{instruction_table_gas_changes_spec, InstructionTable},
     Host, Instruction, InterpreterTypes,
 };
+use primitives::hardfork::SpecId;
 use std::boxed::Box;
 
 /// Stores instructions for EVM.
-#[auto_impl(&, Arc, Rc)]
+#[auto_impl(&mut, Box)]
 pub trait InstructionProvider {
     /// Context type.
     type Context;
@@ -15,13 +17,23 @@ pub trait InstructionProvider {
 
     /// Returns the instruction table that is used by EvmTr to execute instructions.
     fn instruction_table(&self) -> &InstructionTable<Self::InterpreterTypes, Self::Context>;
+
+    /// Returns the gas params that is used by EvmTr to execute instructions.
+    fn gas_params(&self) -> GasParams;
+
+    /// Sets the spec. Return true if the spec was changed.
+    fn set_spec(&mut self, spec: SpecId) -> bool;
 }
 
 /// Ethereum instruction contains list of mainnet instructions that is used for Interpreter execution.
 #[derive(Debug)]
 pub struct EthInstructions<WIRE: InterpreterTypes, HOST: ?Sized> {
     /// Table containing instruction implementations indexed by opcode.
     pub instruction_table: Box<InstructionTable<WIRE, HOST>>,
+    /// Gas params that sets gas costs for instructions.
+    pub gas_params: GasParams,
+    /// Spec that is used to set gas costs for instructions.
+    pub spec: SpecId,
 }
 
 impl<WIRE, HOST: Host + ?Sized> Clone for EthInstructions<WIRE, HOST>
@@ -31,6 +43,8 @@ where
     fn clone(&self) -> Self {
         Self {
             instruction_table: self.instruction_table.clone(),
+            gas_params: self.gas_params.clone(),
+            spec: self.spec,
         }
     }
 }
@@ -42,14 +56,25 @@ where
 {
     /// Returns `EthInstructions` with mainnet spec.
     pub fn new_mainnet() -> Self {
-        Self::new(instruction_table::<WIRE, HOST>())
+        let spec = SpecId::default();
+        Self::new(
+            instruction_table_gas_changes_spec(spec),
+            GasParams::new_spec(spec),
+            spec,
+        )
     }
 
     /// Returns a new instance of `EthInstructions` with custom instruction table.
     #[inline]
-    pub fn new(base_table: InstructionTable<WIRE, HOST>) -> Self {
+    pub fn new(
+        base_table: InstructionTable<WIRE, HOST>,
+        gas_params: GasParams,
+        spec: SpecId,
+    ) -> Self {
         Self {
             instruction_table: Box::new(base_table),
+            gas_params,
+            spec,
         }
     }
 
@@ -71,6 +96,20 @@ where
     fn instruction_table(&self) -> &InstructionTable<Self::InterpreterTypes, Self::Context> {
         &self.instruction_table
     }
+
+    fn gas_params(&self) -> GasParams {
+        self.gas_params.clone()
+    }
+
+    fn set_spec(&mut self, spec: SpecId) -> bool {
+        if spec == self.spec {
+            return false;
+        }
+        self.instruction_table = Box::new(instruction_table_gas_changes_spec(spec));
+        self.gas_params = GasParams::new_spec(spec);
+
+        true
+    }
 }
 
 impl<WIRE, HOST> Default for EthInstructions<WIRE, HOST>

crates/inspector/src/handler.rs

@@ -42,6 +42,7 @@ where
         &mut self,
         evm: &mut Self::Evm,
     ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error> {
+        self.configure(evm);
         match self.inspect_run_without_catch_error(evm) {
             Ok(output) => Ok(output),
             Err(e) => self.catch_error(evm, e),
@@ -136,6 +137,8 @@ where
     ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error> {
         // dummy values that are not used.
         let init_and_floor_gas = InitialAndFloorGas::new(0, 0);
+        // configure
+        self.configure(evm);
         // call execution with inspection and then output.
         match self
             .inspect_execution(evm, &init_and_floor_gas)

crates/interpreter/src/gas.rs

@@ -2,6 +2,7 @@
 
 mod calc;
 mod constants;
+pub mod params;
 
 pub use calc::*;
 pub use constants::*;
@@ -91,11 +92,6 @@ impl Gas {
         self.remaining
     }
 
-    /// Return remaining gas after subtracting 63/64 parts.
-    pub const fn remaining_63_of_64_parts(&self) -> u64 {
-        self.remaining - self.remaining / 64
-    }
-
     /// Erases a gas cost from the totals.
     #[inline]
     pub fn erase_cost(&mut self, returned: u64) {
@@ -199,15 +195,30 @@ impl MemoryGas {
         }
     }
 
+    /// Sets the number of words and the expansion cost.
+    ///
+    /// Returns the difference between the new and old expansion cost.
+    #[inline]
+    pub fn set_words_num(&mut self, words_num: usize, mut expansion_cost: u64) -> Option<u64> {
+        self.words_num = words_num;
+        core::mem::swap(&mut self.expansion_cost, &mut expansion_cost);
+        self.expansion_cost.checked_sub(expansion_cost)
+    }
+
     /// Records a new memory length and calculates additional cost if memory is expanded.
     /// Returns the additional gas cost required, or None if no expansion is needed.
     #[inline]
-    pub fn record_new_len(&mut self, new_num: usize) -> Option<u64> {
+    pub fn record_new_len(
+        &mut self,
+        new_num: usize,
+        linear_cost: u64,
+        quadratic_cost: u64,
+    ) -> Option<u64> {
         if new_num <= self.words_num {
             return None;
         }
         self.words_num = new_num;
-        let mut cost = crate::gas::calc::memory_gas(new_num);
+        let mut cost = crate::gas::calc::memory_gas(new_num, linear_cost, quadratic_cost);
         core::mem::swap(&mut self.expansion_cost, &mut cost);
         // Safe to subtract because we know that new_len > length
         // Notice the swap above.