Struct Interpreter 

pub struct Interpreter<WIRE = EthInterpreter>
where
    WIRE: InterpreterTypes,
{
    pub bytecode: <WIRE as InterpreterTypes>::Bytecode,
    pub gas: Gas,
    pub stack: <WIRE as InterpreterTypes>::Stack,
    pub return_data: <WIRE as InterpreterTypes>::ReturnData,
    pub memory: <WIRE as InterpreterTypes>::Memory,
    pub input: <WIRE as InterpreterTypes>::Input,
    pub runtime_flag: <WIRE as InterpreterTypes>::RuntimeFlag,
    pub extend: <WIRE as InterpreterTypes>::Extend,
}

Available on crate feature evm only.

Main interpreter structure that contains all components defined in InterpreterTypes.

Fields

bytecode: <WIRE as InterpreterTypes>::Bytecode

Bytecode being executed.

gas: Gas

Gas tracking for execution costs.

stack: <WIRE as InterpreterTypes>::Stack

EVM stack for computation.

return_data: <WIRE as InterpreterTypes>::ReturnData

Buffer for return data from calls.

memory: <WIRE as InterpreterTypes>::Memory

EVM memory for data storage.

input: <WIRE as InterpreterTypes>::Input

Input data for current execution context.

runtime_flag: <WIRE as InterpreterTypes>::RuntimeFlag

Runtime flags controlling execution behavior.

extend: <WIRE as InterpreterTypes>::Extend

Extended functionality and customizations.

Implementations

impl<EXT> Interpreter<EthInterpreter<EXT>>

where EXT: Default,

pub fn new( memory: SharedMemory, bytecode: ExtBytecode, input: InputsImpl, is_static: bool, spec_id: SpecId, gas_limit: u64, ) -> Interpreter<EthInterpreter<EXT>>

Create new interpreter

pub fn default_ext() -> Interpreter<EthInterpreter<EXT>>

Create a new interpreter with default extended functionality.

pub fn invalid() -> Interpreter<EthInterpreter<EXT>>

Create a new invalid interpreter.

pub fn clear( &mut self, memory: SharedMemory, bytecode: ExtBytecode, input: InputsImpl, is_static: bool, spec_id: SpecId, gas_limit: u64, )

Clears and reinitializes the interpreter with new parameters.

pub fn with_bytecode( self, bytecode: Bytecode, ) -> Interpreter<EthInterpreter<EXT>>

Sets the bytecode that is going to be executed

pub fn set_spec_id(&mut self, spec_id: SpecId)

Sets the specid for the interpreter.

impl<IW> Interpreter<IW>

where IW: InterpreterTypes,

pub fn resize_memory(&mut self, offset: usize, len: usize) -> bool

Performs EVM memory resize.

pub fn take_next_action(&mut self) -> InterpreterAction

Takes the next action from the control and returns it.

pub fn halt(&mut self, result: InstructionResult)

Halt the interpreter with the given result.

This will set the action to InterpreterAction::Return and set the gas to the current gas.

pub fn halt_oog(&mut self)

Halt the interpreter with an out-of-gas error.

pub fn halt_memory_oog(&mut self)

Halt the interpreter with an out-of-gas error.

pub fn halt_overflow(&mut self)

Halt the interpreter with and overflow error.

pub fn halt_underflow(&mut self)

Halt the interpreter with and underflow error.

pub fn halt_not_activated(&mut self)

Halt the interpreter with and not activated error.

pub fn return_with_output(&mut self, output: Bytes)

Return with the given output.

This will set the action to InterpreterAction::Return and set the gas to the current gas.

pub fn step<H>( &mut self, instruction_table: &[Instruction<IW, H>; 256], host: &mut H, )

where H: Host + ?Sized,

Executes the instruction at the current instruction pointer.

Internally it will increment instruction pointer by one.

pub fn step_dummy( &mut self, instruction_table: &[Instruction<IW, DummyHost>; 256], )

Executes the instruction at the current instruction pointer.

Internally it will increment instruction pointer by one.

This uses dummy Host.

pub fn run_plain<H>( &mut self, instruction_table: &[Instruction<IW, H>; 256], host: &mut H, ) -> InterpreterAction

where H: Host + ?Sized,

Executes the interpreter until it returns or stops.

impl<IW> Interpreter<IW>

where IW: InterpreterTypes, <IW as InterpreterTypes>::Output: From<InterpreterAction>,

pub fn take_next_action_as_output(&mut self) -> <IW as InterpreterTypes>::Output

Takes the next action from the control and returns it as the specific Output type.

pub fn run_plain_as_output<H>( &mut self, instruction_table: &[Instruction<IW, H>; 256], host: &mut H, ) -> <IW as InterpreterTypes>::Output

where H: Host + ?Sized,

Executes the interpreter until it returns or stops, returning the specific Output type.

Trait Implementations

impl<WIRE> Clone for Interpreter<WIRE>

where WIRE: Clone + InterpreterTypes, <WIRE as InterpreterTypes>::Bytecode: Clone, <WIRE as InterpreterTypes>::Stack: Clone, <WIRE as InterpreterTypes>::ReturnData: Clone, <WIRE as InterpreterTypes>::Memory: Clone, <WIRE as InterpreterTypes>::Input: Clone, <WIRE as InterpreterTypes>::RuntimeFlag: Clone, <WIRE as InterpreterTypes>::Extend: Clone,

fn clone(&self) -> Interpreter<WIRE>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<WIRE> Debug for Interpreter<WIRE>

where WIRE: Debug + InterpreterTypes, <WIRE as InterpreterTypes>::Bytecode: Debug, <WIRE as InterpreterTypes>::Stack: Debug, <WIRE as InterpreterTypes>::ReturnData: Debug, <WIRE as InterpreterTypes>::Memory: Debug, <WIRE as InterpreterTypes>::Input: Debug, <WIRE as InterpreterTypes>::RuntimeFlag: Debug, <WIRE as InterpreterTypes>::Extend: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Interpreter

fn default() -> Interpreter

Returns the “default value” for a type.

impl<'de, WIRE> Deserialize<'de> for Interpreter<WIRE>

where WIRE: InterpreterTypes, <WIRE as InterpreterTypes>::Bytecode: Deserialize<'de>, <WIRE as InterpreterTypes>::Stack: Deserialize<'de>, <WIRE as InterpreterTypes>::ReturnData: Deserialize<'de>, <WIRE as InterpreterTypes>::Memory: Deserialize<'de>, <WIRE as InterpreterTypes>::Input: Deserialize<'de>, <WIRE as InterpreterTypes>::RuntimeFlag: Deserialize<'de>, <WIRE as InterpreterTypes>::Extend: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Interpreter<WIRE>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<WIRE> Serialize for Interpreter<WIRE>

where WIRE: InterpreterTypes, <WIRE as InterpreterTypes>::Bytecode: Serialize, <WIRE as InterpreterTypes>::Stack: Serialize, <WIRE as InterpreterTypes>::ReturnData: Serialize, <WIRE as InterpreterTypes>::Memory: Serialize, <WIRE as InterpreterTypes>::Input: Serialize, <WIRE as InterpreterTypes>::RuntimeFlag: Serialize, <WIRE as InterpreterTypes>::Extend: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.