Struct TransactionFetcher 

pub struct TransactionFetcher<N: NetworkPrimitives = EthNetworkPrimitives> { /* private fields */ }

Fetches transactions that peers announced but that are not in the pool yet.

Announcements are recorded with Self::on_announcement, requests are sent with Self::dispatch and resolved requests are yielded as FetchEvents by the [Stream] implementation. See the module docs for how requests are scheduled.

Implementations

impl<N: NetworkPrimitives> TransactionFetcher<N>

pub fn new(config: TransactionFetcherConfig) -> Self

Creates a new fetcher with the given config.

pub const fn config(&self) -> &TransactionFetcherConfig

Returns the fetcher’s config.

pub fn num_hashes(&self) -> usize

Returns the number of tracked hashes, pending and fetching.

pub fn num_pending_hashes(&self) -> usize

Returns the number of hashes that are waiting for an idle candidate peer.

pub const fn num_fetching_hashes(&self) -> usize

Returns the number of hashes that are part of an inflight request.

pub fn num_inflight_requests(&self) -> usize

Returns the number of inflight requests.

pub fn is_idle(&self, peer_id: &PeerId) -> bool

Returns true if there is no inflight request to the peer.

pub fn on_announcement( &mut self, peer_id: PeerId, announcement: impl IntoIterator<Item = AnnouncedTransaction>, )

Records hashes announced by the peer and queues them for fetching.

The metadata of a hash is the announced transaction type and size, if the announcement carried it. The caller is expected to have filtered out hashes that are already known.

Requests are only sent by Self::dispatch.

pub fn dispatch( &mut self, peers: &HashMap<PeerId, PeerMetadata<N>, FbBuildHasher<64>>, max_hashes_per_request: usize, ) -> usize

Sends GetPooledTransactions requests to idle peers that have queued hashes.

Stops when the global inflight request limit is reached. max_hashes_per_request caps each request independently of hashes inflight to other peers, so stalled peers cannot shrink requests to responsive peers. Zero sends nothing. The caller must enforce its import backpressure when consuming responses; decoded responses remain bounded by the configured inflight request limit.

Returns the number of requests sent. New requests are only polled by the next call to [Stream::poll_next], so the caller must poll the fetcher again if any were sent.

pub fn on_transactions_received<'a>( &mut self, hashes: impl IntoIterator<Item = &'a TxHash>, )

Stops tracking the given hashes because the transactions were received, e.g. over broadcast.

Hashes that are part of an inflight request are simply not rescheduled when that request resolves.

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

Removes the peer as a candidate for all hashes it announced and drops pending hashes that have no candidate left.

An inflight request to the peer resolves with an error once its session is gone, which reschedules the requested hashes.

pub fn update_metrics(&self)

Updates the fetcher’s gauges.

Trait Implementations

impl<N: Debug + NetworkPrimitives> Debug for TransactionFetcher<N>

where N::PooledTransaction: Debug,

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

Formats the value using the given formatter.

impl<N: NetworkPrimitives> Default for TransactionFetcher<N>

fn default() -> Self

Returns the “default value” for a type.

impl<N: NetworkPrimitives> Stream for TransactionFetcher<N>

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Advances all inflight requests and yields the next resolved request as an event.

Never terminates, returns Poll::Pending while no request is inflight.

type Item = FetchEvent<<N as NetworkPrimitives>::PooledTransaction>

Values yielded by the stream.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 552 bytes