Struct FakeExt

pub struct FakeExt {

    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,
    /* private fields */
}

Fake externalities test structure.

Can’t do recursive calls.

Fields

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

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 with_wasm(self) -> Self

Alter fake externalities to allow wasm

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

Set chain ID

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], _parent_version: &U256, address: CreateContractAddress, _trap: bool, ) -> Result<ContractCreateResult, TrapKind>

Creates new contract.

fn call( &mut self, gas: &U256, sender_address: &Address, receive_address: &Address, value: Option<U256>, data: &[u8], code_address: &Address, _call_type: ActionType, _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 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.