Struct common_types::engines::machine::Executed

pub struct Executed<T, V> {
    pub exception: Option<Error>,
    pub gas: U256,
    pub gas_used: U256,
    pub refunded: U256,
    pub cumulative_gas_used: U256,
    pub logs: Vec<LogEntry>,
    pub contracts_created: Vec<Address>,
    pub output: Bytes,
    pub trace: Vec<T>,
    pub vm_trace: Option<V>,
    pub state_diff: Option<StateDiff>,
}

Transaction execution receipt.

Fields

exception: Option<Error>

True if the outer call/create resulted in an exceptional exit.

gas: U256

Gas paid up front for execution of transaction.

gas_used: U256

Gas used during execution of transaction.

refunded: U256

Gas refunded after the execution of transaction. To get gas that was required up front, add refunded and gas_used.

cumulative_gas_used: U256

Cumulative gas used in current block so far.

cumulative_gas_used = gas_used(t0) + gas_used(t1) + ... gas_used(tn)

where tn is current transaction.

logs: Vec<LogEntry>

Vector of logs generated by transaction.

contracts_created: Vec<Address>

Addresses of contracts created during execution of transaction. Ordered from earliest creation.

eg. sender creates contract A and A in constructor creates contract B

B creation ends first, and it will be the first element of the vector.

output: Bytes

Transaction output.

trace: Vec<T>

The trace of this transaction.

vm_trace: Option<V>

The VM trace of this transaction.

state_diff: Option<StateDiff>

The state diff, if we traced it.

Trait Implementations

impl<T: Clone, V: Clone> Clone for Executed<T, V>

fn clone(&self) -> Executed<T, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, V: Debug> Debug for Executed<T, V>

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

Formats the value using the given formatter.

impl<T: PartialEq, V: PartialEq> PartialEq<Executed<T, V>> for Executed<T, V>

fn eq(&self, other: &Executed<T, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Executed<T, V>) -> bool

This method tests for !=.

impl<T, V> StructuralPartialEq for Executed<T, V>