Struct BasicBlockBuilder 

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

Available on crate feature evm only.

A block builder backed by a configured BlockExecutor.

Fields

executor: Executor

The block executor used to execute transactions.

evm_env: <F as BlockExecutorFactory>::EvmEnv

EVM environment used for execution.

transactions: Vec<Recovered<<N as NodePrimitives>::SignedTx>>

Transactions executed in this block.

ctx: <F as BlockExecutorFactory>::ExecutionCtx<'a>

Block execution context.

parent: &'a SealedHeader<<N as NodePrimitives>::BlockHeader>

Parent block header.

assembler: &'a Assembler

Block assembler.

Implementations

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

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

pub fn new( executor_factory: &'a F, assembler: &'a Assembler, evm: <F as BlockExecutorFactory>::Evm<'a>, evm_env: <F as BlockExecutorFactory>::EvmEnv, parent: &'a SealedHeader<<N as NodePrimitives>::BlockHeader>, ctx: <F as BlockExecutorFactory>::ExecutionCtx<'a>, ) -> BasicBlockBuilder<'a, F, <F as BlockExecutorFactory>::Executor<'a>, Assembler, N>

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 Executor: BlockExecutor<Transaction = <N as NodePrimitives>::SignedTx, Receipt = <N as NodePrimitives>::Receipt>, <Executor as BlockExecutor>::Evm: Evm<EvmTypes = <F as BlockExecutorFactory>::EvmTypes>, F: BlockExecutorFactory<Transaction = <N as NodePrimitives>::SignedTx, Receipt = <N as NodePrimitives>::Receipt>, Assembler: BlockAssembler<F, Block = <N as NodePrimitives>::Block>, N: NodePrimitives, <N as NodePrimitives>::SignedTx: Clone, <<Executor as BlockExecutor>::Evm as Evm>::Transaction: FromTxWithEncoded<<N as NodePrimitives>::SignedTx>,

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, ) -> &<BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::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<<BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::Executor>, f: impl FnOnce(&TxResultExt<<<<<BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::Executor as BlockExecutor>::Evm as Evm>::EvmTypes as EvmTypesHost>::TxResultExt>, 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<<BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::Executor>, f: impl FnOnce(&<<BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::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<<<BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::Primitives as NodePrimitives>::Receipt>) -> Result<Option<(FixedBytes<32>, 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 <BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::Executor

Provides mutable access to the inner BlockExecutor.

fn executor( &self, ) -> &<BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::Executor

Provides access to the inner BlockExecutor.

fn into_executor( self, ) -> <BasicBlockBuilder<'a, F, Executor, Assembler, N> as BlockBuilder>::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<(FixedBytes<32>, 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, Assembler, N> Debug for BasicBlockBuilder<'a, F, Executor, Assembler, N>

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

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

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.