Struct Env

pub struct Env<D: DB, V: Validator> {
    pub evm_state: Option<ContextWithHandlerCfg<(), D>>,
    pub last_events: Vec<Event>,
    pub event_history: Vec<Event>,
    pub validator: V,
}

Simulation environment

Environment wrapping an in-memory EVM and functionality to update the state of the environment.

Fields

evm_state: Option<ContextWithHandlerCfg<(), D>>

Local EVM state

last_events: Vec<Event>

Events/updates in the last block

event_history: Vec<Event>

History of events/updates over the lifetime of the environment

validator: V

Validator responsbile for transaction ordering

Implementations

impl<V: Validator> Env<ForkDb, V>

pub fn init(node_url: &str, block_number: Option<u64>, validator: V) -> Self

Initialise an environment with a forked DB

Initialise a simulation environment with a database that can request values from a remote fork of the blockchain. During EVM execution, if a contract or storage value does not exist locally the db will attempt to request it from the remote endpoint.

Arguments

• node_url - Url of service to make db requests
• block_number - Block number to fork from, if None latest available block will be used.

pub fn get_request_history(&self) -> &RequestCache

Get history of data requests made by the DB

Get a history of requests for data from the remote fork. These requests can then be inserted into an empty DB to speed up future simulations.

impl<V: Validator> Env<LocalDB, V>

pub fn init(timestamp: U256, block_number: U256, validator: V) -> Self

Initialise a simulation with an in-memory DB

Initialises a simulation environment with an empty in-memory database.

Arguments

• timestamp - Timestamp to initialise the the simulation/EVM with
• block_number - Block number initialise the the simulation/EVM with

impl<D: DB, V: Validator> Env<D, V>

pub fn evm_state(&mut self) -> &mut ContextWithHandlerCfg<(), D>

Get a mutable reference to the stored evm-state

pub fn increment_time<R: Rng>(&mut self, rng: &mut R, interval: u64)

Increment block number, time and prevarando

pub fn insert_account(&mut self, address: Address, start_balance: U256)

Insert a user account into the DB

Arguments

• address - Address to create the account at
• start_balance - Starting balance of Eth of the account

pub fn insert_accounts(&mut self, start_balance: u128, addresses: Vec<Address>)

Insert multiple accounts into the DB

Arguments

• start_balance - Starting balance of Eth of the account
• addresses - Vector of addresses to create accounts at

pub fn deploy_contract( &mut self, deployer: Address, contract_name: &str, data: Vec<u8>, ) -> Address

Deploy a contract to the EVM

Arguments

• deployer - Address of contract deployer
• contract_name - Name of the contract, only used for error messaging
• data - Deployment bytecode, and abi encoded arguments if required

pub fn direct_execute_raw( &mut self, callee: Address, contract: Address, encoded_args: Vec<u8>, value: U256, ) -> Result<ExecutionResult, RevertError>

Execute a contract function with ABI encoded arguments

Arguments

• callee - Contract caller address
• contract - Address of the contract to call
• encoded_args - ABI encoded function arguments and function selector
• value - Value attached to the transaction

pub fn direct_execute<T: SolCall>( &mut self, callee: Address, contract: Address, call_args: T, value: U256, ) -> Result<(<T as SolCall>::Return, Vec<Log>), RevertError>

Execute a contract function for a specific ABI

Arguments

• callee - Function caller address
• contract - Address of the contract
• call_args - Function arguments wrapped in a SolCall object
• value - Value attached to the transaction

pub fn direct_call_raw( &mut self, callee: Address, contract: Address, encoded_args: Vec<u8>, value: U256, ) -> Result<ExecutionResult, RevertError>

Call a contract function without committing changes

Arguments

• callee - Address of the function caller
• contract - Address of the contract
• encoded_args - ABI encoded function selector and arguments
• value - Value attached to the transaction

pub fn direct_call<T: SolCall>( &mut self, callee: Address, contract: Address, call_args: T, value: U256, ) -> Result<(<T as SolCall>::Return, Vec<Log>), RevertError>

Call a contract function without committing changes

Arguments

• callee - Address of the function caller
• contract - Address of the contract
• call_args - Function arguments wrapped in a SolCall object
• value - Value attached to the transaction

pub fn process_transactions<R: Rng>( &mut self, transactions: Vec<Transaction>, rng: &mut R, step: usize, )

Process a queue of Transaction

Arguments

• transactions - Vector of transactions
• step - Step number of the simulation

pub fn clear_events(&mut self)

Store events from the last block

Move events generated in the last block into the historical storage.