Struct TransactionFetcher

pub struct TransactionFetcher<N: NetworkPrimitives = EthNetworkPrimitives> {
    pub active_peers: LruMap<PeerId, u8, ByLength>,
    pub inflight_requests: FuturesUnordered<GetPooledTxRequestFut<N::PooledTransaction>>,
    pub hashes_pending_fetch: LruCache<TxHash>,
    pub info: TransactionFetcherInfo,
    /* private fields */
}

The type responsible for fetching missing transactions from peers.

This will keep track of unique transaction hashes that are currently being fetched and submits new requests on announced hashes.

Fields

active_peers: LruMap<PeerId, u8, ByLength>

All peers with to which a GetPooledTransactions request is inflight.

inflight_requests: FuturesUnordered<GetPooledTxRequestFut<N::PooledTransaction>>

All currently active GetPooledTransactions requests.

The set of hashes encompassed by these requests are a subset of all hashes in the fetcher. It’s disjoint from the set of hashes which are awaiting an idle fallback peer in order to be fetched.

hashes_pending_fetch: LruCache<TxHash>

Hashes that are awaiting an idle fallback peer so they can be fetched.

This is a subset of all hashes in the fetcher, and is disjoint from the set of hashes for which a GetPooledTransactions request is inflight.

info: TransactionFetcherInfo

Info on capacity of the transaction fetcher.

Implementations

impl<N: NetworkPrimitives> TransactionFetcher<N>

pub fn update_metrics(&self)

Updates metrics.

pub fn with_transaction_fetcher_config( config: &TransactionFetcherConfig, ) -> Self

Sets up transaction fetcher with config

pub fn remove_hashes_from_transaction_fetcher<I>(&mut self, hashes: I)

where I: IntoIterator<Item = TxHash>,

Removes the specified hashes from inflight tracking.

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

Returns true if peer is idle with respect to self.inflight_requests.

pub fn get_idle_peer_for(&self, hash: TxHash) -> Option<&PeerId>

Returns any idle peer for the given hash.

pub fn find_any_idle_fallback_peer_for_any_pending_hash( &mut self, hashes_to_request: &mut RequestTxHashes, budget: Option<usize>, ) -> Option<PeerId>

Returns any idle peer for any hash pending fetch. If one is found, the corresponding hash is written to the request buffer that is passed as parameter.

Loops through the hashes pending fetch in lru order until one is found with an idle fallback peer, or the budget passed as parameter is depleted, whatever happens first.

pub fn pack_request( &self, hashes_to_request: &mut RequestTxHashes, hashes_from_announcement: ValidAnnouncementData, ) -> RequestTxHashes

Packages hashes for a GetPooledTxRequest up to limit. Returns left over hashes. Takes a RequestTxHashes buffer as parameter for filling with hashes to request.

Returns left over hashes.

pub fn pack_request_eth68( &self, hashes_to_request: &mut RequestTxHashes, hashes_from_announcement: impl HandleMempoolData + IntoIterator<Item = (TxHash, Option<(u8, usize)>)>, ) -> RequestTxHashes

Packages hashes for a GetPooledTxRequest from an Eth68 announcement up to limit as defined by protocol version 68. Takes a RequestTxHashes buffer as parameter for filling with hashes to request.

Returns left over hashes.

Loops through hashes passed as parameter and checks if a hash fits in the expected response. If no, it’s added to surplus hashes. If yes, it’s added to hashes to the request and expected response size is accumulated.

pub fn pack_request_eth66( &self, hashes_to_request: &mut RequestTxHashes, hashes_from_announcement: ValidAnnouncementData, ) -> RequestTxHashes

Packages hashes for a GetPooledTxRequest from an Eth66 announcement up to limit as defined by protocol version 66. Takes a RequestTxHashes buffer as parameter for filling with hashes to request.

Returns left over hashes.

pub fn try_buffer_hashes_for_retry( &mut self, hashes: RequestTxHashes, peer_failed_to_serve: &PeerId, )

Tries to buffer hashes for retry.

pub fn buffer_hashes( &mut self, hashes: RequestTxHashes, fallback_peer: Option<PeerId>, )

Buffers hashes. Note: Only peers that haven’t yet tried to request the hashes should be passed as fallback_peer parameter! For re-buffering hashes on failed request, use TransactionFetcher::try_buffer_hashes_for_retry. Hashes that have been re-requested DEFAULT_MAX_RETRIES, are dropped.

pub fn on_fetch_pending_hashes( &mut self, peers: &HashMap<PeerId, PeerMetadata<N>>, has_capacity_wrt_pending_pool_imports: impl Fn(usize) -> bool, )

Tries to request hashes pending fetch.

Finds the first buffered hash with a fallback peer that is idle, if any. Fills the rest of the request by checking the transactions seen by the peer against the buffer.

pub fn filter_unseen_and_pending_hashes( &mut self, new_announced_hashes: &mut ValidAnnouncementData, is_tx_bad_import: impl Fn(&TxHash) -> bool, peer_id: &PeerId, client_version: &str, )

Filters out hashes that have been seen before. For hashes that have already been seen, the peer is added as fallback peer.

pub fn request_transactions_from_peer( &mut self, new_announced_hashes: RequestTxHashes, peer: &PeerMetadata<N>, ) -> Option<RequestTxHashes>

Requests the missing transactions from the previously unseen announced hashes of the peer. Returns the requested hashes if the request concurrency limit is reached or if the request fails to send over the channel to the peer’s session task.

This filters all announced hashes that are already in flight, and requests the missing, while marking the given peer as an alternative peer for the hashes that are already in flight.

pub fn fill_request_from_hashes_pending_fetch( &mut self, hashes_to_request: &mut RequestTxHashes, seen_hashes: &LruCache<TxHash>, budget_fill_request: Option<usize>, )

Tries to fill request with hashes pending fetch so that the expected PooledTransactions response is full enough. A mutable reference to a list of hashes to request is passed as parameter. A budget is passed as parameter, this ensures that the node stops searching for more hashes after the budget is depleted. Under bad network conditions, the cache of hashes pending fetch may become very full for a while. As the node recovers, the hashes pending fetch cache should get smaller. The budget should aim to be big enough to loop through all buffered hashes in good network conditions.

The request hashes buffer is filled as if it’s an eth68 request, i.e. smartly assemble the request based on expected response size. For any hash missing size metadata, it is guessed at AVERAGE_BYTE_SIZE_TX_ENCODED.

Loops through hashes pending fetch and does:

1. Check if a hash pending fetch is seen by peer.
2. Optimistically include the hash in the request.
3. Accumulate expected total response size.
4. Check if acc size and hashes count is at limit, if so stop looping.
5. Remove hashes to request from cache of hashes pending fetch.

pub fn has_capacity_for_fetching_pending_hashes(&self) -> bool

Returns true if TransactionFetcher has capacity to request pending hashes. Returns false if TransactionFetcher is operating close to full capacity.

pub fn search_breadth_budget_find_idle_fallback_peer( &self, has_capacity_wrt_pending_pool_imports: impl Fn(usize) -> bool, ) -> Option<usize>

Returns the limit to enforce when looking for any pending hash with an idle fallback peer.

Returns Some(limit) if TransactionFetcher and the TransactionPool are operating close to full capacity. Returns None, unlimited, if they are not that busy.

pub fn search_breadth_budget_find_intersection_pending_hashes_and_hashes_seen_by_peer( &self, has_capacity_wrt_pending_pool_imports: impl Fn(usize) -> bool, ) -> Option<usize>

Returns the limit to enforce when looking for the intersection between hashes announced by peer and hashes pending fetch.

Returns Some(limit) if TransactionFetcher and the TransactionPool are operating close to full capacity. Returns None, unlimited, if they are not that busy.

pub const fn approx_capacity_get_pooled_transactions_req( &self, announcement_version: EthVersion, ) -> usize

Returns the approx number of transactions that a GetPooledTransactions request will have capacity for w.r.t. the given version of the protocol.

pub fn on_resolved_get_pooled_transactions_request_fut( &mut self, response: GetPooledTxResponse<N::PooledTransaction>, ) -> FetchEvent<N::PooledTransaction>

Processes a resolved GetPooledTransactions request. Queues the outcome as a FetchEvent, which will then be streamed by TransactionsManager.

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<T: NetworkPrimitives> Default for TransactionFetcher<T>

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 returns the next event.

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.

impl<'pin, N: NetworkPrimitives> Unpin for TransactionFetcher<N>

where PinnedFieldsOf<__TransactionFetcher<'pin, N>>: Unpin,

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: 528 bytes