Struct Context 

pub struct Context<BLOCK = BlockEnv, TX = TxEnv, CFG = CfgEnv, DB: Database = EmptyDB, JOURNAL: JournalTr<Database = DB> = Journal<DB>, CHAIN = (), LOCAL: LocalContextTr = LocalContext> {
    pub block: BLOCK,
    pub tx: TX,
    pub cfg: CFG,
    pub journaled_state: JOURNAL,
    pub chain: CHAIN,
    pub local: LOCAL,
    pub error: Result<(), ContextError<DB::Error>>,
}

EVM context contains data that EVM needs for execution.

Fields

block: BLOCK

Block information.

tx: TX

Transaction information.

cfg: CFG

Configurations.

journaled_state: JOURNAL

EVM State with journaling support and database.

chain: CHAIN

Inner context.

local: LOCAL

Local context that is filled by execution.

error: Result<(), ContextError<DB::Error>>

Error that happened during execution.

Implementations

impl<BLOCK: Block + Default, TX: Transaction + Default, DB: Database, JOURNAL: JournalTr<Database = DB>, CHAIN: Default, LOCAL: LocalContextTr + Default> Context<BLOCK, TX, CfgEnv, DB, JOURNAL, CHAIN, LOCAL>

pub fn new(db: DB, spec: SpecId) -> Self

Creates a new context with a new database type.

This will create a new Journal object.

impl<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL> Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL>

where BLOCK: Block, TX: Transaction, CFG: Cfg, DB: Database, JOURNAL: JournalTr<Database = DB>, LOCAL: LocalContextTr,

pub fn with_new_journal<OJOURNAL: JournalTr<Database = DB>>( self, journal: OJOURNAL, ) -> Context<BLOCK, TX, CFG, DB, OJOURNAL, CHAIN, LOCAL>

Creates a new context with a new journal type. New journal needs to have the same database type.

pub fn with_db<ODB: Database>( self, db: ODB, ) -> Context<BLOCK, TX, CFG, ODB, Journal<ODB>, CHAIN, LOCAL>

Creates a new context with a new database type.

This will create a new Journal object.

pub fn with_ref_db<ODB: DatabaseRef>( self, db: ODB, ) -> Context<BLOCK, TX, CFG, WrapDatabaseRef<ODB>, Journal<WrapDatabaseRef<ODB>>, CHAIN, LOCAL>

Creates a new context with a new DatabaseRef type.

pub fn with_block<OB: Block>( self, block: OB, ) -> Context<OB, TX, CFG, DB, JOURNAL, CHAIN, LOCAL>

Creates a new context with a new block type.

pub fn with_tx<OTX: Transaction>( self, tx: OTX, ) -> Context<BLOCK, OTX, CFG, DB, JOURNAL, CHAIN, LOCAL>

Creates a new context with a new transaction type.

pub fn with_chain<OC>( self, chain: OC, ) -> Context<BLOCK, TX, CFG, DB, JOURNAL, OC, LOCAL>

Creates a new context with a new chain type.

pub fn with_cfg<OCFG: Cfg>( self, cfg: OCFG, ) -> Context<BLOCK, TX, OCFG, DB, JOURNAL, CHAIN, LOCAL>

Creates a new context with a new chain type.

pub fn with_local<OL: LocalContextTr>( self, local: OL, ) -> Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, OL>

Creates a new context with a new local context type.

pub fn modify_cfg_chained<F>(self, f: F) -> Self

where F: FnOnce(&mut CFG),

Modifies the context configuration.

pub fn modify_block_chained<F>(self, f: F) -> Self

where F: FnOnce(&mut BLOCK),

Modifies the context block.

pub fn modify_tx_chained<F>(self, f: F) -> Self

where F: FnOnce(&mut TX),

Modifies the context transaction.

pub fn modify_chain_chained<F>(self, f: F) -> Self

where F: FnOnce(&mut CHAIN),

Modifies the context chain.

pub fn modify_db_chained<F>(self, f: F) -> Self

where F: FnOnce(&mut DB),

Modifies the context database.

pub fn modify_journal_chained<F>(self, f: F) -> Self

where F: FnOnce(&mut JOURNAL),

Modifies the context journal.

pub fn modify_block<F>(&mut self, f: F)

where F: FnOnce(&mut BLOCK),

Modifies the context block.

pub fn modify_tx<F>(&mut self, f: F)

where F: FnOnce(&mut TX),

Modifies the context transaction.

pub fn modify_cfg<F>(&mut self, f: F)

where F: FnOnce(&mut CFG),

Modifies the context configuration.

pub fn modify_chain<F>(&mut self, f: F)

where F: FnOnce(&mut CHAIN),

Modifies the context chain.

pub fn modify_db<F>(&mut self, f: F)

where F: FnOnce(&mut DB),

Modifies the context database.

pub fn modify_journal<F>(&mut self, f: F)

where F: FnOnce(&mut JOURNAL),

Modifies the context journal.

pub fn modify_local<F>(&mut self, f: F)

where F: FnOnce(&mut LOCAL),

Modifies the local context.

Trait Implementations

impl<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL> Clone for Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL>

where BLOCK: Clone, CFG: Clone, CHAIN: Clone, TX: Clone, DB: Clone + Database, JOURNAL: Clone + JournalTr<Database = DB>, <DB as Database>::Error: Clone, LOCAL: Clone + LocalContextTr,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<BLOCK: Block, TX: Transaction, DB: Database, CFG: Cfg, JOURNAL: JournalTr<Database = DB>, CHAIN, LOCAL: LocalContextTr> ContextSetters for Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL>

fn set_tx(&mut self, tx: Self::Tx)

Set the transaction

fn set_block(&mut self, block: Self::Block)

Set the block

impl<BLOCK: Block, TX: Transaction, DB: Database, CFG: Cfg, JOURNAL: JournalTr<Database = DB>, CHAIN, LOCAL: LocalContextTr> ContextTr for Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL>

type Block = BLOCK

Block type

type Tx = TX

Transaction type

type Cfg = CFG

Configuration type

type Db = DB

Database type

type Journal = JOURNAL

Journal type

type Chain = CHAIN

Chain type

type Local = LOCAL

Local context type

fn all( &self, ) -> (&Self::Block, &Self::Tx, &Self::Cfg, &Self::Db, &Self::Journal, &Self::Chain, &Self::Local)

Get all contexts

fn all_mut( &mut self, ) -> (&Self::Block, &Self::Tx, &Self::Cfg, &mut Self::Journal, &mut Self::Chain, &mut Self::Local)

Get all contexts mutably

fn error( &mut self, ) -> &mut Result<(), ContextError<<Self::Db as Database>::Error>>

Get the error

fn tx(&self) -> &Self::Tx

Get the transaction

fn block(&self) -> &Self::Block

Get the block

fn cfg(&self) -> &Self::Cfg

Get the configuration

fn journal(&self) -> &Self::Journal

Get the journal

fn journal_mut(&mut self) -> &mut Self::Journal

Get the journal mutably

fn journal_ref(&self) -> &Self::Journal

Get the journal reference

fn db(&self) -> &Self::Db

Get the database

fn db_mut(&mut self) -> &mut Self::Db

Get the database mutably

fn db_ref(&self) -> &Self::Db

Get the database reference

fn chain(&self) -> &Self::Chain

Get the chain

fn chain_mut(&mut self) -> &mut Self::Chain

Get the chain mutably

fn chain_ref(&self) -> &Self::Chain

Get the chain reference

fn local(&self) -> &Self::Local

Get the local context

fn local_mut(&mut self) -> &mut Self::Local

Get the local context mutably

fn local_ref(&self) -> &Self::Local

Get the local context reference

fn tx_journal_mut(&mut self) -> (&Self::Tx, &mut Self::Journal)

Get the transaction and journal. It is used to efficiently load access list into journal without copying them from transaction.

fn tx_block_cfg_journal_mut( &mut self, ) -> (&Self::Tx, &Self::Block, &Self::Cfg, &mut Self::Journal)

Get the transaction, configuration and mutable journal.

fn tx_local_mut(&mut self) -> (&Self::Tx, &mut Self::Local)

Get the transaction and local context. It is used to efficiently load initcode into local context without copying them from transaction.

impl<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL> Debug for Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL>

where BLOCK: Debug, CFG: Debug, CHAIN: Debug, TX: Debug, DB: Debug + Database, JOURNAL: Debug + JournalTr<Database = DB>, <DB as Database>::Error: Debug, LOCAL: Debug + LocalContextTr,

fn fmt(&self, __f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<BLOCK: Block, TX: Transaction, CFG: Cfg, DB: Database, JOURNAL: JournalTr<Database = DB>, CHAIN, LOCAL: LocalContextTr> Host for Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, LOCAL>

fn tload(&mut self, address: Address, index: StorageKey) -> StorageValue

Gets the transient storage value of address at index.

fn tstore(&mut self, address: Address, index: StorageKey, value: StorageValue)

Sets the transient storage value of address at index.

fn log(&mut self, log: Log)

Emits a log owned by address with given LogData.

fn selfdestruct( &mut self, address: Address, target: Address, ) -> Option<StateLoad<SelfDestructResult>>

Marks address to be deleted, with funds transferred to target.

fn basefee(&self) -> U256

Block basefee, calls ContextTr::block().basefee()

fn blob_gasprice(&self) -> U256

Block blob gasprice, calls ContextTr::block().blob_gasprice()

fn gas_limit(&self) -> U256

Block gas limit, calls ContextTr::block().gas_limit()

fn difficulty(&self) -> U256

Block difficulty, calls ContextTr::block().difficulty()

fn prevrandao(&self) -> Option<U256>

Block prevrandao, calls ContextTr::block().prevrandao()

fn block_number(&self) -> U256

Block number, calls ContextTr::block().number()

fn timestamp(&self) -> U256

Block timestamp, calls ContextTr::block().timestamp()

fn beneficiary(&self) -> Address

Block beneficiary, calls ContextTr::block().beneficiary()

fn chain_id(&self) -> U256

Chain id, calls ContextTr::cfg().chain_id()

fn effective_gas_price(&self) -> U256

Transaction effective gas price, calls ContextTr::tx().effective_gas_price(basefee as u128)

fn caller(&self) -> Address

Transaction caller, calls ContextTr::tx().caller()

fn blob_hash(&self, number: usize) -> Option<U256>

Transaction blob hash, calls ContextTr::tx().blob_hash(number)

fn max_initcode_size(&self) -> usize

Max initcode size, calls ContextTr::cfg().max_code_size().saturating_mul(2)

fn block_hash(&mut self, requested_number: u64) -> Option<B256>

Block hash, calls ContextTr::journal_mut().db().block_hash(number)

fn sstore_skip_cold_load( &mut self, address: Address, key: StorageKey, value: StorageValue, skip_cold_load: bool, ) -> Result<StateLoad<SStoreResult>, LoadError>

Sstore with optional fetch from database. Return none if the value is cold or if there is db error.

fn sload_skip_cold_load( &mut self, address: Address, key: StorageKey, skip_cold_load: bool, ) -> Result<StateLoad<StorageValue>, LoadError>

Sload with optional fetch from database. Return none if the value is cold or if there is db error.

fn load_account_info_skip_cold_load( &mut self, address: Address, load_code: bool, skip_cold_load: bool, ) -> Result<AccountInfoLoad<'_>, LoadError>

Main function to load account info.

fn sstore( &mut self, address: Address, key: Uint<256, 4>, value: Uint<256, 4>, ) -> Option<StateLoad<SStoreResult>>

Sstore, calls ContextTr::journal_mut().sstore(address, key, value)

fn sload( &mut self, address: Address, key: Uint<256, 4>, ) -> Option<StateLoad<Uint<256, 4>>>

Sload, calls ContextTr::journal_mut().sload(address, key)

fn balance(&mut self, address: Address) -> Option<StateLoad<Uint<256, 4>>>

Balance, calls ContextTr::journal_mut().load_account(address)

fn load_account_delegated( &mut self, address: Address, ) -> Option<StateLoad<AccountLoad>>

Load account delegated, calls ContextTr::journal_mut().load_account_delegated(address)

fn load_account_code(&mut self, address: Address) -> Option<StateLoad<Bytes>>

Load account code, calls Host::load_account_info_skip_cold_load with load_code set to false.

fn load_account_code_hash( &mut self, address: Address, ) -> Option<StateLoad<FixedBytes<32>>>

Load account code hash, calls Host::load_account_info_skip_cold_load with load_code set to false.