Struct Hybrid 

pub(crate) struct Hybrid<TContext, TExecutionBlockProvider>
where
    TContext: BufferPooler + Storage + Metrics + Clock,
{
    prunable: Archive<TwoCap, TContext, Digest, Block>,
    execution_block_provider: TExecutionBlockProvider,
    retention_blocks: u64,
}

Finalized blocks store backed by a prunable archive (a hot cache of the most recently finalized blocks) and reth (the source of truth for finalized blocks).

Fields

prunable: Archive<TwoCap, TContext, Digest, Block>

Hot cache of recently finalized blocks. Bounded to roughly retention_blocks items above reth’s finalized watermark via Self::evict_below_execution_finalized_floor.

execution_block_provider: TExecutionBlockProvider

Execution layer block provider used to look up finalized blocks below the cache window and to read reth’s finalized watermark for cache eviction.

retention_blocks: u64

Number of most-recently-finalized blocks (relative to the EL’s finalized watermark) to keep in the prunable cache. Anything older is dropped from the cache and served out of Self::execution_block_provider instead.

Implementations

impl<TContext, P> Hybrid<TContext, P>

where TContext: BufferPooler + Storage + Metrics + Clock, P: FinalizedBlocksProvider + 'static,

pub(crate) fn new(config: Config<TContext, P>) -> Self

async fn evict_below_execution_finalized_floor(&mut self) -> Result<(), Error>

Drops blocks below the execution layer’s finalized watermark.

The cache is sized relative to the EL’s finalized boundary, not to the height the marshal happens to put. This keeps two invariants:

• We never evict a block the EL doesn’t yet have. If the EL is lagging the marshal, no eviction happens; the cache temporarily grows past retention_blocks.
• Eviction tracks the EL’s progress monotonically. Once the EL finalizes height H, the cache may drop everything below H - retention_blocks + 1 on the next put.

Trait Implementations

impl<TContext, TExecutionBlockProvider> Blocks for Hybrid<TContext, TExecutionBlockProvider>

where TContext: BufferPooler + Storage + Metrics + Clock + Send + Sync + 'static, TExecutionBlockProvider: FinalizedBlocksProvider + 'static,

async fn get( &self, id: Identifier<'_, Digest>, ) -> Result<Option<Self::Block>, Self::Error>

Attempts to read id from the prunable archive, falling back to EL on miss.

async fn prune(&mut self, _min: Height) -> Result<(), Self::Error>

No-op: Cache eviction is EL-driven (see Self::evict_below_execution_finalized_floor).

type Block = Block

The type of [Block] that is stored.

type Error = Error

The type of error returned when storing, retrieving, or pruning blocks.

async fn put(&mut self, block: Self::Block) -> Result<(), Self::Error>

Buffer a finalized block for storage, keyed by height and block digest.

async fn sync(&mut self) -> Result<(), Self::Error>

Flush all buffered writes to durable storage.

fn missing_items(&self, start: Height, max: usize) -> Vec<Height>

Returns up to max missing items starting from start.

fn next_gap(&self, value: Height) -> (Option<Height>, Option<Height>)

Finds the end of the range containing value and the start of the range succeeding value. This method is useful for identifying gaps around a given point.

fn last_index(&self) -> Option<Height>

Retrieve the last (highest) index in the store.

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.