Struct vm::tests::FakeExt

pub struct FakeExt {

    pub initial_store: HashMap<H256, H256>,
    pub store: HashMap<H256, H256>,
    pub suicides: HashSet<Address>,
    pub calls: HashSet<FakeCall>,
    pub sstore_clears: i128,
    pub depth: usize,
    pub blockhashes: HashMap<U256, H256>,
    pub codes: HashMap<Address, Arc<Bytes>>,
    pub logs: Vec<FakeLogEntry>,
    pub info: EnvInfo,
    pub schedule: Schedule,
    pub balances: HashMap<Address, U256>,
    pub tracing: bool,
    pub is_static: bool,
    pub access_list: AccessList,
    /* private fields */
}

Fake externalities test structure.

Can’t do recursive calls.

Fields

initial_store: HashMap<H256, H256>

store: HashMap<H256, H256>

suicides: HashSet<Address>

calls: HashSet<FakeCall>

sstore_clears: i128

depth: usize

blockhashes: HashMap<U256, H256>

codes: HashMap<Address, Arc<Bytes>>

logs: Vec<FakeLogEntry>

info: EnvInfo

schedule: Schedule

balances: HashMap<Address, U256>

tracing: bool

is_static: bool

access_list: AccessList

Implementations

impl FakeExt

pub fn new() -> Self

New fake externalities

pub fn new_byzantium() -> Self

New fake externalities with byzantium schedule rules

pub fn new_constantinople() -> Self

New fake externalities with constantinople schedule rules

pub fn new_istanbul() -> Self

New fake externalities with Istanbul schedule rules

pub fn new_berlin(from: Address, to: Address, builtins: &[Address]) -> Self

New fake externalities with Berlin schedule rules

pub fn new_london(from: Address, to: Address, builtins: &[Address]) -> Self

New fake externalities with London schedule rules

pub fn with_wasm(self) -> Self

Alter fake externalities to allow wasm

pub fn with_chain_id(self, chain_id: u64) -> Self

Set chain ID

pub fn set_initial_storage(&mut self, key: H256, value: H256)

pub fn prefill(&mut self, data: &[u64])

Fill the storage before the transaction with data, i. e. set both original and current values, beginning from address 0.

Trait Implementations

impl Default for FakeExt

fn default() -> FakeExt

Returns the “default value” for a type.

impl Ext for FakeExt

fn initial_storage_at(&self, key: &H256) -> Result<H256>

Returns the storage value for a given key if reversion happens on the current transaction.

fn storage_at(&self, key: &H256) -> Result<H256>

Returns a value for given key.

fn set_storage(&mut self, key: H256, value: H256) -> Result<()>

Stores a value for given key.

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

Determine whether an account exists.

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

Determine whether an account exists and is not null (zero balance/nonce, no code).

fn origin_balance(&self) -> Result<U256>

Balance of the origin account.

fn balance(&self, address: &Address) -> Result<U256>

Returns address balance.

fn blockhash(&mut self, number: &U256) -> H256

Returns the hash of one of the 256 most recent complete blocks.

fn create(
    &mut self,
    gas: &U256,
    value: &U256,
    code: &[u8],
    address: CreateContractAddress,
    _trap: bool
) -> Result<ContractCreateResult, TrapKind>

Creates new contract.

fn calc_address(
    &self,
    _code: &[u8],
    _address: CreateContractAddress
) -> Option<Address>

Returns the address that will be created in the create call

fn call(
    &mut self,
    gas: &U256,
    sender_address: &Address,
    receive_address: &Address,
    value: Option<U256>,
    data: &[u8],
    code_address: &Address,
    _call_type: CallType,
    _trap: bool
) -> Result<MessageCallResult, TrapKind>

Message call.

fn extcode(&self, address: &Address) -> Result<Option<Arc<Bytes>>>

Returns code at given address

fn extcodesize(&self, address: &Address) -> Result<Option<usize>>

Returns code size at given address

fn extcodehash(&self, address: &Address) -> Result<Option<H256>>

Returns code hash at given address

fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> Result<()>

Creates log entry with given topics and data

fn ret(
    self,
    _gas: &U256,
    _data: &ReturnData,
    _apply_state: bool
) -> Result<U256>

Should be called when transaction calls RETURN opcode. Returns gas_left if cost of returning the data is not too high.

fn suicide(&mut self, refund_address: &Address) -> Result<()>

Should be called when contract commits suicide. Address to which funds should be refunded.

fn schedule(&self) -> &Schedule

Returns schedule.

fn env_info(&self) -> &EnvInfo

Returns environment info.

fn chain_id(&self) -> u64

Returns the chain ID of the blockchain

fn depth(&self) -> usize

Returns current depth of execution.

fn is_static(&self) -> bool

Check if running in static context.

fn add_sstore_refund(&mut self, value: usize)

Increments sstore refunds counter.

fn sub_sstore_refund(&mut self, value: usize)

Decrements sstore refunds counter.

fn trace_next_instruction(
    &mut self,
    _pc: usize,
    _instruction: u8,
    _gas: U256
) -> bool

Decide if any more operations should be traced. Passthrough for the VM trace.

fn al_is_enabled(&self) -> bool

Returns if the list is enabled

fn al_contains_storage_key(&self, address: &Address, key: &H256) -> bool

Checks if contains an storage key

fn al_insert_storage_key(&mut self, address: Address, key: H256)

Inserts an storage key into the list

fn al_contains_address(&self, address: &Address) -> bool

Checks if contains an address

fn al_insert_address(&mut self, address: Address)

Inserts an address into the list

fn trace_prepare_execute(
    &mut self,
    _pc: usize,
    _instruction: u8,
    _gas_cost: U256,
    _mem_written: Option<(usize, usize)>,
    _store_written: Option<(U256, U256)>
)

Prepare to trace an operation. Passthrough for the VM trace. For each call of trace_prepare_execute either trace_failed or trace_executed MUST be called.

fn trace_failed(&mut self)

Trace the execution failure of a single instruction.

fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem: &[u8])

Trace the finalised execution of a single instruction.