Struct TrustedChainSync 

pub struct TrustedChainSync {
    pub indexer_rpc_client: IndexerClient<Channel>,
    db: ZebraDb,
    non_finalized_state: NonFinalizedState,
    chain_tip_sender: ChainTipSender,
    non_finalized_state_sender: Sender<NonFinalizedState>,
    started_sync_sender: Sender<bool>,
}

Syncs non-finalized blocks in the best chain from a trusted Zebra node’s RPC methods.

Fields

indexer_rpc_client: IndexerClient<Channel>

gRPC client for calling Zebra’s indexer methods.

db: ZebraDb

The read state service.

non_finalized_state: NonFinalizedState

The non-finalized state - currently only contains the best chain.

chain_tip_sender: ChainTipSender

The chain tip sender for updating LatestChainTip and ChainTipChange.

non_finalized_state_sender: Sender<NonFinalizedState>

The non-finalized state sender, for updating the ReadStateService when the non-finalized best chain changes.

started_sync_sender: Sender<bool>

Flipped to true once sync() receives its first parseable block from the non_finalized_state_change stream, which stops update_finalized_chain_tip so sync() becomes the sole caller of try_catch_up_with_primary on the shared secondary db.

Implementations

impl TrustedChainSync

pub async fn spawn( indexer_rpc_address: SocketAddr, db: ZebraDb, non_finalized_state_sender: Sender<NonFinalizedState>, ) -> Result<(LatestChainTip, ChainTipChange, JoinHandle<()>), BoxError>

Creates a new TrustedChainSync with a ChainTipSender, then spawns a task to sync blocks from the node’s non-finalized best chain.

Returns the LatestChainTip, ChainTipChange, and a [JoinHandle] for the sync task.

async fn sync(&mut self)

Starts syncing blocks from the node’s non-finalized best chain and checking for chain tip changes in the finalized state.

When the best chain tip in Zebra is not available in the finalized state or the local non-finalized state, gets any unavailable blocks in Zebra’s best chain from the RPC server, adds them to the local non-finalized state, then sends the updated chain tip block and non-finalized state to the ChainTipSender and non-finalized state sender.

async fn try_commit( &mut self, block: SemanticallyVerifiedBlock, ) -> Result<(), ValidateContextError>

fn commit( &mut self, block: SemanticallyVerifiedBlock, ) -> Result<(), ValidateContextError>

Commits block to the non-finalized state, starting a new chain if it builds on the finalized tip or extending an existing chain otherwise, prunes newly-finalized blocks, and publishes the updated chain tip and non-finalized state.

Updating the channels here (rather than only after try_commit returns) means the bridge blocks committed by Self::fill_finalized_gap also advance the published chain tip.

async fn fill_finalized_gap(&mut self, target_height: Height)

Fetches the blocks between the secondary’s finalized tip and target_height (exclusive) from the primary and commits them to the non-finalized state.

These blocks are finalized on the primary but not yet on the lagging secondary. Committing them as non-finalized bridge blocks gives the block at target_height a contiguous chain to attach to; they are dropped again by Self::prune_finalized as the secondary catches up.

This is best-effort: if a block can’t be fetched or committed, it returns early and lets the caller’s commit fail so the block is retried on the next subscription.

async fn get_block( &self, hash_or_height: HashOrHeight, ) -> Result<(Block, Hash), Status>

Fetches a single block from the primary by hash or height via the indexer gRPC.

async fn subscribe_to_non_finalized_state_change( &mut self, ) -> Result<Streaming<BlockAndHash>, Status>

Calls the non_finalized_state_change() method on the indexer gRPC client to subscribe to non-finalized state changes, and returns the response stream.

Passes the tip hashes of every chain currently in this syncer’s non-finalized state so the server only streams blocks after the tips we already have, instead of re-sending the whole non-finalized state on every (re)subscription. When the non-finalized state is empty, the request carries no tips and the server streams every non-finalized block.

async fn try_catch_up_with_primary(&self)

Tries to catch up to the primary db instance for an up-to-date view of finalized blocks.

fn prune_finalized(&mut self)

Finalizes any non-finalized blocks that are at or below the finalized tip height.

The secondary’s finalized state follows the primary, so after catching up it may have advanced past the root of the non-finalized state. This drops those now-finalized blocks so the non-finalized state only tracks blocks above the finalized tip. Does nothing when the non-finalized state is empty.

fn update_channels(&mut self)

Sends the new chain tip and non-finalized state to the latest chain channels.

Trait Implementations

impl Debug for TrustedChainSync

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

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