feat(l1): discv5 server

cmd/ethrex/cli.rs

@@ -15,10 +15,8 @@ use ethrex_blockchain::{
 };
 use ethrex_common::types::{Block, DEFAULT_BUILDER_GAS_CEIL, Genesis, validate_block_body};
 use ethrex_p2p::{
-    discv4::{peer_table::TARGET_PEERS, server::INITIAL_LOOKUP_INTERVAL_MS},
-    sync::SyncMode,
-    tx_broadcaster::BROADCAST_INTERVAL_MS,
-    types::Node,
+    discv4::server::INITIAL_LOOKUP_INTERVAL_MS, peer_table::TARGET_PEERS, sync::SyncMode,
+    tx_broadcaster::BROADCAST_INTERVAL_MS, types::Node,
 };
 use ethrex_rlp::encode::RLPEncode;
 use ethrex_storage::error::StoreError;

cmd/ethrex/ethrex.rs

@@ -4,7 +4,7 @@ use ethrex::{
     initializers::{init_l1, init_tracing},
     utils::{NodeConfigFile, get_client_version, is_memory_datadir, store_node_config_file},
 };
-use ethrex_p2p::{discv4::peer_table::PeerTable, types::NodeRecord};
+use ethrex_p2p::{peer_table::PeerTable, types::NodeRecord};
 use serde::Deserialize;
 use std::{path::Path, time::Duration};
 use tokio::signal::unix::{SignalKind, signal};

cmd/ethrex/initializers.rs

@@ -14,9 +14,9 @@ use ethrex_metrics::profiling::{FunctionProfilingLayer, initialize_block_process
 use ethrex_metrics::rpc::initialize_rpc_metrics;
 use ethrex_p2p::rlpx::initiator::RLPxInitiator;
 use ethrex_p2p::{
-    discv4::peer_table::PeerTable,
     network::P2PContext,
     peer_handler::PeerHandler,
+    peer_table::PeerTable,
     sync::SyncMode,
     sync_manager::SyncManager,
     types::{Node, NodeRecord},

cmd/ethrex/utils.rs

@@ -3,7 +3,7 @@ use bytes::Bytes;
 use directories::ProjectDirs;
 use ethrex_common::types::{Block, Genesis};
 use ethrex_p2p::{
-    discv4::peer_table::PeerTable,
+    peer_table::PeerTable,
     sync::SyncMode,
     types::{Node, NodeRecord},
 };

crates/common/rlp/structs.rs

@@ -117,6 +117,10 @@ impl<'a> Decoder<'a> {
     pub const fn finish_unchecked(self) -> &'a [u8] {
         self.remaining
     }
+
+    pub const fn get_payload_len(&self) -> usize {
+        self.payload.len()
+    }
 }
 
 fn field_decode_error<T>(field_name: &str, err: RLPDecodeError) -> RLPDecodeError {

crates/networking/p2p/discv4/server.rs

@@ -5,9 +5,9 @@ use crate::{
             ENRRequestMessage, ENRResponseMessage, FindNodeMessage, Message, NeighborsMessage,
             Packet, PacketDecodeErr, PingMessage, PongMessage,
         },
-        peer_table::{Contact, OutMessage as PeerTableOutMessage, PeerTable, PeerTableError},
     },
     metrics::METRICS,
+    peer_table::{Contact, OutMessage as PeerTableOutMessage, PeerTable, PeerTableError},
     types::{Endpoint, Node, NodeRecord},
     utils::{
         get_msg_expiration_from_seconds, is_msg_expired, node_id, public_key_from_signing_key,
@@ -98,7 +98,7 @@ impl DiscoveryServer {
         storage: Store,
         local_node: Node,
         signer: SecretKey,
-        udp_socket: Arc<UdpSocket>,
+        udp_socket: UdpSocket,
         mut peer_table: PeerTable,
         bootnodes: Vec<Node>,
         initial_lookup_interval: f64,
@@ -117,7 +117,7 @@ impl DiscoveryServer {
             local_node: local_node.clone(),
             local_node_record,
             signer,
-            udp_socket,
+            udp_socket: Arc::new(udp_socket),
             store: storage.clone(),
             peer_table: peer_table.clone(),
             find_node_message: Self::random_message(&signer),

crates/networking/p2p/discv5/codec.rs

@@ -1,52 +1,17 @@
 use crate::discv5::messages::{Packet, PacketCodecError};
-use crate::discv5::session::Session;
 
 use bytes::BytesMut;
 use ethrex_common::H256;
-use rand::{RngCore, thread_rng};
 use tokio_util::codec::{Decoder, Encoder};
 
 #[derive(Debug)]
 pub struct Discv5Codec {
-    dest_id: H256,
-    /// Outgoing message count, used for nonce generation as per the spec.
-    counter: u32,
-    session: Option<Session>,
+    local_node_id: H256,
 }
 
 impl Discv5Codec {
-    pub fn new(dest_id: H256) -> Self {
-        Self {
-            dest_id,
-            counter: 0,
-            session: None,
-        }
-    }
-
-    pub fn with_session(dest_id: H256, session: Session) -> Self {
-        Self {
-            dest_id,
-            counter: 0,
-            session: Some(session),
-        }
-    }
-
-    pub fn set_session(&mut self, session: Session) {
-        self.session = Some(session);
-    }
-
-    /// Generates a 96-bit AES-GCM nonce
-    /// ## Spec Recommendation
-    /// Encode the current outgoing message count into the first 32 bits of the nonce and fill the remaining 64 bits with random data generated
-    /// by a cryptographically secure random number generator.
-    pub fn next_nonce<R: RngCore>(&mut self, rng: &mut R) -> [u8; 12] {
-        let counter = self.counter;
-        self.counter = self.counter.wrapping_add(1);
-
-        let mut nonce = [0u8; 12];
-        nonce[..4].copy_from_slice(&counter.to_be_bytes());
-        rng.fill_bytes(&mut nonce[4..]);
-        nonce
+    pub fn new(local_node_id: H256) -> Self {
+        Self { local_node_id }
     }
 }
 
@@ -56,13 +21,8 @@ impl Decoder for Discv5Codec {
 
     fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
         if !buf.is_empty() {
-            let key: &[u8; 16] = match &self.session {
-                Some(session) => session.inbound_key(),
-                None => &[0; 16],
-            };
             Ok(Some(Packet::decode(
-                &self.dest_id,
-                key,
+                &self.local_node_id,
                 &buf.split_to(buf.len()),
             )?))
         } else {
@@ -74,17 +34,8 @@ impl Decoder for Discv5Codec {
 impl Encoder<Packet> for Discv5Codec {
     type Error = PacketCodecError;
 
-    fn encode(&mut self, packet: Packet, buf: &mut BytesMut) -> Result<(), Self::Error> {
-        let masking_iv: u128 = rand::random();
-        let mut rng = thread_rng();
-        let nonce = self.next_nonce(&mut rng);
-        // key isnt needed in WHOAREYOU packets
-        let key = match (&packet, &mut self.session) {
-            (Packet::WhoAreYou(_), _) => &[][..],
-            (_, Some(session)) => session.outbound_key(),
-            (_, None) => return Err(PacketCodecError::SessionNotEstablished),
-        };
-
-        packet.encode(buf, masking_iv, &nonce, &self.dest_id, key)
+    fn encode(&mut self, _packet: Packet, _buf: &mut BytesMut) -> Result<(), Self::Error> {
+        // We are not going to use Discv5Coded to send messages, only to receive them
+        unimplemented!();
     }
 }