Struct revm::SubRoutine

pub struct SubRoutine { /* private fields */ }

Implementations

impl SubRoutine

pub fn new() -> SubRoutine

pub fn state(&mut self) -> &mut Map<H160, Account>

pub fn load_precompiles(&mut self, precompiles: Map<H160, AccountInfo>)

pub fn load_precompiles_default(&mut self, precompiles: &[H160])

pub fn finalize(&mut self) -> (Map<H160, Account>, Vec<Log>)

do cleanup and return modified state Do take that filthy stuff and return it back. Some states of Filth enum are internaly used but in output it can only be:

1. Dirty with empty Map (Map is internaly used). Only changed slots are returned in storage or
2. Destroyed if selfdestruct was called.

pub fn account(&self, address: H160) -> &Account

Use it with load_account function.

pub fn depth(&self) -> u64

pub fn set_code(&mut self, address: H160, code: Bytes, code_hash: H256)

use it only if you know that acc is hot

pub fn inc_nonce(&mut self, address: H160) -> u64

pub fn balance_add(&mut self, address: H160, payment: U256) -> bool

pub fn balance_sub(&mut self, address: H160, payment: U256) -> bool

pub fn transfer<DB: Database>(
    &mut self,
    from: H160,
    to: H160,
    value: U256,
    db: &mut DB
) -> Result<(bool, bool), Return>

pub fn new_contract_acc<DB: Database>(
    &mut self,
    address: H160,
    is_precompile: bool,
    db: &mut DB
) -> bool

return if it has collition of addresses

pub fn create_checkpoint(&mut self) -> SubRoutineCheckpoint

pub fn checkpoint_commit(&mut self)

pub fn checkpoint_revert(&mut self, checkpoint: SubRoutineCheckpoint)

pub fn selfdestruct<DB: Database>(
    &mut self,
    address: H160,
    target: H160,
    db: &mut DB
) -> SelfDestructResult

transfer balance from address to target. Check if target exist/is_cold

pub fn load_account<DB: Database>(&mut self, address: H160, db: &mut DB) -> bool

load account into memory. return if it is cold or hot accessed

pub fn load_account_exist<DB: Database>(
    &mut self,
    address: H160,
    db: &mut DB
) -> (bool, bool)

pub fn load_code<DB: Database>(
    &mut self,
    address: H160,
    db: &mut DB
) -> (&mut Account, bool)

pub fn sload<DB: Database>(
    &mut self,
    address: H160,
    index: U256,
    db: &mut DB
) -> (U256, bool)

pub fn sstore<DB: Database>(
    &mut self,
    address: H160,
    index: U256,
    new: U256,
    db: &mut DB
) -> (U256, U256, U256, bool)

account should already be present in our state. returns (original,present,new) slot

pub fn log(&mut self, log: Log)

push log into subroutine

Trait Implementations

impl Default for SubRoutine

fn default() -> Self

Returns the “default value” for a type.