Struct evm_adapters::sputnik::Executor

pub struct Executor<S, E> {
    pub executor: E,
    pub gas_limit: u64,
    // some fields omitted
}

Wrapper around Sputnik Executors which implements the Evm trait.

Fields

executor: E

gas_limit: u64

Implementations

impl<S, E> Executor<S, E>

pub fn from_executor(executor: E, gas_limit: u64) -> Self

Instantiates the executor given a Sputnik instance.

impl<'a, 'b, B: Backend, P: PrecompileSet> Executor<MemoryStackState<'a, 'a, B>, StackExecutor<'a, 'b, MemoryStackState<'a, 'a, B>, P>>

pub fn new(
    gas_limit: u64,
    config: &'a Config,
    backend: &'a B,
    precompiles: &'b P
) -> Self

Given a gas limit, vm version, initial chain configuration and initial state

impl<'a, 'b, B: Backend, P: PrecompileSet> Executor<CheatcodeStackState<'a, B>, CheatcodeStackExecutor<'a, 'b, B, P>>

pub fn new_with_cheatcodes(
    backend: B,
    gas_limit: u64,
    config: &'a Config,
    precompiles: &'b P,
    enable_ffi: bool,
    enable_trace: bool,
    debug: bool
) -> Self

Instantiates a cheatcode-enabled Executor

Trait Implementations

impl<'a, S, E> Evm<S> for Executor<S, E> where
    E: SputnikExecutor<S>,
    S: StackState<'a>, 

fn debug_calls(&self) -> Vec<DebugArena>

Grabs debug steps

fn initialize_contracts<T: IntoIterator<Item = (Address, Bytes)>>(
    &mut self,
    contracts: T
)

given an iterator of contract address to contract bytecode, initializes the state with the contract deployed at the specified address

fn deploy(
    &mut self,
    from: Address,
    calldata: Bytes,
    value: U256
) -> Result<(Address, ExitReason, u64, Vec<String>)>

Deploys the provided contract bytecode

fn call_raw(
    &mut self,
    from: Address,
    to: Address,
    calldata: Bytes,
    value: U256,
    _is_static: bool
) -> Result<(Bytes, ExitReason, u64, Vec<String>)>

Runs the selected function

type ReturnReason = ExitReason

The returned reason type from an EVM (Success / Revert/ Stopped etc.)

fn revert() -> Self::ReturnReason

Gets the revert reason type

fn expected_revert(&self) -> Option<&[u8]>

fn is_success(reason: &Self::ReturnReason) -> bool

Whether a return reason should be considered successful

fn is_fail(reason: &Self::ReturnReason) -> bool

Whether a return reason should be considered failing

fn reset(&mut self, state: S)

Resets the EVM’s state to the provided value

fn set_tracing_enabled(&mut self, enabled: bool) -> bool

Turns on/off tracing, returning the previously set value

fn tracing_enabled(&self) -> bool

Returns whether tracing is enabled

fn set_balance(&mut self, address: Address, balance: U256)

Sets the balance at the specified address

fn state(&self) -> &S

Gets a reference to the current state of the EVM

fn code(&self, address: Address) -> Vec<u8>

fn traces(&self) -> Vec<CallTraceArena>

fn reset_traces(&mut self)

fn all_logs(&self) -> Vec<String>

Gets all logs from the execution, regardless of reverts

fn call<D: Detokenize, T: Tokenize, F: IntoFunction>(
    &mut self,
    from: Address,
    to: Address,
    func: F,
    args: T,
    value: U256
) -> Result<(D, Self::ReturnReason, u64, Vec<String>), EvmError>

Performs a call_unchecked, checks if execution reverted, and proceeds to return the decoded response to the user.

fn call_unchecked<T: Tokenize>(
    &mut self,
    from: Address,
    to: Address,
    func: &Function,
    args: T,
    value: U256
) -> Result<(Bytes, Self::ReturnReason, u64, Vec<String>)>

Executes the specified EVM call against the state

fn setup(
    &mut self,
    address: Address
) -> Result<(Self::ReturnReason, Vec<String>)>

Runs the setUp() function call to instantiate the contract’s state

fn failed(&mut self, address: Address) -> Result<bool>

Runs the failed() function call to inspect the test contract’s state and see whether the failed state var is set. This is to allow compatibility with dapptools-style DSTest smart contracts to preserve emiting of logs

fn check_success(
    &mut self,
    address: Address,
    reason: &Self::ReturnReason,
    should_fail: bool
) -> bool

Given a smart contract address, the result type and whether it’s expected to fail, it returns the test’s success status