Struct ExecutedBlock 

pub struct ExecutedBlock<N: NodePrimitives = EthPrimitives> {
    pub recovered_block: Arc<RecoveredBlock<N::Block>>,
    pub execution_output: Arc<ExecutionOutcome<N::Receipt>>,
    pub trie_data: DeferredTrieData,
}

Represents an executed block stored in-memory.

Fields

recovered_block: Arc<RecoveredBlock<N::Block>>

Recovered Block

execution_output: Arc<ExecutionOutcome<N::Receipt>>

Block’s execution outcome.

trie_data: DeferredTrieData

Deferred trie data produced by execution.

This allows deferring the computation of the trie data which can be expensive. The data can be populated asynchronously after the block was validated.

Implementations

impl<N: NodePrimitives> ExecutedBlock<N>

pub fn new( recovered_block: Arc<RecoveredBlock<N::Block>>, execution_output: Arc<ExecutionOutcome<N::Receipt>>, trie_data: ComputedTrieData, ) -> Self

Create a new ExecutedBlock with already-computed trie data.

Use this constructor when trie data is available immediately (e.g., sequencers, payload builders). This is the safe default path.

pub const fn with_deferred_trie_data( recovered_block: Arc<RecoveredBlock<N::Block>>, execution_output: Arc<ExecutionOutcome<N::Receipt>>, trie_data: DeferredTrieData, ) -> Self

Create a new ExecutedBlock with deferred trie data.

This is useful if the trie data is populated somewhere else, e.g. asynchronously after the block was validated.

The DeferredTrieData handle allows expensive trie operations (sorting hashed state, sorting trie updates, and building the accumulated trie input overlay) to be performed outside the critical validation path. This can improve latency for time-sensitive operations like block validation.

If the data hasn’t been populated when Self::trie_data() is called, computation occurs synchronously from stored inputs, so there is no blocking or deadlock risk.

Use Self::new() instead when trie data is already computed and available immediately.

pub fn sealed_block(&self) -> &SealedBlock<N::Block>

Returns a reference to an inner [SealedBlock]

pub fn recovered_block(&self) -> &RecoveredBlock<N::Block>

Returns a reference to [RecoveredBlock]

pub fn execution_outcome(&self) -> &ExecutionOutcome<N::Receipt>

Returns a reference to the block’s execution outcome

pub fn trie_data(&self) -> ComputedTrieData

Returns the trie data, computing it synchronously if not already cached.

Uses OnceLock::get_or_init internally:

• If already computed: returns cached result immediately
• If not computed: first caller computes, others wait for that result

pub fn trie_data_handle(&self) -> DeferredTrieData

Returns a clone of the deferred trie data handle.

A handle is a lightweight reference that can be passed to descendants without forcing trie data to be computed immediately. The actual work runs when wait_cloned() is called by a consumer (e.g. when merging overlays).

pub fn hashed_state(&self) -> Arc<HashedPostStateSorted>

Returns the hashed state result of the execution outcome.

May compute trie data synchronously if the deferred task hasn’t completed.

pub fn trie_updates(&self) -> Arc<TrieUpdatesSorted>

Returns the trie updates resulting from the execution outcome.

May compute trie data synchronously if the deferred task hasn’t completed.

pub fn trie_input(&self) -> Option<Arc<TrieInputSorted>>

Returns the trie input anchored to the persisted ancestor.

May compute trie data synchronously if the deferred task hasn’t completed.

pub fn anchor_hash(&self) -> Option<B256>

Returns the anchor hash of the trie input, if present.

pub fn block_number(&self) -> BlockNumber

Returns a [BlockNumber] of the block.

Trait Implementations

impl<N: Clone + NodePrimitives> Clone for ExecutedBlock<N>

where N::Block: Clone, N::Receipt: Clone,

fn clone(&self) -> ExecutedBlock<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug + NodePrimitives> Debug for ExecutedBlock<N>

where N::Block: Debug, N::Receipt: Debug,

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

Formats the value using the given formatter.

impl<N: NodePrimitives> Default for ExecutedBlock<N>

fn default() -> Self

Returns the “default value” for a type.

impl<N: NodePrimitives> PartialEq for ExecutedBlock<N>

fn eq(&self, other: &Self) -> 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.

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: 24 bytes