Struct BasicBlockBuilder 

pub struct BasicBlockBuilder<'a, F, Executor, Assembler, N>
where
    F: BlockExecutorFactory + 'a,
    N: NodePrimitives,
{
    pub executor: Executor,
    pub evm_env: F::EvmEnv,
    pub transactions: Vec<Recovered<TxTy<N>>>,
    pub ctx: F::ExecutionCtx<'a>,
    pub parent: &'a SealedHeader<HeaderTy<N>>,
    pub assembler: &'a Assembler,
}

A block builder backed by a configured BlockExecutor.

Fields

executor: Executor

The block executor used to execute transactions.

evm_env: F::EvmEnv

EVM environment used for execution.

transactions: Vec<Recovered<TxTy<N>>>

Transactions executed in this block.

ctx: F::ExecutionCtx<'a>

Block execution context.

parent: &'a SealedHeader<HeaderTy<N>>

Parent block header.

assembler: &'a Assembler

Block assembler.

Implementations

impl<'a, F, Assembler, N> BasicBlockBuilder<'a, F, F::Executor<'a>, Assembler, N>

where F: BlockExecutorFactory<Transaction = TxTy<N>, Receipt = ReceiptTy<N>> + 'a, Assembler: BlockAssembler<F, Block = N::Block> + 'a, N: NodePrimitives,

pub fn new( executor_factory: &'a F, assembler: &'a Assembler, evm: F::Evm<'a>, evm_env: F::EvmEnv, parent: &'a SealedHeader<HeaderTy<N>>, ctx: F::ExecutionCtx<'a>, ) -> Self

Creates a block builder that accumulates bundle state in the execution output.

Trait Implementations

impl<'a, F, Executor, Assembler, N> BlockBuilder for BasicBlockBuilder<'a, F, Executor, Assembler, N>

where F: BlockExecutorFactory<Transaction = TxTy<N>, Receipt = ReceiptTy<N>>, Executor: BlockExecutor<Transaction = TxTy<N>, Receipt = ReceiptTy<N>, Evm: Evm<EvmTypes = F::EvmTypes>>, Assembler: BlockAssembler<F, Block = N::Block>, N: NodePrimitives, TxTy<N>: Clone, <<Executor as BlockExecutor>::Evm as Evm>::Transaction: FromTxWithEncoded<TxTy<N>>,

type Primitives = N

The primitive types used by the inner BlockExecutor.

type Executor = Executor

Inner block executor.

type EvmEnv = <F as BlockExecutorFactory>::EvmEnv

EVM environment used for block execution.

fn evm_env(&self) -> &Self::EvmEnv

Returns the EVM environment used for block execution.

fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError>

Applies pre-execution block changes.

fn execute_transaction_with_commit_condition( &mut self, tx: impl ExecutorTx<Self::Executor>, f: impl FnOnce(&TxResult<<<Self::Executor as BlockExecutor>::Evm as Evm>::EvmTypes>, TxStateChanges<'_>) -> CommitChanges, ) -> Result<Option<GasOutput>, BlockExecutionError>

Executes a transaction, exposes its borrowed execution result and state changes to f, and saves it for block assembly only if committed.

fn execute_transaction_with_result_closure( &mut self, tx: impl ExecutorTx<Self::Executor>, f: impl FnOnce(&<Self::Executor as BlockExecutor>::TransactionResultWithState), ) -> Result<GasOutput, BlockExecutionError>

Executes a transaction, invokes f with the detached result and state changes, and saves it for block assembly.

fn finish_with_state_root( self, state_provider: impl StateProvider, state_root: impl FnOnce(&BlockExecutionOutput<ReceiptTy<Self::Primitives>>) -> Result<Option<(B256, TrieUpdates)>, BlockExecutionError>, ) -> Result<BlockBuilderOutcome<N>, BlockExecutionError>

Completes block building, resolving an optional state root after execution is finalized.

fn set_state_hook( &mut self, hook: impl FnMut(StateUpdate) + Send + 'static, ) -> bool

Sets a hook for transaction state updates emitted while building a block.

fn executor_mut(&mut self) -> &mut Self::Executor

Provides mutable access to the inner BlockExecutor.

fn executor(&self) -> &Self::Executor

Provides access to the inner BlockExecutor.

fn into_executor(self) -> Self::Executor

Consumes the type and returns the underlying executor.

fn execute_transaction( &mut self, tx: impl ExecutorTx<Self::Executor>, ) -> Result<GasOutput, BlockExecutionError>

Executes a transaction and saves it for block assembly.

fn finish( self, state_provider: impl StateProvider, state_root_precomputed: Option<(B256, TrieUpdates)>, ) -> Result<BlockBuilderOutcome<Self::Primitives>, BlockExecutionError>

Completes block building.

fn evm_mut(&mut self) -> &mut <Self::Executor as BlockExecutor>::Evm

Provides mutable access to the underlying EVM.

fn evm(&self) -> &<Self::Executor as BlockExecutor>::Evm

Provides access to the underlying EVM.

impl<'a, F, Executor: Debug, Assembler: Debug, N> Debug for BasicBlockBuilder<'a, F, Executor, Assembler, N>

where F: BlockExecutorFactory + 'a + Debug, N: NodePrimitives + Debug, F::EvmEnv: Debug, F::ExecutionCtx<'a>: Debug,

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

Formats the value using the given formatter.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.