Struct BlockSyncClient

pub(crate) struct BlockSyncClient<N: Network> {
    config: BlockSyncClientConfiguration,
    receiver: BlockSyncClientStub,
    sender: SenderHandle<N>,
    validator_set_update_handle: ValidatorSetUpdateHandle<N>,
    block_sync_client_state: BlockSyncClientState,
    event_publisher: Option<Sender<Event>>,
}

Fields

config: BlockSyncClientConfiguration

receiver: BlockSyncClientStub

sender: SenderHandle<N>

validator_set_update_handle: ValidatorSetUpdateHandle<N>

block_sync_client_state: BlockSyncClientState

event_publisher: Option<Sender<Event>>

Implementations

impl<N: Network> BlockSyncClient<N>

pub(crate) fn new( config: BlockSyncClientConfiguration, receiver: BlockSyncClientStub, sender: SenderHandle<N>, validator_set_update_handle: ValidatorSetUpdateHandle<N>, event_publisher: Option<Sender<Event>>, ) -> Self

Create a new instance of the BlockSyncClient.

pub(crate) fn on_receive_msg<K: KVStore>( &mut self, msg: BlockSyncAdvertiseMessage, origin: &VerifyingKey, block_tree: &mut BlockTreeSingleton<K>, app: &mut impl App<K>, ) -> Result<(), BlockSyncClientError>

Process a received BlockSyncAdvertiseMessage.

pub(crate) fn tick<K: KVStore>( &mut self, block_tree: &mut BlockTreeSingleton<K>, app: &mut impl App<K>, ) -> Result<(), BlockSyncClientError>

Update the BlockSyncClient’s internal state, and possibly trigger sync on reaching sync trigger timeout.

fn on_receive_advertise_block<K: KVStore>( &mut self, advertise_block: AdvertiseBlock, origin: &VerifyingKey, block_tree: &BlockTreeSingleton<K>, ) -> Result<(), BlockSyncClientError>

Process an AdvertiseBlock message. This can lead to registering the sender as an available sync server and storing information on the server’s claimed highest committed block height.

fn on_receive_advertise_pc<K: KVStore>( &mut self, advertise_pc: AdvertisePC, origin: &VerifyingKey, block_tree: &mut BlockTreeSingleton<K>, app: &mut impl App<K>, ) -> Result<(), BlockSyncClientError>

Process an AdvertisePC message. This can lead to triggering sync if the criteria for event-based sync trigger are met.

fn sync<K: KVStore>( &mut self, block_tree: &mut BlockTreeSingleton<K>, app: &mut impl App<K>, ) -> Result<(), BlockSyncClientError>

Sync with a randomly selected peer.

fn sync_with<K: KVStore>( &mut self, peer: &VerifyingKey, block_tree: &mut BlockTreeSingleton<K>, app: &mut impl App<K>, ) -> Result<(), BlockSyncClientError>

Sync with a given peer. This involves possibly multiple iterations of:

1. Sending a sync request to the peer for a given number of blocks,
2. Waiting for a response from the peer,
3. Processing the response: validating blocks, inserting into the block tree, performing related block tree and app state updates.

As part of this process, a sync peer can be blacklisted if:

1. It sends an incorrect or unsafe block,
2. It sends a block that is not validated by the App,
3. It fails to provide the minimum number of blocks it committed to providing through AdvertiseBlock.