chore(deps): serve the ENR we report, on the ethrex branch tip

Bumps ethrex to the feat/discovery-peer-requirements tip (f30b16d5 ->
bf401280, rebased onto main 24.0.0), which reworks `DiscoveryServer::spawn`
to take a prepared `NodeRecord` instead of a `Store` it derived one from.

That closes the gap docs/discovery.md called "the record ethrex serves is
not the record we report": ethrex built its own copy from the local `Node`,
so what it answered discv5 queries with carried `ip`, `udp` and `secp256k1`
but none of `eth2`, `attnets` or `quic`. A lean peer applying our own
admission rules to that record rejected us for the missing `quic` entry, so
discovery found peers but could not be found by them. We now hand `spawn`
the same record `enr_url` reports, and ethrex edits and re-signs it on IP
voting rather than rebuilding, so the consensus entries survive a sequence
bump.

The empty in-memory ethrex `Store` existed only to satisfy the old
signature, so both it and the `ethrex-storage` dependency go, along with
the `DiscoveryError::Store` variant that could no longer be constructed.

Author: MegaRedHand

CLAUDE.md

@@ -282,7 +282,7 @@ actual_slot = finalized_slot + 1 + relative_index
 
 ### Peer Discovery (discv5, opt-in)
 - Off by default; `--discovery.enable` plus `--discovery.port` (own UDP socket, must differ from `--gossipsub-port`)
-- Reuses ethrex's `DiscoveryServer` + `PeerTable` with discv4 disabled and an empty in-memory ethrex `Store` (`spawn` requires one; lean has no execution chain)
+- Reuses ethrex's `DiscoveryServer` + `PeerTable` with discv4 disabled; `spawn` takes the prepared lean ENR, so the record ethrex serves is the one we report
 - ENR follows the beacon phase0 spec: `ip`/`udp`/`quic`/`secp256k1`/`eth2`/`attnets`, deliberately **no** `tcp`
 - Admission mirrors lighthouse: `eth2.fork_digest` must match, `next_fork_*` may differ, `quic` entry required. Handed to the peer table as `LeanFilter: PeerFilter`, so records are judged on arrival, not at dial time; a reject is re-judged on a higher-`seq` ENR
 - Candidates ranked by uncovered attestation subnets. See [`docs/discovery.md`](docs/discovery.md)

Cargo.lock

@@ -44,8 +44,6 @@ rand = "0.8"
 ethrex-p2p = { git = "https://github.com/lambdaclass/ethrex", branch = "feat/discovery-peer-requirements" }
 ethrex-rlp = { git = "https://github.com/lambdaclass/ethrex", branch = "feat/discovery-peer-requirements" }
 ethrex-common = { git = "https://github.com/lambdaclass/ethrex", branch = "feat/discovery-peer-requirements" }
-# Only for the empty in-memory Store that DiscoveryServer::spawn requires.
-ethrex-storage = { git = "https://github.com/lambdaclass/ethrex", branch = "feat/discovery-peer-requirements" }
 
 # Version pinned to ethrex's workspace: `SecretKey` crosses the API boundary.
 secp256k1 = { version = "0.30.0", default-features = false, features = ["global-context"] }

crates/net/p2p/Cargo.toml

@@ -19,7 +19,6 @@ use std::time::Duration;
 use ethrex_p2p::discovery::{DiscoveryConfig, DiscoveryServer};
 use ethrex_p2p::peer_table::{PeerTable, PeerTableServer};
 use ethrex_p2p::types::Node;
-use ethrex_storage::{EngineType, Store};
 use tokio::net::UdpSocket;
 use tracing::{info, warn};
 
@@ -51,8 +50,6 @@ pub enum DiscoveryError {
     BuildEnr(ethrex_p2p::types::NodeError),
     #[error("failed to encode local ENR: {0}")]
     EncodeEnr(ethrex_p2p::types::NodeError),
-    #[error("failed to create the discovery store: {0}")]
-    Store(String),
     #[error("failed to start discovery server: {0}")]
     Server(String),
     #[error("node key is not a valid secp256k1 secret key: {0}")]
@@ -151,18 +148,14 @@ pub async fn spawn_discovery(
         "Starting discv5 discovery"
     );
 
-    // `spawn` requires a store but the discv5 path reads it only for
-    // `get_fork_id`, which errors on a store with no genesis block and makes
-    // ethrex skip the `eth` entry — what lean wants, having no execution chain.
-    // That the record ethrex then serves is *not* the complete one we report is
-    // a known gap; see docs/discovery.md, "The record ethrex serves is not the
-    // record we report".
-    let store = Store::new("", EngineType::InMemory)
-        .map_err(|err| DiscoveryError::Store(err.to_string()))?;
-
+    // The record we hand over is the same one `enr_url` above reported, so what
+    // ethrex answers discv5 queries with carries the consensus entries (`eth2`,
+    // `attnets`, `quic`) and a lean peer applying our own admission rules to it
+    // admits us. ethrex re-signs it under `params.signer` whenever IP voting
+    // bumps the sequence number, keeping the extra entries.
     DiscoveryServer::spawn(
-        store,
         local_node,
+        local_record,
         params.signer,
         Arc::new(socket),
         peer_table.clone(),

crates/net/p2p/src/discovery/mod.rs

@@ -58,6 +58,12 @@ and ethlambda speaks QUIC only.
 Read the local ENR from `GET /lean/v0/node/identity`, which reports it as `enr`
 (`null` when discovery is disabled). It is also logged once at startup.
 
+This same record is handed to ethrex's `DiscoveryServer`, so it is what answers
+discv5 queries: what we report and what peers see are the same bytes. If IP
+voting later changes our external address, ethrex edits and re-signs that record
+rather than rebuilding one, so the consensus entries survive the bump; only the
+sequence number and `ip` move, which the reported ENR then lags.
+
 ## Which peers get dialed
 
 A discovered peer is admitted only if:
@@ -131,23 +137,6 @@ another**: two devnets running this code will peer with each other. Closing that
 gap requires lean adopting a genesis-derived fork digest, which is a
 cross-client change to gossip topic names.
 
-### The record ethrex serves is not the record we report
-
-`GET /lean/v0/node/identity` reports the ENR built by `build_local_enr`, which
-carries every entry in the table above. ethrex's `DiscoveryServer` builds its
-own copy from the local `Node` and offers no way to seed the consensus entries,
-so the record it answers discv5 queries with carries `ip`, `udp` and
-`secp256k1` but **not** `eth2`, `attnets` or `quic`.
-
-Discovery is therefore one-sided: we find lean peers and admit them, but a lean
-peer applying [the same admission rules](#which-peers-get-dialed) to what ethrex
-serves rejects us for a missing `quic` entry. Copying our reported ENR into
-another node's bootnode list still works, since that is the complete record.
-
-Closing this needs a way to hand ethrex's `DiscoveryServer::spawn` a prepared
-record instead of having it build one. Until then, discovery finds peers but
-cannot be found by them.
-
 ### A beacon-chain client cannot discover us, and `tcp` is why
 
 Beyond the fork digest never matching a real beacon network, there is a second,