feat(l1): kademlia k-bucket routing table v2

cmd/ethrex/initializers.rs

@@ -530,7 +530,8 @@ pub async fn init_l1(
 
     let local_node_record = get_local_node_record(&datadir, &local_p2p_node, &signer);
 
-    let peer_table = PeerTableServer::spawn(opts.target_peers, store.clone());
+    let peer_table =
+        PeerTableServer::spawn(local_p2p_node.node_id(), opts.target_peers, store.clone());
 
     // TODO: Check every module starts properly.
     let tracker = TaskTracker::new();

cmd/ethrex/l2/initializers.rs

@@ -241,7 +241,11 @@ pub async fn init_l2(
         if !opts.sequencer_opts.based {
             blockchain.set_synced();
         }
-        let peer_table = PeerTableServer::spawn(opts.node_opts.target_peers, store.clone());
+        let peer_table = PeerTableServer::spawn(
+            local_p2p_node.node_id(),
+            opts.node_opts.target_peers,
+            store.clone(),
+        );
         let p2p_context = P2PContext::new(
             local_p2p_node.clone(),
             network_config,

crates/blockchain/metrics/p2p.rs

@@ -98,7 +98,7 @@ impl MetricsP2P {
             kademlia_insert_contact_duration: Histogram::with_opts(
                 HistogramOpts::new(
                     "ethrex_kademlia_insert_contact_duration_seconds",
-                    "Duration of peer table contact insertion operations",
+                    "Duration of Kademlia insert_contact operations",
                 )
                 .buckets(vec![
                     0.000_001, 0.000_005, 0.000_01, 0.000_05, 0.000_1, 0.000_5, 0.001, 0.01,
@@ -108,7 +108,7 @@ impl MetricsP2P {
             kademlia_iter_contacts_duration: Histogram::with_opts(
                 HistogramOpts::new(
                     "ethrex_kademlia_iter_contacts_duration_seconds",
-                    "Duration of peer table full-scan operations",
+                    "Duration of Kademlia iter_contacts full-scan operations",
                 )
                 .buckets(vec![
                     0.000_01, 0.000_05, 0.000_1, 0.000_5, 0.001, 0.005, 0.01, 0.05, 0.1,

crates/networking/p2p/discv4/server.rs

@@ -139,11 +139,7 @@ impl DiscoveryServer {
             "Adding bootnodes"
         );
 
-        peer_table.new_contacts(
-            bootnodes.clone(),
-            local_node.node_id(),
-            DiscoveryProtocol::Discv4,
-        )?;
+        peer_table.new_contacts(bootnodes.clone(), DiscoveryProtocol::Discv4)?;
 
         for bootnode in &bootnodes {
             discovery_server.send_ping(bootnode).await?;
@@ -608,11 +604,8 @@ impl DiscoveryServer {
         }
 
         let nodes = neighbors_message.nodes;
-        self.peer_table.new_contacts(
-            nodes,
-            self.local_node.node_id(),
-            DiscoveryProtocol::Discv4,
-        )?;
+        self.peer_table
+            .new_contacts(nodes, DiscoveryProtocol::Discv4)?;
         Ok(())
     }
 

crates/networking/p2p/discv5/server.rs

@@ -201,7 +201,7 @@ impl DiscoveryServer {
             count = bootnodes.len(),
             "Adding bootnodes"
         );
-        peer_table.new_contacts(bootnodes, local_node.node_id(), DiscoveryProtocol::Discv5)?;
+        peer_table.new_contacts(bootnodes, DiscoveryProtocol::Discv5)?;
 
         Ok(discovery_server.start())
     }
@@ -529,8 +529,7 @@ impl DiscoveryServer {
 
         // Add the peer to the peer table
         if let Some(record) = &authdata.record {
-            self.peer_table
-                .new_contact_records(vec![record.clone()], self.local_node.node_id())?;
+            self.peer_table.new_contact_records(vec![record.clone()])?;
         }
 
         // Derive session keys (we are the recipient, node B)
@@ -725,10 +724,7 @@ impl DiscoveryServer {
         // Per spec, distance 0 means the node itself — include the local ENR explicitly.
         let mut nodes = self
             .peer_table
-            .get_nodes_at_distances(
-                self.local_node.node_id(),
-                find_node_message.distances.clone(),
-            )
+            .get_nodes_at_distances(find_node_message.distances.clone())
             .await?;
         if find_node_message.distances.contains(&0) {
             nodes.push(self.local_node_record.clone());
@@ -776,8 +772,7 @@ impl DiscoveryServer {
         nodes_message: NodesMessage,
     ) -> Result<(), DiscoveryServerError> {
         // TODO(#3746): check that we requested neighbors from the node
-        self.peer_table
-            .new_contact_records(nodes_message.nodes, self.local_node.node_id())?;
+        self.peer_table.new_contact_records(nodes_message.nodes)?;
         Ok(())
     }
 
@@ -1338,12 +1333,14 @@ mod tests {
         ).expect("Bad enode url");
         let signer = SecretKey::new(&mut rand::rngs::OsRng);
         let local_node_record = NodeRecord::from_node(&local_node, 1, &signer).unwrap();
+        let local_node_id = local_node.node_id();
         let mut server = DiscoveryServer {
             local_node,
             local_node_record,
             signer,
             udp_socket: Arc::new(UdpSocket::bind("127.0.0.1:30303").await.unwrap()),
             peer_table: PeerTableServer::spawn(
+                local_node_id,
                 10,
                 Store::new("", EngineType::InMemory).expect("Failed to create store"),
             ),
@@ -1379,12 +1376,14 @@ mod tests {
         let signer = SecretKey::new(&mut rand::rngs::OsRng);
         let local_node_record = NodeRecord::from_node(&local_node, 1, &signer).unwrap();
         // Use port 0 to let the OS assign an available port
+        let local_node_id = local_node.node_id();
         let mut server = DiscoveryServer {
             local_node,
             local_node_record,
             signer,
             udp_socket: Arc::new(UdpSocket::bind("127.0.0.1:0").await.unwrap()),
             peer_table: PeerTableServer::spawn(
+                local_node_id,
                 10,
                 Store::new("", EngineType::InMemory).expect("Failed to create store"),
             ),
@@ -1463,14 +1462,13 @@ mod tests {
         let remote_node_id = remote_node.node_id();
 
         let peer_table = PeerTableServer::spawn(
+            local_node.node_id(),
             10,
             Store::new("", EngineType::InMemory).expect("Failed to create store"),
         );
 
         // Add the remote node as a contact with its ENR record
-        peer_table
-            .new_contact_records(vec![remote_record], local_node.node_id())
-            .unwrap();
+        peer_table.new_contact_records(vec![remote_record]).unwrap();
 
         // Set up a session for the remote node (required for send_ordinary)
         let session = Session {
@@ -1567,12 +1565,14 @@ mod tests {
         let local_node_record = NodeRecord::from_node(&local_node, 1, &signer).unwrap();
         let original_seq = local_node_record.seq;
 
+        let local_node_id = local_node.node_id();
         let mut server = DiscoveryServer {
             local_node,
             local_node_record,
             signer,
             udp_socket: Arc::new(UdpSocket::bind("127.0.0.1:0").await.unwrap()),
             peer_table: PeerTableServer::spawn(
+                local_node_id,
                 10,
                 Store::new("", EngineType::InMemory).expect("Failed to create store"),
             ),
@@ -1624,12 +1624,14 @@ mod tests {
         let signer = SecretKey::new(&mut rand::rngs::OsRng);
         let local_node_record = NodeRecord::from_node(&local_node, 1, &signer).unwrap();
 
+        let local_node_id = local_node.node_id();
         let mut server = DiscoveryServer {
             local_node,
             local_node_record,
             signer,
             udp_socket: Arc::new(UdpSocket::bind("127.0.0.1:0").await.unwrap()),
             peer_table: PeerTableServer::spawn(
+                local_node_id,
                 10,
                 Store::new("", EngineType::InMemory).expect("Failed to create store"),
             ),
@@ -1673,12 +1675,14 @@ mod tests {
         let local_node_record = NodeRecord::from_node(&local_node, 1, &signer).unwrap();
         let original_seq = local_node_record.seq;
 
+        let local_node_id = local_node.node_id();
         let mut server = DiscoveryServer {
             local_node,
             local_node_record,
             signer,
             udp_socket: Arc::new(UdpSocket::bind("127.0.0.1:0").await.unwrap()),
             peer_table: PeerTableServer::spawn(
+                local_node_id,
                 10,
                 Store::new("", EngineType::InMemory).expect("Failed to create store"),
             ),
@@ -1727,12 +1731,14 @@ mod tests {
         let signer = SecretKey::new(&mut rand::rngs::OsRng);
         let local_node_record = NodeRecord::from_node(&local_node, 1, &signer).unwrap();
 
+        let local_node_id = local_node.node_id();
         let mut server = DiscoveryServer {
             local_node,
             local_node_record,
             signer,
             udp_socket: Arc::new(UdpSocket::bind("127.0.0.1:0").await.unwrap()),
             peer_table: PeerTableServer::spawn(
+                local_node_id,
                 10,
                 Store::new("", EngineType::InMemory).expect("Failed to create store"),
             ),
@@ -1785,12 +1791,14 @@ mod tests {
         let signer = SecretKey::new(&mut rand::rngs::OsRng);
         let local_node_record = NodeRecord::from_node(&local_node, 1, &signer).unwrap();
 
+        let local_node_id = local_node.node_id();
         let mut server = DiscoveryServer {
             local_node,
             local_node_record,
             signer,
             udp_socket: Arc::new(UdpSocket::bind("127.0.0.1:0").await.unwrap()),
             peer_table: PeerTableServer::spawn(
+                local_node_id,
                 10,
                 Store::new("", EngineType::InMemory).expect("Failed to create store"),
             ),
@@ -1836,12 +1844,14 @@ mod tests {
         let signer = SecretKey::new(&mut rand::rngs::OsRng);
         let local_node_record = NodeRecord::from_node(&local_node, 1, &signer).unwrap();
 
+        let local_node_id = local_node.node_id();
         let mut server = DiscoveryServer {
             local_node,
             local_node_record,
             signer,
             udp_socket: Arc::new(UdpSocket::bind("127.0.0.1:0").await.unwrap()),
             peer_table: PeerTableServer::spawn(
+                local_node_id,
                 10,
                 Store::new("", EngineType::InMemory).expect("Failed to create store"),
             ),

crates/networking/p2p/peer_handler.rs

@@ -90,6 +90,8 @@ async fn ask_peer_head_number(
         }
         Ok(_other_msgs) => Err(PeerHandlerError::UnexpectedResponseFromPeer(peer_id)),
         Err(PeerConnectionError::Timeout) => {
+            // Mark this peer as disposable so it gets pruned and replaced
+            let _ = peer_table.set_disposable(peer_id);
             Err(PeerHandlerError::ReceiveMessageFromPeerTimeout(peer_id))
         }
         Err(_other_err) => Err(PeerHandlerError::ReceiveMessageFromPeer(peer_id)),
@@ -464,13 +466,15 @@ impl PeerHandler {
                         warn!(
                             "[SYNCING] Received empty/invalid headers from peer, penalizing peer {peer_id}"
                         );
+                        let _ = self.peer_table.set_disposable(peer_id);
                         return Ok(None);
                     }
                 }
-                // Timeouted
+                // Timeout or invalid response - mark peer as disposable
                 warn!(
                     "[SYNCING] Didn't receive block headers from peer, penalizing peer {peer_id}..."
                 );
+                let _ = self.peer_table.set_disposable(peer_id);
                 Ok(None)
             }
         }
@@ -552,6 +556,7 @@ impl PeerHandler {
                     "[SYNCING] Didn't receive block bodies from peer, penalizing peer {peer_id}..."
                 );
                 self.peer_table.record_failure(peer_id)?;
+                let _ = self.peer_table.set_disposable(peer_id);
                 Ok(None)
             }
         }