Struct ckb_sync::Relayer

pub struct Relayer { /* private fields */ }

Relayer protocol handle

Implementations

impl Relayer

pub fn new(chain: ChainController, shared: Arc<SyncShared>) -> Self

Init relay protocol handle

This is a runtime relay protocol shared state, and any relay messages will be processed and forwarded by it

pub fn shared(&self) -> &Arc<SyncShared>

Get shared state

pub fn request_proposal_txs(
    &self,
    nc: &dyn CKBProtocolContext,
    peer: PeerIndex,
    block_hash_and_number: BlockNumberAndHash,
    proposals: Vec<ProposalShortId>
)

Request the transaction corresponding to the proposal id from the specified node

pub fn accept_block(
    &self,
    nc: &dyn CKBProtocolContext,
    peer: PeerIndex,
    block: BlockView
)

Accept a new block from network

pub fn reconstruct_block(
    &self,
    active_chain: &ActiveChain,
    compact_block: &CompactBlock,
    received_transactions: Vec<TransactionView>,
    uncles_index: &[u32],
    received_uncles: &[UncleBlockView]
) -> ReconstructionResult

Reorganize the full block according to the compact block/txs/uncles

pub fn ask_for_txs(&self, nc: &dyn CKBProtocolContext)

Ask for relay transaction by hash from all peers

pub fn send_bulk_of_tx_hashes(&self, nc: &dyn CKBProtocolContext)

Send bulk of tx hashes to selected peers

Trait Implementations

impl CKBProtocolHandler for Relayer

fn init<'life0, 'async_trait>(
    &'life0 mut self,
    nc: Arc<dyn CKBProtocolContext + Sync>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Init action on service run

fn received<'life0, 'async_trait>(
    &'life0 mut self,
    nc: Arc<dyn CKBProtocolContext + Sync>,
    peer_index: PeerIndex,
    data: Bytes
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Called when the corresponding protocol message is received

fn connected<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    _nc: Arc<dyn CKBProtocolContext + Sync>,
    peer_index: PeerIndex,
    version: &'life1 str
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Called when opening protocol

fn disconnected<'life0, 'async_trait>(
    &'life0 mut self,
    _nc: Arc<dyn CKBProtocolContext + Sync>,
    peer_index: PeerIndex
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Called when closing protocol

fn notify<'life0, 'async_trait>(
    &'life0 mut self,
    nc: Arc<dyn CKBProtocolContext + Sync>,
    token: u64
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Called when the Service receives the notify task

fn poll<'life0, 'async_trait>(
    &'life0 mut self,
    _nc: Arc<dyn CKBProtocolContext + Sync + 'static>
) -> Pin<Box<dyn Future<Output = Option<()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Behave like Stream::poll

impl Clone for Relayer

fn clone(&self) -> Relayer

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.