Struct OrderedTrieRootEncodedBuilder 

pub struct OrderedTrieRootEncodedBuilder { /* private fields */ }

A builder for computing ordered trie roots incrementally from pre-encoded items.

This builder allows pushing items one by one as they become available (e.g., receipts after each transaction execution), rather than requiring all items upfront.

Use Case

When executing a block, the receipt root must be computed from all transaction receipts. With the standard ordered_trie_root, you must wait until all transactions are executed before computing the root. This builder enables incremental computation - you can start building the trie as soon as receipts become available, potentially in parallel with continued execution.

The builder requires knowing the total item count upfront (the number of transactions in the block), but items can be pushed in any order by index.

How It Works

Items can be pushed in any order by specifying their index. The builder internally buffers items and flushes them to the underlying HashBuilder in the correct order for RLP key encoding (as determined by [adjust_index_for_rlp]).

Memory

Each pushed item is stored in an internal buffer until it can be flushed. In the worst case (e.g., pushing index 0 last), all items except one will be buffered. For receipt roots, index 0 is typically flushed late due to RLP key ordering, so expect to buffer most items until near the end.

Example

use reth_trie_common::ordered_root::OrderedTrieRootEncodedBuilder;

// Create a builder for 2 pre-encoded items
let mut builder = OrderedTrieRootEncodedBuilder::new(2);

// Push pre-encoded items as they arrive (can be out of order)
builder.push(1, b"encoded_item_1").unwrap();
builder.push(0, b"encoded_item_0").unwrap();

// Finalize to get the root hash
let root = builder.finalize().unwrap();

Implementations

impl OrderedTrieRootEncodedBuilder

pub fn new(len: usize) -> OrderedTrieRootEncodedBuilder

Creates a new builder for len pre-encoded items.

pub fn push( &mut self, index: usize, bytes: &[u8], ) -> Result<(), OrderedRootError>

Pushes a pre-encoded item at the given index to the builder.

Items can be pushed in any order. The builder will automatically flush items to the underlying HashBuilder when they become available in the correct order.

Errors

• OrderedRootError::IndexOutOfBounds if index >= len
• OrderedRootError::DuplicateIndex if an item was already pushed at this index

pub fn push_unchecked(&mut self, index: usize, bytes: &[u8])

Pushes a pre-encoded item at the given index without bounds or duplicate checking.

This is a performance-critical method for callers that can guarantee:

• index < len
• No item has been pushed at this index before

Panics

Panics in debug mode if index >= len.

pub const fn is_complete(&self) -> bool

Returns true if all items have been pushed.

pub const fn pushed_count(&self) -> usize

Returns the number of items pushed so far.

pub const fn expected_count(&self) -> usize

Returns the expected total number of items.

pub fn finalize(self) -> Result<FixedBytes<32>, OrderedRootError>

Finalizes the builder and returns the trie root.

Errors

Returns OrderedRootError::Incomplete if not all items have been pushed.

Trait Implementations

impl Debug for OrderedTrieRootEncodedBuilder

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

Formats the value using the given formatter.

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