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>,
}

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.

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>

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

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

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.

async fn finalized_chain_tip_block(&self) -> Option<ChainTipBlock>

Reads the finalized tip block from the secondary db instance and converts it to a ChainTipBlock.

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