Struct PeerHandler 

pub struct PeerHandler {
    pub peer_table: PeerTable,
    pub initiator: ActorRef<RLPxInitiator>,
}

An abstraction over the [Kademlia] containing logic to make requests to peers

Fields

peer_table: PeerTable

initiator: ActorRef<RLPxInitiator>

Implementations

impl PeerHandler

pub fn new( peer_table: PeerTable, initiator: ActorRef<RLPxInitiator>, ) -> PeerHandler

pub async fn eth_capable_peer_count(&self) -> usize

Number of peers known to the table that advertise the eth capabilities used for sync. NOTE: this counts eth-capable peers regardless of whether they currently have a live connection, so it can be greater than the number actually queryable via get_random_peer (which requires a live connection). Used only for diagnostics; logged as eth_capable_peers. Returns 0 on any peer-table error.

pub async fn request_block_headers( &mut self, start: u64, sync_head: H256, ) -> Result<Option<Vec<BlockHeader>>, PeerHandlerError>

Requests block headers from any suitable peer, starting from the start block hash towards either older or newer blocks depending on the order Returns the block headers or None if:

• There are no available peers (the node just started up or was rejected by all other nodes)
• No peer returned a valid response in the given time and retry limits

pub async fn request_block_headers_from_hash( &mut self, start: H256, order: BlockRequestOrder, ) -> Result<HeaderFetchOutcome, PeerHandlerError>

Requests block headers from any suitable peer, starting from the start block hash towards either older or newer blocks depending on the order

• No peer returned a valid response in the given time and retry limits Since request_block_headers brought problems in cases of reorg seen in this pr https://github.com/lambdaclass/ethrex/pull/4028, we have this other function to request block headers only for full sync.

pub async fn request_block_bodies( &mut self, block_headers: &[BlockHeader], ) -> Result<Option<Vec<BlockBody>>, PeerHandlerError>

Requests block bodies from any suitable peer given their block headers and validates them Returns the requested block bodies or None if:

• There are no available peers (the node just started up or was rejected by all other nodes)
• No peer returned a valid response in the given time and retry limits
• The block bodies are invalid given the block headers

pub async fn request_block_access_lists( &mut self, block_hashes: &[H256], ) -> Result<Option<Vec<Option<BlockAccessList>>>, PeerHandlerError>

Requests block access lists from a peer that supports eth/71. Returns a vector of optional BALs (one per requested block hash) or None if:

• There are no available eth/71 peers
• The peer did not respond in time

pub async fn read_peer_diagnostics(&self) -> Vec<PeerDiagnostics>

Returns diagnostic snapshots for all connected peers (scores, requests, eligibility).

pub async fn read_connected_peers(&mut self) -> Vec<PeerData>

Returns the PeerData for each connected Peer

pub async fn count_total_peers(&mut self) -> Result<usize, PeerHandlerError>

pub async fn get_block_header( &mut self, connection: &mut PeerConnection, _permit: RequestPermit, block_number: u64, ) -> Result<Option<BlockHeader>, PeerHandlerError>

Requests a single block header by number from an already-selected peer. Consumes a RequestPermit reserved by the caller at peer selection time; the permit drops when this function returns, releasing the slot.

Trait Implementations

impl Clone for PeerHandler

fn clone(&self) -> PeerHandler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PeerHandler

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.