feat(l1): add "eth" entry to local ENR

cmd/ethrex/initializers.rs

@@ -333,15 +333,15 @@ pub fn get_local_node_record(
 ) -> NodeRecord {
     match read_node_config_file(datadir) {
         Ok(Some(ref mut config)) => {
-            NodeRecord::from_node(local_p2p_node, config.node_record.seq + 1, signer)
+            NodeRecord::from_node(local_p2p_node, config.node_record.seq + 1, signer, None)
                 .expect("Node record could not be created from local node")
         }
         _ => {
             let timestamp = SystemTime::now()
                 .duration_since(UNIX_EPOCH)
                 .unwrap_or_default()
                 .as_secs();
-            NodeRecord::from_node(local_p2p_node, timestamp, signer)
+            NodeRecord::from_node(local_p2p_node, timestamp, signer, None)
                 .expect("Node record could not be created from local node")
         }
     }

crates/networking/p2p/discv4/server.rs

@@ -15,6 +15,7 @@ use crate::{
 };
 use bytes::BytesMut;
 use ethrex_common::{H256, H512};
+use ethrex_storage::Store;
 use futures::StreamExt;
 use rand::rngs::OsRng;
 use secp256k1::SecretKey;
@@ -89,6 +90,7 @@ pub struct DiscoveryServer {
 
 impl DiscoveryServer {
     pub async fn spawn(
+        storage: Store,
         local_node: Node,
         signer: SecretKey,
         udp_socket: Arc<UdpSocket>,
@@ -97,7 +99,8 @@ impl DiscoveryServer {
     ) -> Result<(), DiscoveryServerError> {
         info!("Starting Discovery Server");
 
-        let local_node_record = NodeRecord::from_node(&local_node, 1, &signer)
+        let fork_id = storage.get_fork_id().await.ok();
+        let local_node_record = NodeRecord::from_node(&local_node, 1, &signer, fork_id)
             .expect("Failed to create local node record");
         let mut discovery_server = Self {
             local_node: local_node.clone(),

crates/networking/p2p/network.rs

@@ -111,6 +111,7 @@ pub async fn start_network(context: P2PContext, bootnodes: Vec<Node>) -> Result<
     );
 
     DiscoveryServer::spawn(
+        context.storage.clone(),
         context.local_node.clone(),
         context.signer,
         udp_socket.clone(),

crates/networking/p2p/types.rs

@@ -347,11 +347,26 @@ impl NodeRecord {
         Ok(result)
     }
 
-    pub fn from_node(node: &Node, seq: u64, signer: &SecretKey) -> Result<Self, NodeError> {
+    pub fn from_node(
+        node: &Node,
+        seq: u64,
+        signer: &SecretKey,
+        fork_id: Option<ForkId>,
+    ) -> Result<Self, NodeError> {
         let mut record = NodeRecord {
             seq,
             ..Default::default()
         };
+        if let Some(fork_id) = fork_id {
+            // Without the Vec wrapper, RLP encoding fork_id directly would produce:
+            // [forkHash, forkNext]
+            // But the spec requires nested lists:
+            // [[forkHash, forkNext]]
+            let eth = vec![fork_id];
+            record
+                .pairs
+                .push(("eth".into(), eth.encode_to_vec().into()));
+        }
         record
             .pairs
             .push(("id".into(), "v4".encode_to_vec().into()));
@@ -402,6 +417,11 @@ impl From<NodeRecordPairs> for Vec<(Bytes, Bytes)> {
     fn from(value: NodeRecordPairs) -> Self {
         let mut pairs = vec![];
         if let Some(eth) = value.eth {
+            // Without the Vec wrapper, RLP encoding fork_id directly would produce:
+            // [forkHash, forkNext]
+            // But the spec requires nested lists:
+            // [[forkHash, forkNext]]
+            let eth = vec![eth];
             pairs.push(("eth".into(), eth.encode_to_vec().into()));
         }
         if let Some(id) = value.id {
@@ -500,6 +520,7 @@ mod tests {
         utils::public_key_from_signing_key,
     };
     use ethrex_common::H512;
+    use ethrex_rlp::decode::RLPDecode;
     use ethrex_storage::{EngineType, Store};
     use secp256k1::SecretKey;
     use std::{net::SocketAddr, str::FromStr};
@@ -581,7 +602,7 @@ mod tests {
             addr.port(),
             public_key_from_signing_key(&signer),
         );
-        let mut record = NodeRecord::from_node(&node, 1, &signer).unwrap();
+        let mut record = NodeRecord::from_node(&node, 1, &signer, None).unwrap();
         // Drop fork ID since the test doesn't use it
         record.pairs.retain(|(k, _)| k != "eth");
         record.sign_record(&signer).unwrap();
@@ -590,4 +611,39 @@ mod tests {
 
         assert_eq!(record.enr_url().unwrap(), expected_enr_string);
     }
+
+    #[tokio::test]
+    async fn encode_decode_node_record_with_forkid() {
+        let signer = SecretKey::from_slice(&[
+            16, 125, 177, 238, 167, 212, 168, 215, 239, 165, 77, 224, 199, 143, 55, 205, 9, 194,
+            87, 139, 92, 46, 30, 191, 74, 37, 68, 242, 38, 225, 104, 246,
+        ])
+        .unwrap();
+        let addr = std::net::SocketAddr::from_str("127.0.0.1:30303").unwrap();
+
+        let mut storage =
+            Store::new("", EngineType::InMemory).expect("Failed to create in-memory storage");
+        storage
+            .add_initial_state(serde_json::from_str(TEST_GENESIS).unwrap())
+            .await
+            .expect("Failed to build test genesis");
+
+        let node = Node::new(
+            addr.ip(),
+            addr.port(),
+            addr.port(),
+            public_key_from_signing_key(&signer),
+        );
+        let fork_id = storage.get_fork_id().await.unwrap();
+
+        let record = NodeRecord::from_node(&node, 1, &signer, Some(fork_id.clone())).unwrap();
+        record.sign_record(&signer).unwrap();
+
+        let enr_url = record.enr_url().unwrap();
+        let base64_decoded = ethrex_common::base64::decode(&enr_url.as_bytes()[4..]);
+        let parsed_record = NodeRecord::decode(&base64_decoded).unwrap();
+        let pairs = parsed_record.decode_pairs();
+
+        assert_eq!(pairs.eth, Some(fork_id));
+    }
 }

crates/networking/rpc/admin/peers.rs

@@ -167,7 +167,7 @@ mod tests {
     fn test_peer_data_to_serialized_peer() {
         // Test that we can correctly serialize an active Peer
         let node = Node::from_enode_url("enode://4aeb4ab6c14b23e2c4cfdce879c04b0748a20d8e9b59e25ded2a08143e265c6c25936e74cbc8e641e3312ca288673d91f2f93f8e277de3cfa444ecdaaf982052@157.90.35.166:30303").unwrap();
-        let record = NodeRecord::from_node(&node, 17, &SecretKey::new(&mut OsRng)).unwrap();
+        let record = NodeRecord::from_node(&node, 17, &SecretKey::new(&mut OsRng), None).unwrap();
         let mut peer = PeerData::new(
             node,
             Some(record),

crates/networking/rpc/test_utils.rs

@@ -208,7 +208,7 @@ pub fn example_local_node_record() -> NodeRecord {
     let node = Node::new("127.0.0.1".parse().unwrap(), 30303, 30303, public_key_1);
     let signer = SecretKey::new(&mut rand::rngs::OsRng);
 
-    NodeRecord::from_node(&node, 1, &signer).unwrap()
+    NodeRecord::from_node(&node, 1, &signer, None).unwrap()
 }
 
 // Util to start an api for testing on ports 8500 and 8501,