Crate reth_network

Source
Expand description

reth P2P networking.

Ethereum’s networking protocol is specified in devp2p.

In order for a node to join the ethereum p2p network it needs to know what nodes are already part of that network. This includes public identities (public key) and addresses (where to reach them).

§Bird’s Eye View

See also diagram in NetworkManager

The Network is made up of several, separate tasks:

  • Transactions Task: is a spawned TransactionsManager future that:

    • Responds to incoming transaction related requests
    • Requests missing transactions from the Network
    • Broadcasts new transactions received from the TransactionPool over the Network

  • ETH request Task: is a spawned EthRequestHandler future that:

    • Responds to incoming ETH related requests: Headers, Bodies

  • Discovery Task: is a spawned Discv4 future that handles peer discovery and emits new peers to the Network

  • NetworkManager task advances the state of the Network, which includes:

    • Initiating new outgoing connections to discovered peers
    • Handling incoming TCP connections from peers
    • Peer management
    • Route requests:
      • from remote peers to corresponding tasks
      • from local to remote peers

§Usage

§Configure and launch a standalone network

The NetworkConfig is used to configure the network. It requires an instance of BlockReader.

use reth_network::{
    config::rng_secret_key, EthNetworkPrimitives, NetworkConfig, NetworkManager,
};
use reth_network_peers::mainnet_nodes;
use reth_storage_api::noop::NoopProvider;

// This block provider implementation is used for testing purposes.
let client = NoopProvider::default();

// The key that's used for encrypting sessions and to identify our node.
let local_key = rng_secret_key();

let config = NetworkConfig::<_, EthNetworkPrimitives>::builder(local_key)
    .boot_nodes(mainnet_nodes())
    .build(client);

// create the network instance
let network = NetworkManager::new(config).await.unwrap();

// keep a handle to the network and spawn it
let handle = network.handle().clone();
tokio::task::spawn(network);

§Configure all components of the Network with the NetworkBuilder

use reth_network::{
    config::rng_secret_key, EthNetworkPrimitives, NetworkConfig, NetworkManager,
};
use reth_network_peers::mainnet_nodes;
use reth_storage_api::noop::NoopProvider;
use reth_transaction_pool::TransactionPool;
async fn launch<Pool: TransactionPool>(pool: Pool) {
    // This block provider implementation is used for testing purposes.
    let client = NoopProvider::default();

    // The key that's used for encrypting sessions and to identify our node.
    let local_key = rng_secret_key();

    let config = NetworkConfig::<_, EthNetworkPrimitives>::builder(local_key)
        .boot_nodes(mainnet_nodes())
        .build(client.clone());
    let transactions_manager_config = config.transactions_manager_config.clone();

    // create the network instance
    let (handle, network, transactions, request_handler) = NetworkManager::builder(config)
        .await
        .unwrap()
        .transactions(pool, transactions_manager_config)
        .request_handler(client)
        .split_with_handle();
}

§Feature Flags

  • serde (default): Enable serde support for configuration types.
  • test-utils: Various utilities helpful for writing tests
  • geth-tests: Runs tests that require Geth to be installed locally.

Re-exports§

Modules§

  • cache
    Network cache support
  • config
    Network config support
  • error
    Possible errors when interacting with the network.
  • eth_requests
    Blocks/Headers management for the p2p network.
  • import
    This module provides an abstraction over block import in the form of the BlockImport trait.
  • message
    Capability messaging
  • peers
    Peer related implementations
  • protocol
    Support for handling additional RLPx-based application-level protocols.
  • test_utilstest-utils
    Common helpers for network testing. Common helpers for network testing.
  • transactions
    Transactions management for the p2p network.

Macros§

Structs§

  • ActiveSessionHandle
    An established session with a remote peer.
  • Discovery
    An abstraction over the configured discovery protocol.
  • EthNetworkPrimitives
    Network primitive types used by Ethereum networks.
  • FetchClient
    Front-end API for fetching data from the network.
  • FlattenedResponse
    Flatten a [Receiver] message in order to get rid of the [RecvError] result
  • HelloMessageWithProtocols
    This is a superset of [HelloMessage] that provides additional protocol [Protocol] information about the number of messages used by each capability in order to do proper message ID multiplexing.
  • NetworkBuilder
    A builder that can configure all components of the network.
  • NetworkHandle
    A shareable network frontend. Used to interact with the network.
  • NetworkManager
    Manages the entire state of the network.
  • PeerInfo
    Info about an active peer session.
  • PeerRequestSender
    A Cloneable connection for sending requests directly to the session of a peer.
  • PeersConfig
    Config type for initiating a PeersManager instance.
  • PendingSessionHandle
    A handler attached to a peer session that’s not authenticated yet, pending Handshake and hello message which exchanges the capabilities of the peer.
  • SessionId
    Internal identifier for active sessions.
  • SessionManager
    Manages a set of sessions.
  • SessionsConfig
    Configuration options for peer session management.
  • TxTypesCounter
    Counts the number of transactions by their type in a block or collection.

Enums§

Traits§