Struct BlockchainTree

pub struct BlockchainTree<N, E>
where
    N: NodeTypesWithDB,
{ /* private fields */ }

A Tree of chains.

The flowchart represents all the states a block can have inside the tree.

• Green blocks belong to the canonical chain and are saved inside the database.
• Pending blocks and sidechains are found in-memory inside BlockchainTree.

Both pending chains and sidechains have the same mechanisms, the only difference is when they get committed to the database.

For pending, it is an append operation, but for sidechains they need to move the current canonical blocks to the tree (by removing them from the database), and commit the sidechain blocks to the database to become the canonical chain (reorg).

include_mmd!("docs/mermaid/tree.mmd“)

Main functions

• BlockchainTree::insert_block: Connect a block to a chain, execute it, and if valid, insert the block into the tree.
• BlockchainTree::finalize_block: Remove chains that branch off of the now finalized block.
• BlockchainTree::make_canonical: Check if we have the hash of a block that is the current canonical head and commit it to db.

Implementations

impl<N, E> BlockchainTree<N, E>

where N: NodeTypesWithDB,

pub fn subscribe_canon_state(&self) -> Receiver<CanonStateNotification>

Subscribe to new blocks events.

Note: Only canonical blocks are emitted by the tree.

pub fn canon_state_notification_sender(&self) -> Sender<CanonStateNotification>

Returns a clone of the sender for the canonical state notifications.

impl<N, E> BlockchainTree<N, E>

where N: TreeNodeTypes, E: BlockExecutorProvider,

pub fn new( externals: TreeExternals<N, E>, config: BlockchainTreeConfig, ) -> Result<BlockchainTree<N, E>, ProviderError>

Builds the blockchain tree for the node.

This method configures the blockchain tree, which is a critical component of the node, responsible for managing the blockchain state, including blocks, transactions, and receipts. It integrates with the consensus mechanism and the EVM for executing transactions.

Parameters

• externals: External components required by the blockchain tree:
  • provider_factory: A factory for creating various blockchain-related providers, such as for accessing the database or static files.
  • consensus: The consensus configuration, which defines how the node reaches agreement on the blockchain state with other nodes.
  • evm_config: The EVM (Ethereum Virtual Machine) configuration, which affects how smart contracts and transactions are executed. Proper validation of this configuration is crucial for the correct execution of transactions.
• tree_config: Configuration for the blockchain tree, including any parameters that affect its structure or performance.

pub fn with_sync_metrics_tx( self, metrics_tx: UnboundedSender<MetricEvent>, ) -> BlockchainTree<N, E>

Set the sync metric events sender.

A transmitter for sending synchronization metrics. This is used for monitoring the node’s synchronization process with the blockchain network.

pub const fn block_indices(&self) -> &BlockIndices

Expose internal indices of the BlockchainTree.

pub fn sidechain_block_by_hash( &self, block_hash: FixedBytes<32>, ) -> Option<&SealedBlock>

Returns the block with matching hash from any side-chain.

Caution: This will not return blocks from the canonical chain.

pub fn block_with_senders_by_hash( &self, block_hash: FixedBytes<32>, ) -> Option<&SealedBlockWithSenders>

Returns the block with matching hash from any side-chain.

Caution: This will not return blocks from the canonical chain.

pub fn receipts_by_block_hash( &self, block_hash: FixedBytes<32>, ) -> Option<Vec<&Receipt>>

Returns the block’s receipts with matching hash from any side-chain.

Caution: This will not return blocks from the canonical chain.

pub fn pending_block(&self) -> Option<&SealedBlock>

Returns the block that’s considered the Pending block, if it exists.

pub fn post_state_data( &self, block_hash: FixedBytes<32>, ) -> Option<ExecutionData>

Return items needed to execute on the pending state. This includes: * BlockHash of canonical block that chain connects to. Needed for creating database provider for the rest of the state. * BundleState changes that happened at the asked block_hash * BTreeMap<BlockNumber,BlockHash> list of past pending and canonical hashes, That are needed for evm BLOCKHASH opcode. Return none if: * block unknown. * chain_id not present in state. * there are no parent hashes stored.

pub fn get_buffered_block( &self, hash: &FixedBytes<32>, ) -> Option<&SealedBlockWithSenders>

Checks the block buffer for the given block.

pub fn lowest_buffered_ancestor( &self, hash: &FixedBytes<32>, ) -> Option<&SealedBlockWithSenders>

Gets the lowest ancestor for the given block in the block buffer.

pub fn insert_block_without_senders( &mut self, block: SealedBlock, ) -> Result<InsertPayloadOk, InsertBlockError>

Insert a new block into the tree.

Note

This recovers transaction signers (unlike BlockchainTree::insert_block).

pub fn buffer_block( &mut self, block: SealedBlockWithSenders, ) -> Result<(), InsertBlockError>

Insert block for future execution.

Returns an error if the block is invalid.

pub fn insert_block( &mut self, block: SealedBlockWithSenders, block_validation_kind: BlockValidationKind, ) -> Result<InsertPayloadOk, InsertBlockError>

Insert a block (with recovered senders) into the tree.

Returns the BlockStatus on success:

• The block is already part of a sidechain in the tree, or
• The block is already part of the canonical chain, or
• The parent is part of a sidechain in the tree, and we can fork at this block, or
• The parent is part of the canonical chain, and we can fork at this block

Otherwise, an error is returned, indicating that neither the block nor its parent are part of the chain or any sidechains.

This means that if the block becomes canonical, we need to fetch the missing blocks over P2P.

If the BlockValidationKind::SkipStateRootValidation variant is provided the state root is not validated.

Note

If the senders have not already been recovered, call BlockchainTree::insert_block_without_senders instead.

pub fn remove_old_blocks(&mut self, block: u64)

Discard all blocks that precede block number from the buffer.

pub fn finalize_block( &mut self, finalized_block: u64, ) -> Result<(), ProviderError>

Finalize blocks up until and including finalized_block, and remove them from the tree.

pub fn connect_buffered_blocks_to_canonical_hashes_and_finalize( &mut self, last_finalized_block: u64, ) -> Result<(), ProviderError>

Reads the last N canonical hashes from the database and updates the block indices of the tree by attempting to connect the buffered blocks to canonical hashes.

N is the maximum of max_reorg_depth and the number of block hashes needed to satisfy the BLOCKHASH opcode in the EVM.

Note

This finalizes last_finalized_block prior to reading the canonical hashes (using BlockchainTree::finalize_block).

pub fn update_block_hashes( &mut self, ) -> Result<BTreeMap<u64, FixedBytes<32>>, ProviderError>

Update all block hashes. iterate over present and new list of canonical hashes and compare them. Remove all mismatches, disconnect them and removes all chains.

pub fn update_block_hashes_and_clear_buffered( &mut self, ) -> Result<BTreeMap<u64, FixedBytes<32>>, ProviderError>

Update all block hashes. iterate over present and new list of canonical hashes and compare them. Remove all mismatches, disconnect them, removes all chains and clears all buffered blocks before the tip.

pub fn connect_buffered_blocks_to_canonical_hashes( &mut self, ) -> Result<(), ProviderError>

Reads the last N canonical hashes from the database and updates the block indices of the tree by attempting to connect the buffered blocks to canonical hashes.

N is the maximum of max_reorg_depth and the number of block hashes needed to satisfy the BLOCKHASH opcode in the EVM.

pub fn find_canonical_header( &self, hash: &FixedBytes<32>, ) -> Result<Option<SealedHeader>, ProviderError>

Attempts to find the header for the given block hash if it is canonical.

Returns Ok(None) if the block hash is not canonical (block hash does not exist, or is included in a sidechain).

Note: this does not distinguish between a block that is finalized and a block that is not finalized yet, only whether it is part of the canonical chain or not.

pub fn is_block_hash_canonical( &self, hash: &FixedBytes<32>, ) -> Result<bool, ProviderError>

Determines whether or not a block is canonical, checking the db if necessary.

Note: this does not distinguish between a block that is finalized and a block that is not finalized yet, only whether it is part of the canonical chain or not.

pub fn make_canonical( &mut self, block_hash: FixedBytes<32>, ) -> Result<CanonicalOutcome, CanonicalError>

Make a block and its parent(s) part of the canonical chain and commit them to the database

Note

This unwinds the database if necessary, i.e. if parts of the canonical chain have been reorged.

Returns

Returns Ok if the blocks were canonicalized, or if the blocks were already canonical.

pub fn unwind(&mut self, unwind_to: u64) -> Result<(), CanonicalError>

Unwind tables and put it inside state

Trait Implementations

impl<N, E> Debug for BlockchainTree<N, E>

where N: Debug + NodeTypesWithDB, E: 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.