Struct ExecutionOutcome

pub struct ExecutionOutcome<T = Receipt> {
    pub bundle: BundleState,
    pub receipts: Receipts<T>,
    pub first_block: BlockNumber,
    pub requests: Vec<Requests>,
}

Represents the outcome of block execution, including post-execution changes and reverts.

The ExecutionOutcome structure aggregates the state changes over an arbitrary number of blocks, capturing the resulting state, receipts, and requests following the execution.

Fields

bundle: BundleState

Bundle state with reverts.

receipts: Receipts<T>

The collection of receipts. Outer vector stores receipts for each block sequentially. The inner vector stores receipts ordered by transaction number.

If receipt is None it means it is pruned.

first_block: BlockNumber

First block of bundle state.

requests: Vec<Requests>

The collection of EIP-7685 requests. Outer vector stores requests for each block sequentially. The inner vector stores requests ordered by transaction number.

A transaction may have zero or more requests, so the length of the inner vector is not guaranteed to be the same as the number of transactions.

Implementations

impl<T> ExecutionOutcome<T>

pub const fn new( bundle: BundleState, receipts: Receipts<T>, first_block: BlockNumber, requests: Vec<Requests>, ) -> Self

Creates a new ExecutionOutcome.

This constructor initializes a new ExecutionOutcome instance with the provided bundle state, receipts, first block number, and EIP-7685 requests.

pub fn new_init( state_init: BundleStateInit, revert_init: RevertsInit, contracts_init: impl IntoIterator<Item = (B256, Bytecode)>, receipts: Receipts<T>, first_block: BlockNumber, requests: Vec<Requests>, ) -> Self

Creates a new ExecutionOutcome from initialization parameters.

This constructor initializes a new ExecutionOutcome instance using detailed initialization parameters.

pub const fn state(&self) -> &BundleState

Return revm bundle state.

pub fn state_mut(&mut self) -> &mut BundleState

Returns mutable revm bundle state.

pub fn set_first_block(&mut self, first_block: BlockNumber)

Set first block.

pub fn accounts_iter( &self, ) -> impl Iterator<Item = (Address, Option<&AccountInfo>)>

Return iterator over all accounts

pub fn bundle_accounts_iter( &self, ) -> impl Iterator<Item = (Address, &BundleAccount)>

Return iterator over all [BundleAccount]s in the bundle

pub fn account(&self, address: &Address) -> Option<Option<Account>>

Get account if account is known.

pub fn storage(&self, address: &Address, storage_key: U256) -> Option<U256>

Get storage if value is known.

This means that depending on status we can potentially return U256::ZERO.

pub fn bytecode(&self, code_hash: &B256) -> Option<Bytecode>

Return bytecode if known.

pub fn hash_state_slow(&self) -> HashedPostState

Returns [HashedPostState] for this execution outcome. See [HashedPostState::from_bundle_state] for more info.

pub fn block_number_to_index(&self, block_number: BlockNumber) -> Option<usize>

Transform block number to the index of block.

pub fn generic_receipts_root_slow( &self, block_number: BlockNumber, f: impl FnOnce(&[&T]) -> B256, ) -> Option<B256>

Returns the receipt root for all recorded receipts. Note: this function calculated Bloom filters for every receipt and created merkle trees of receipt. This is a expensive operation.

pub const fn receipts(&self) -> &Receipts<T>

Returns reference to receipts.

pub fn receipts_mut(&mut self) -> &mut Receipts<T>

Returns mutable reference to receipts.

pub fn receipts_by_block(&self, block_number: BlockNumber) -> &[Option<T>]

Return all block receipts

pub fn is_empty(&self) -> bool

Is execution outcome empty.

pub fn len(&self) -> usize

Number of blocks in the execution outcome.

pub const fn first_block(&self) -> BlockNumber

Return first block of the execution outcome

pub fn revert_to(&mut self, block_number: BlockNumber) -> bool

Revert the state to the given block number.

Returns false if the block number is not in the bundle state.

Note

The provided block number will stay inside the bundle state.

pub fn split_at(self, at: BlockNumber) -> (Option<Self>, Self)

where T: Clone,

Splits the block range state at a given block number. Returns two split states ([..at], [at..]). The plain state of the 2nd bundle state will contain extra changes that were made in state transitions belonging to the lower state.

Panics

If the target block number is not included in the state block range.

pub fn extend(&mut self, other: Self)

Extend one state from another

For state this is very sensitive operation and should be used only when we know that other state was build on top of this one. In most cases this would be true.

pub fn prepend_state(&mut self, other: BundleState)

Prepends present the state with the given BundleState. It adds changes from the given state but does not override any existing changes.

Reverts and receipts are not updated.

pub fn with_receipts(self, receipts: Receipts<T>) -> Self

Create a new instance with updated receipts.

pub fn with_requests(self, requests: Vec<Requests>) -> Self

Create a new instance with updated requests.

pub fn changed_accounts(&self) -> impl Iterator<Item = ChangedAccount> + '_

Returns an iterator over all changed accounts from the ExecutionOutcome.

This method filters the accounts to return only those that have undergone changes and maps them into ChangedAccount instances, which include the address, nonce, and balance.

impl<T: Receipt> ExecutionOutcome<T>

pub fn logs( &self, block_number: BlockNumber, ) -> Option<impl Iterator<Item = &Log>>

Returns an iterator over all block logs.

pub fn block_logs_bloom(&self, block_number: BlockNumber) -> Option<Bloom>

Return blocks logs bloom

pub fn receipts_root_slow(&self, _block_number: BlockNumber) -> Option<B256>

where T: ReceiptExt,

Returns the receipt root for all recorded receipts. Note: this function calculated Bloom filters for every receipt and created merkle trees of receipt. This is a expensive operation.

Trait Implementations

impl<T: Clone> Clone for ExecutionOutcome<T>

fn clone(&self) -> ExecutionOutcome<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ExecutionOutcome<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for ExecutionOutcome<T>

fn default() -> ExecutionOutcome<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for ExecutionOutcome<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<(BlockExecutionOutput<T>, u64)> for ExecutionOutcome<T>

fn from(value: (BlockExecutionOutput<T>, BlockNumber)) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for ExecutionOutcome<T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for ExecutionOutcome<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for ExecutionOutcome<T>

impl<T> StructuralPartialEq for ExecutionOutcome<T>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 176 bytes