Struct ChainSync

pub struct ChainSync<ZN, ZS, ZV, ZSTip>
where
    ZN: Service<Request, Response = Response, Error = BoxError> + Send + Sync + Clone + 'static,
    ZN::Future: Send,
    ZS: Service<Request, Response = Response, Error = BoxError> + Send + Sync + Clone + 'static,
    ZS::Future: Send,
    ZV: Service<Request, Response = Hash, Error = BoxError> + Send + Sync + Clone + 'static,
    ZV::Future: Send,
    ZSTip: ChainTip + Clone + Send + 'static,
{
    genesis_hash: Hash,
    max_checkpoint_height: Height,
    checkpoint_verify_concurrency_limit: usize,
    full_verify_concurrency_limit: usize,
    tip_network: Timeout<ZN>,
    downloads: Pin<Box<Downloads<Hedge<ConcurrencyLimit<Retry<RetryLimit, Timeout<ZN>>>, AlwaysHedge>, Timeout<ZV>, ZSTip>>>,
    state: ZS,
    latest_chain_tip: ZSTip,
    prospective_tips: HashSet<CheckedTip>,
    recent_syncs: RecentSyncLengths,
    past_lookahead_limit_receiver: WatchReceiver<bool>,
}

Fields

genesis_hash: Hash

The genesis hash for the configured network

max_checkpoint_height: Height

The largest block height for the checkpoint verifier, based on the current config.

checkpoint_verify_concurrency_limit: usize

The configured checkpoint verification concurrency limit, after applying the minimum limit.

full_verify_concurrency_limit: usize

The configured full verification concurrency limit, after applying the minimum limit.

tip_network: Timeout<ZN>

A network service which is used to perform ObtainTips and ExtendTips requests.

Has no retry logic, because failover is handled using fanout.

downloads: Pin<Box<Downloads<Hedge<ConcurrencyLimit<Retry<RetryLimit, Timeout<ZN>>>, AlwaysHedge>, Timeout<ZV>, ZSTip>>>

A service which downloads and verifies blocks, using the provided network and verifier services.

state: ZS

The cached block chain state.

latest_chain_tip: ZSTip

Allows efficient access to the best tip of the blockchain.

prospective_tips: HashSet<CheckedTip>

The tips that the syncer is currently following.

recent_syncs: RecentSyncLengths

The lengths of recent sync responses.

past_lookahead_limit_receiver: WatchReceiver<bool>

Receiver that is true when the downloader is past the lookahead limit. This is based on the downloaded block height and the state tip height.

Implementations

impl<ZN, ZS, ZV, ZSTip> ChainSync<ZN, ZS, ZV, ZSTip>

where ZN: Service<Request, Response = Response, Error = BoxError> + Send + Sync + Clone + 'static, ZN::Future: Send, ZS: Service<Request, Response = Response, Error = BoxError> + Send + Sync + Clone + 'static, ZS::Future: Send, ZV: Service<Request, Response = Hash, Error = BoxError> + Send + Sync + Clone + 'static, ZV::Future: Send, ZSTip: ChainTip + Clone + Send + 'static,

Polls the network to determine whether further blocks are available and downloads them.

This component is used for initial block sync, but the Inbound service is responsible for participating in the gossip protocols used for block diffusion.

pub fn new( config: &ZebradConfig, max_checkpoint_height: Height, peers: ZN, verifier: ZV, state: ZS, latest_chain_tip: ZSTip, ) -> (Self, SyncStatus)

Returns a new syncer instance, using:

• chain: the zebra-chain Network to download (Mainnet or Testnet)
• peers: the zebra-network peers to contact for downloads
• verifier: the zebra-consensus verifier that checks the chain
• state: the zebra-state that stores the chain
• latest_chain_tip: the latest chain tip from state

Also returns a SyncStatus to check if the syncer has likely reached the chain tip.

pub async fn sync(self) -> Result<(), Report>

Runs the syncer to synchronize the chain and keep it synchronized.

async fn try_to_sync(&mut self) -> Result<(), Report>

Tries to synchronize the chain as far as it can.

Obtains some prospective tips and iteratively tries to extend them and download the missing blocks.

Returns Ok if it was able to synchronize as much of the chain as it could, and then ran out of prospective tips. This happens when synchronization finishes or if Zebra ended up following a fork. Either way, Zebra should attempt to obtain some more tips.

Returns Err if there was an unrecoverable error and restarting the synchronization is necessary. This includes outer timeouts, where an entire syncing step takes an extremely long time. (These usually indicate hangs.)

async fn try_to_sync_once( &mut self, extra_hashes: IndexSet<Hash>, ) -> Result<IndexSet<Hash>, Report>

Tries to synchronize the chain once, using the existing extra_hashes.

Tries to extend the existing tips and download the missing blocks.

Returns Ok(extra_hashes) if it was able to extend once and synchronize sone of the chain. Returns Err if there was an unrecoverable error and restarting the synchronization is necessary.

async fn obtain_tips(&mut self) -> Result<IndexSet<Hash>, Report>

Given a block_locator list fan out request for subsequent hashes to multiple peers

async fn extend_tips(&mut self) -> Result<IndexSet<Hash>, Report>

async fn request_genesis(&mut self) -> Result<(), Report>

Download and verify the genesis block, if it isn’t currently known to our node.

async fn request_genesis_once( &mut self, ) -> Result<Result<(Height, Hash), BlockDownloadVerifyError>, Report>

Try to download and verify the genesis block once.

Fatal errors are returned in the outer result, temporary errors in the inner one.

async fn request_blocks( &mut self, hashes: IndexSet<Hash>, ) -> Result<IndexSet<Hash>, BlockDownloadVerifyError>

Queue download and verify tasks for each block that isn’t currently known to our node.

TODO: turn obtain and extend tips into a separate task, which sends hashes via a channel?

fn lookahead_limit(&self, new_hashes: usize) -> usize

The configured lookahead limit, based on the currently verified height, and the number of hashes we haven’t queued yet.

fn handle_block_response( &mut self, response: Result<(Height, Hash), BlockDownloadVerifyError>, ) -> Result<(), BlockDownloadVerifyError>

Handles a response for a requested block.

See Self::handle_response for more details.

fn handle_hash_response( response: Result<IndexSet<Hash>, BlockDownloadVerifyError>, ) -> Result<IndexSet<Hash>, BlockDownloadVerifyError>

Handles a response to block hash submission, passing through any extra hashes.

See Self::handle_response for more details.

fn handle_response<T>( response: Result<T, BlockDownloadVerifyError>, ) -> Result<(), BlockDownloadVerifyError>

Handles a response to a syncer request.

Returns Ok if the request was successful, or if an expected error occurred, so that the synchronization can continue normally.

Returns Err if an unexpected error occurred, to force the synchronizer to restart.

pub(crate) async fn state_contains( &mut self, hash: Hash, ) -> Result<bool, Report>

Returns true if the hash is present in the state, and false if the hash is not present in the state.

fn update_metrics(&mut self)

fn should_restart_sync(e: &BlockDownloadVerifyError) -> bool

Return if the sync should be restarted based on the given error from the block downloader and verifier stream.