Struct SyncingStrategy

pub struct SyncingStrategy<B: BlockT, Client> { /* private fields */ }

Proxy to specific syncing strategies.

Implementations

impl<B, Client> SyncingStrategy<B, Client>

where B: BlockT, Client: HeaderBackend<B> + BlockBackend<B> + HeaderMetadata<B, Error = Error> + ProofProvider<B> + Send + Sync + 'static,

pub fn new( config: SyncingConfig, client: Arc<Client>, warp_sync_config: Option<WarpSyncConfig<B>>, ) -> Result<Self, ClientError>

Initialize a new syncing strategy.

pub fn add_peer( &mut self, peer_id: PeerId, best_hash: B::Hash, best_number: NumberFor<B>, )

Notify that a new peer has connected.

pub fn remove_peer(&mut self, peer_id: &PeerId)

Notify that a peer has disconnected.

pub fn on_validated_block_announce( &mut self, is_best: bool, peer_id: PeerId, announce: &BlockAnnounce<B::Header>, ) -> Option<(B::Hash, NumberFor<B>)>

Submit a validated block announcement.

Returns new best hash & best number of the peer if they are updated.

pub fn set_sync_fork_request( &mut self, peers: Vec<PeerId>, hash: &B::Hash, number: NumberFor<B>, )

Configure an explicit fork sync request in case external code has detected that there is a stale fork missing.

pub fn request_justification(&mut self, hash: &B::Hash, number: NumberFor<B>)

Request extra justification.

pub fn clear_justification_requests(&mut self)

Clear extra justification requests.

pub fn on_justification_import( &mut self, hash: B::Hash, number: NumberFor<B>, success: bool, )

Report a justification import (successful or not).

pub fn on_block_response( &mut self, peer_id: PeerId, key: StrategyKey, request: BlockRequest<B>, blocks: Vec<BlockData<B>>, )

Process block response.

pub fn on_state_response( &mut self, peer_id: PeerId, key: StrategyKey, response: OpaqueStateResponse, )

Process state response.

pub fn on_warp_proof_response( &mut self, peer_id: &PeerId, key: StrategyKey, response: EncodedProof, )

Process warp proof response.

pub fn on_blocks_processed( &mut self, imported: usize, count: usize, results: Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>, )

A batch of blocks have been processed, with or without errors.

pub fn on_block_finalized(&mut self, hash: &B::Hash, number: NumberFor<B>)

Notify a syncing strategy that a block has been finalized.

pub fn update_chain_info( &mut self, best_hash: &B::Hash, best_number: NumberFor<B>, )

Inform sync about a new best imported block.

pub fn is_major_syncing(&self) -> bool

pub fn num_peers(&self) -> usize

Get the number of peers known to the syncing strategy.

pub fn status(&self) -> SyncStatus<B>

Returns the current sync status.

pub fn num_downloaded_blocks(&self) -> usize

Get the total number of downloaded blocks.

pub fn num_sync_requests(&self) -> usize

Get an estimate of the number of parallel sync requests.

pub fn actions(&mut self) -> Result<Vec<SyncingAction<B>>, ClientError>

Get actions that should be performed by the owner on the strategy’s behalf

pub fn proceed_to_next(&mut self) -> Result<(), ClientError>

Proceed with the next strategy if the active one finished.