Struct PendingBlockProcessor 

pub struct PendingBlockProcessor { /* private fields */ }

Wires one or more TxDeltaIndexers to an existing TychoStreamDecoder, enabling ephemeral simulation of candidate transaction bundles against the correct parent state for a specific target block.

Block targeting

Call subscribe_confirmed_block to obtain a watch::Receiver<u64> that fires on every confirmed block. Use it to wait for the right parent before submitting a bundle:

pending
    .subscribe_confirmed_block()
    .wait_for(|&n| n >= target_header.number - 1)
    .await
    .expect("stream closed");
let update = pending
    .generate_pending_update(txs, target_header, "bundle-1".to_string())
    .await
    .expect("pending update failed");

Concurrency

PendingBlockProcessor is intentionally not wrapped in a Mutex at construction time. The confirmed stream forwards blocks via an unbounded channel — it never blocks waiting for the consumer. Multiple callers can each hold a watch receiver and independently decide when to acquire whatever external lock they use around generate_pending_update.

Implementations

impl PendingBlockProcessor

pub fn subscribe_confirmed_block(&self) -> Receiver<u64>

Returns a receiver that is notified with the latest confirmed block number every time a new block is applied.

Typical usage: .wait_for(|&n| n >= target_block - 1).await before calling generate_pending_update.

pub fn current_confirmed_block(&self) -> u64

Returns the block number of the last confirmed block applied to the indexers.

pub fn advance( &mut self, msg: &FeedMessage<BlockHeader>, ) -> Result<(), PendingError>

Advances each registered indexer by applying one confirmed block.

Only needed when using the processor standalone (without ProtocolStreamBuilder::build_with_pending). When using build_with_pending, confirmed blocks are forwarded automatically.

pub async fn generate_pending_update( &mut self, txs: &[TxInput], target_header: BlockHeader, label: String, ) -> Result<PendingUpdate, PendingError>

Simulates txs against the confirmed parent state of target_block and returns an ephemeral Update.

Drains any confirmed blocks that have arrived since the last call, then immediately checks whether the parent block (target_block - 1) is available. If not, returns PendingError::ParentNotYetConfirmed — no blocking. Use subscribe_confirmed_block to wait for the right block before calling.

Neither the indexers’ internal state nor the decoder’s confirmed pool states are mutated. Calling this twice with the same arguments returns identical results.

Parameters

• txs — candidate bundle in execution order; failed transactions are skipped.
• target_header — header of the block being built. Its number is used for the parent-block guard; the full header is forwarded to apply_deltas_ephemeral so that block number and timestamp are injected into each state delta.
• label — opaque caller-supplied tag stamped onto the returned PendingUpdate. Use it to associate the result with a specific bundle or evaluation context.