Struct sc_network_sync::ChainSync

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

The main data structure which contains all the state for a chains active syncing strategy.

Implementations

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

pub fn new(
    mode: SyncMode,
    client: Arc<Client>,
    block_announce_validator: Box<dyn BlockAnnounceValidator<B> + Send>,
    max_parallel_downloads: u32,
    warp_sync_provider: Option<Arc<dyn WarpSyncProvider<B>>>
) -> Result<Self, ClientError>

Create a new instance.

Trait Implementations

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

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

Returns the current sync status.

fn create_opaque_block_request(
    &self,
    request: &BlockRequest<B>
) -> OpaqueBlockRequest

Create implementation-specific block request.

fn peer_info(&self, who: &PeerId) -> Option<PeerInfo<B>>

Returns the state of the sync of the given peer.

fn num_sync_requests(&self) -> usize

Number of active forks requests. This includes requests that are pending or could be issued right away.

fn num_downloaded_blocks(&self) -> usize

Number of downloaded blocks.

fn num_peers(&self) -> usize

Returns the current number of peers stored within this state machine.

fn new_peer(
    &mut self,
    who: PeerId,
    best_hash: B::Hash,
    best_number: NumberFor<B>
) -> Result<Option<BlockRequest<B>>, BadPeer>

Handle a new connected peer.

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

Signal that a new best block has been imported.

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

Schedule a justification request for the given block.

fn clear_justification_requests(&mut self)

Clear all pending justification requests.

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

Request syncing for the given block from given set of peers.

fn justification_requests(
    &mut self
) -> Box<dyn Iterator<Item = (PeerId, BlockRequest<B>)> + '_>

Get an iterator over all scheduled justification requests.

fn block_requests(
    &mut self
) -> Box<dyn Iterator<Item = (&PeerId, BlockRequest<B>)> + '_>

Get an iterator over all block requests of all peers.

fn state_request(&mut self) -> Option<(PeerId, OpaqueStateRequest)>

Get a state request, if any.

fn warp_sync_request(&mut self) -> Option<(PeerId, WarpProofRequest<B>)>

Get a warp sync request, if any.

fn on_block_data(
    &mut self,
    who: &PeerId,
    request: Option<BlockRequest<B>>,
    response: BlockResponse<B>
) -> Result<OnBlockData<B>, BadPeer>

Handle a response from the remote to a block request that we made.

fn on_state_data(
    &mut self,
    who: &PeerId,
    response: OpaqueStateResponse
) -> Result<OnStateData<B>, BadPeer>

Handle a response from the remote to a state request that we made.

fn on_warp_sync_data(
    &mut self,
    who: &PeerId,
    response: EncodedProof
) -> Result<(), BadPeer>

Handle a response from the remote to a warp proof request that we made.

fn on_block_justification(
    &mut self,
    who: PeerId,
    response: BlockResponse<B>
) -> Result<OnBlockJustification<B>, BadPeer>

Handle a response from the remote to a justification request that we made.

fn on_blocks_processed(
    &mut self,
    imported: usize,
    count: usize,
    results: Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>
) -> Box<dyn Iterator<Item = Result<(PeerId, BlockRequest<B>), BadPeer>>>

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

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

Call this when a justification has been processed by the import queue, with or without errors.

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

Notify about finalization of the given block.

fn push_block_announce_validation(
    &mut self,
    who: PeerId,
    hash: B::Hash,
    announce: BlockAnnounce<B::Header>,
    is_best: bool
)

Push a block announce validation.

fn poll_block_announce_validation(
    &mut self,
    cx: &mut Context<'_>
) -> Poll<PollBlockAnnounceValidation<B::Header>>

Poll block announce validation.

fn peer_disconnected(&mut self, who: &PeerId) -> Option<OnBlockData<B>>

Call when a peer has disconnected. Canceled obsolete block request may result in some blocks being ready for import, so this functions checks for such blocks and returns them.

fn metrics(&self) -> Metrics

Return some key metrics.

fn encode_block_request(
    &self,
    request: &OpaqueBlockRequest
) -> Result<Vec<u8>, String>

Encode implementation-specific block request.

fn decode_block_response(
    &self,
    response: &[u8]
) -> Result<OpaqueBlockResponse, String>

Decode implementation-specific block response.

fn block_response_into_blocks(
    &self,
    request: &BlockRequest<B>,
    response: OpaqueBlockResponse
) -> Result<Vec<BlockData<B>>, String>

Access blocks from implementation-specific block response.

fn encode_state_request(
    &self,
    request: &OpaqueStateRequest
) -> Result<Vec<u8>, String>

Encode implementation-specific state request.

fn decode_state_response(
    &self,
    response: &[u8]
) -> Result<OpaqueStateResponse, String>

Decode implementation-specific state response.