Make eth protocol handler stateful in network

[mattsse]

Describe the feature

rn the eth handler used by peer connections are fixed to the default eth protocol spec:

reth/crates/net/eth-wire-types/src/message.rs

Line 174 in b97d9b4

pub enum EthMessage<N: NetworkPrimitives = EthNetworkPrimitives> {

this means that, while the types are configurable, the actual message variants are not.

the network impl itself is only concerned with bodies,headers,transaction messages

reth/crates/net/network/src/message.rs

Lines 42 to 62 in b97d9b4

	/// All Bi-directional eth-message variants that can be sent to a session or received from a
	/// session.
	#[derive(Debug)]
	pub enum PeerMessage<N: NetworkPrimitives = EthNetworkPrimitives> {
	/// Announce new block hashes
	NewBlockHashes(NewBlockHashes),
	/// Broadcast new block.
	NewBlock(NewBlockMessage<N::Block>),
	/// Received transactions _from_ the peer
	ReceivedTransaction(Transactions<N::BroadcastedTransaction>),
	/// Broadcast transactions _from_ local _to_ a peer.
	SendTransactions(SharedTransactions<N::BroadcastedTransaction>),
	/// Send new pooled transactions
	PooledTransactions(NewPooledTransactionHashes),
	/// All `eth` request variants.
	EthRequest(PeerRequest<N>),
	/// Any other or manually crafted eth message.
	///
	/// Caution: It is expected that this is a valid `eth_` capability message.
	Other(RawCapabilityMessage),
	}

we assume this will still be the case, but we'd like to make connection handling configurable:

reth/crates/net/network/src/session/mod.rs

Lines 907 to 935 in b97d9b4

	let stream = match get_ecies_stream(stream, secret_key, direction).await {
	Ok(stream) => stream,
	Err(error) => {
	let _ = events
	.send(PendingSessionEvent::EciesAuthError {
	remote_addr,
	session_id,
	error,
	direction,
	})
	.await;
	return
	}
	};
	let unauthed = UnauthedP2PStream::new(stream);
	let auth = authenticate_stream(
	unauthed,
	session_id,
	remote_addr,
	local_addr,
	direction,
	hello,
	status,
	fork_filter,
	extra_handlers,
	)
	.boxed();

meaning we'd like to support a custom p2pstream type:

reth/crates/net/network/src/session/mod.rs

Lines 990 to 991 in b97d9b4

	// conduct the p2p handshake and return the authenticated stream
	let (p2p_stream, their_hello) = match stream.handshake(hello).await {

this can be implemented similarly to what we already do with additional rlpx protocol handlers:

reth/crates/net/network/src/session/mod.rs

Lines 110 to 111 in b97d9b4

	/// Additional `RLPx` sub-protocols to be used by the session manager.
	extra_protocols: RlpxSubProtocols,

so some type that knows:

• how to establish a new stream
• yields PeerMessages

  reth/crates/net/network/src/session/active.rs

  Lines 70 to 71 in b97d9b4

  	/// The underlying connection.
  	pub(crate) conn: EthRlpxConnection<N>,

This is a significant change and should be done in multiple steps
First we should introduce a stateful authenticator style type that knows how to establish incoming and outgoing connections (still restricted to the default eth types)
Afterwards we can slow relax the EthMessage locking and make it possible to configure a modified eth protocol for example.

Additional context

No response

[nadtech-hub]

I would like to work on this one too