Struct evm_rs_emulator::Runner

pub struct Runner {

    pub pc: usize,
    pub bytecode: Vec<u8>,
    pub debug_level: Option<u8>,
    pub call_depth: u32,
    pub gas: u64,
    pub origin: [u8; 20],
    pub caller: [u8; 20],
    pub callvalue: [u8; 32],
    pub address: [u8; 20],
    pub state: EvmState,
    pub memory: Memory,
    pub calldata: Memory,
    pub returndata: Memory,
    pub stack: Stack,
}

Fields

pc: usize

bytecode: Vec<u8>

debug_level: Option<u8>

call_depth: u32

gas: u64

origin: [u8; 20]

caller: [u8; 20]

callvalue: [u8; 32]

address: [u8; 20]

state: EvmState

memory: Memory

calldata: Memory

returndata: Memory

stack: Stack

Implementations

impl Runner

Implementation of the Runner struct, which is responsible for executing EVM bytecode.

pub fn new( caller: [u8; 20], origin: Option<[u8; 20]>, address: Option<[u8; 20]>, callvalue: Option<[u8; 32]>, calldata: Option<Vec<u8>>, state: Option<EvmState> ) -> Self

Creates a new instance of the EVM runner with the given parameters.

Arguments

• caller - The address of the account that initiated the call.
• origin - The address of the account that originally initiated the transaction.
• address - The address of the account that will receive the call.
• callvalue - The value (in wei) that was sent along with the call.
• calldata - The input data for the call.
• state - The initial state of the EVM.

Returns

A new instance of the EVM runner.

pub fn _default(debug_level: u8) -> Self

Creates a new Runner instance with default values and sets the debug level to the given value.

Arguments

• debug_level - A u8 value representing the debug level to set.

Returns

A new Runner instance with default values and the debug level set to the given value.

pub fn increment_pc(&mut self, size: usize) -> Result<(), ExecutionError>

Increments the program counter by the specified size.

Arguments

• size - The number of bytes to increment the program counter by.

Errors

Returns an ExecutionError if the program counter goes out of bounds.

pub fn set_pc(&mut self, value: usize)

Sets the program counter to the specified value.

Arguments

• value - The value to set the program counter to.

pub fn get_pc(&mut self) -> usize

Returns the current value of the program counter.

pub fn interpret( &mut self, bytecode: Vec<u8>, debug: Option<u8>, initial_interpretation: bool ) -> Result<(), ExecutionError>

Interprets the given bytecode and executes it on the EVM.

Arguments

• bytecode - A vector of bytes representing the bytecode to be executed.
• debug - An optional u8 value representing the debug level. If set to 2 or higher, debug information will be printed.
• initial_interpretation - A boolean value indicating whether this is the initial interpretation of the bytecode.

Errors

Returns an ExecutionError if an error occurs during execution.

Examples

use evm_rs_emulator::Runner;

let mut runner = Runner::_default(255);
let bytecode = vec![0x60, 0x01, 0x60, 0x02, 0x01, 0x00, 0x00];
let result = runner.interpret(bytecode, Some(2), true);
assert!(result.is_ok());

pub fn interpret_op_code(&mut self, opcode: u8) -> Result<(), ExecutionError>

Interpret a single opcode.

Arguments

• opcode - A single opcode to interpret.

Errors

Returns an ExecutionError if the opcode is invalid or if an error occurs during execution.

OpCodes

The function matches the given opcode with the corresponding function from the op_codes module. The OpCodes are divided into the following categories:

• Execution OpCodes
• Math operations OpCodes
• Push OpCodes
• Dup OpCodes
• Swap OpCodes
• Memory OpCodes
• Storage OpCodes

For more information on each OpCode, please refer to the op_codes module.

pub fn call( &mut self, to: [u8; 20], value: [u8; 32], calldata: Vec<u8>, _gas: u64, delegate: bool ) -> Result<(), ExecutionError>

Executes a call to a contract. Set up a new runner environment for the call and interpret the bytecode.

Arguments

• to - The address of the contract to call.
• value - The value to send with the call.
• calldata - The input data to the contract.
• _gas - The gas limit for the call (currently unused).
• delegate - Whether the call is a delegate call.

Errors

Returns an ExecutionError if the call fails.

pub fn print_debug(&self, s: &str)

Prints a debug message with a tab prefix that indicates the current call depth. The more the call depth is high, the more the tab prefix will be long.