reth_network_peers/
lib.rs

1//! Network Types and Utilities.
2//!
3//! This crate manages and converts Ethereum network entities such as node records, peer IDs, and
4//! Ethereum Node Records (ENRs)
5//!
6//! ## An overview of Node Record types
7//!
8//! Ethereum uses different types of "node records" to represent peers on the network.
9//!
10//! The simplest way to identify a peer is by public key. This is the [`PeerId`] type, which usually
11//! represents a peer's secp256k1 public key.
12//!
13//! A more complete representation of a peer is the [`NodeRecord`] type, which includes the peer's
14//! IP address, the ports where it is reachable (TCP and UDP), and the peer's public key. This is
15//! what is returned from discovery v4 queries.
16//!
17//! The most comprehensive node record type is the Ethereum Node Record ([`Enr`]), which is a
18//! signed, versioned record that includes the information from a [`NodeRecord`] along with
19//! additional metadata. This is the data structure returned from discovery v5 queries.
20//!
21//! When we need to deserialize an identifier that could be any of these three types ([`PeerId`],
22//! [`NodeRecord`], and [`Enr`]), we use the [`AnyNode`] type, which is an enum over the three
23//! types. [`AnyNode`] is used in reth's `admin_addTrustedPeer` RPC method.
24//!
25//! The __final__ type is the [`TrustedPeer`] type, which is similar to a [`NodeRecord`] but may
26//! include a domain name instead of a direct IP address. It includes a `resolve` method, which can
27//! be used to resolve the domain name, producing a [`NodeRecord`]. This is useful for adding
28//! trusted peers at startup, whose IP address may not be static each time the node starts. This is
29//! common in orchestrated environments like Kubernetes, where there is reliable service discovery,
30//! but services do not necessarily have static IPs.
31//!
32//! In short, the types are as follows:
33//! - [`PeerId`]: A simple public key identifier.
34//! - [`NodeRecord`]: A more complete representation of a peer, including IP address and ports.
35//! - [`Enr`]: An Ethereum Node Record, which is a signed, versioned record that includes additional
36//!   metadata. Useful when interacting with discovery v5, or when custom metadata is required.
37//! - [`AnyNode`]: An enum over [`PeerId`], [`NodeRecord`], and [`Enr`], useful in deserialization
38//!   when the type of the node record is not known.
39//! - [`TrustedPeer`]: A [`NodeRecord`] with an optional domain name, which can be resolved to a
40//!   [`NodeRecord`]. Useful for adding trusted peers at startup, whose IP address may not be
41//!   static.
42//!
43//!
44//! ## Feature Flags
45//!
46//! - `net`: Support for address lookups.
47
48#![doc(
49    html_logo_url = "https://raw.githubusercontent.com/paradigmxyz/reth/main/assets/reth-docs.png",
50    html_favicon_url = "https://avatars0.githubusercontent.com/u/97369466?s=256",
51    issue_tracker_base_url = "https://github.com/paradigmxyz/reth/issues/"
52)]
53#![cfg_attr(not(test), warn(unused_crate_dependencies))]
54#![cfg_attr(docsrs, feature(doc_cfg))]
55#![cfg_attr(not(feature = "std"), no_std)]
56
57extern crate alloc;
58
59use alloc::{
60    format,
61    string::{String, ToString},
62};
63use alloy_primitives::B512;
64use core::str::FromStr;
65
66// Re-export PeerId for ease of use.
67#[cfg(feature = "secp256k1")]
68pub use enr::Enr;
69
70/// Alias for a peer identifier
71pub type PeerId = B512;
72
73pub mod node_record;
74pub use node_record::{NodeRecord, NodeRecordParseError};
75
76pub mod trusted_peer;
77pub use trusted_peer::TrustedPeer;
78
79mod bootnodes;
80pub use bootnodes::*;
81
82/// This tag should be set to indicate to libsecp256k1 that the following bytes denote an
83/// uncompressed pubkey.
84///
85/// `SECP256K1_TAG_PUBKEY_UNCOMPRESSED` = `0x04`
86///
87/// See: <https://github.com/bitcoin-core/secp256k1/blob/master/include/secp256k1.h#L211>
88#[cfg(feature = "secp256k1")]
89const SECP256K1_TAG_PUBKEY_UNCOMPRESSED: u8 = 4;
90
91/// Converts a [`secp256k1::PublicKey`] to a [`PeerId`] by stripping the
92/// `SECP256K1_TAG_PUBKEY_UNCOMPRESSED` tag and storing the rest of the slice in the [`PeerId`].
93#[cfg(feature = "secp256k1")]
94#[inline]
95pub fn pk2id(pk: &secp256k1::PublicKey) -> PeerId {
96    PeerId::from_slice(&pk.serialize_uncompressed()[1..])
97}
98
99/// Converts a [`PeerId`] to a [`secp256k1::PublicKey`] by prepending the [`PeerId`] bytes with the
100/// `SECP256K1_TAG_PUBKEY_UNCOMPRESSED` tag.
101#[cfg(feature = "secp256k1")]
102#[inline]
103pub fn id2pk(id: PeerId) -> Result<secp256k1::PublicKey, secp256k1::Error> {
104    // NOTE: B512 is used as a PeerId because 512 bits is enough to represent an uncompressed
105    // public key.
106    let mut s = [0u8; secp256k1::constants::UNCOMPRESSED_PUBLIC_KEY_SIZE];
107    s[0] = SECP256K1_TAG_PUBKEY_UNCOMPRESSED;
108    s[1..].copy_from_slice(id.as_slice());
109    secp256k1::PublicKey::from_slice(&s)
110}
111
112/// A peer that can come in ENR or [`NodeRecord`] form.
113#[derive(
114    Debug, Clone, Eq, PartialEq, Hash, serde_with::SerializeDisplay, serde_with::DeserializeFromStr,
115)]
116pub enum AnyNode {
117    /// An "enode:" peer with full ip
118    NodeRecord(NodeRecord),
119    /// An "enr:" peer
120    #[cfg(feature = "secp256k1")]
121    Enr(Enr<secp256k1::SecretKey>),
122    /// An incomplete "enode" with only a peer id
123    PeerId(PeerId),
124}
125
126impl AnyNode {
127    /// Returns the peer id of the node.
128    #[cfg(not(feature = "secp256k1"))]
129    pub const fn peer_id(&self) -> PeerId {
130        match self {
131            Self::NodeRecord(record) => record.id,
132            Self::PeerId(peer_id) => *peer_id,
133        }
134    }
135
136    /// Returns the peer id of the node.
137    #[cfg(feature = "secp256k1")]
138    pub fn peer_id(&self) -> PeerId {
139        match self {
140            Self::NodeRecord(record) => record.id,
141            Self::Enr(enr) => pk2id(&enr.public_key()),
142            Self::PeerId(peer_id) => *peer_id,
143        }
144    }
145
146    /// Returns the full node record if available.
147    #[cfg(not(feature = "secp256k1"))]
148    pub const fn node_record(&self) -> Option<NodeRecord> {
149        match self {
150            Self::NodeRecord(record) => Some(*record),
151            Self::PeerId(_) => None,
152        }
153    }
154
155    /// Returns the full node record if available.
156    #[cfg(feature = "secp256k1")]
157    pub fn node_record(&self) -> Option<NodeRecord> {
158        match self {
159            Self::NodeRecord(record) => Some(*record),
160            Self::Enr(enr) => {
161                let node_record = NodeRecord {
162                    address: enr
163                        .ip4()
164                        .map(core::net::IpAddr::from)
165                        .or_else(|| enr.ip6().map(core::net::IpAddr::from))?,
166                    tcp_port: enr.tcp4().or_else(|| enr.tcp6())?,
167                    udp_port: enr.udp4().or_else(|| enr.udp6())?,
168                    id: pk2id(&enr.public_key()),
169                }
170                .into_ipv4_mapped();
171                Some(node_record)
172            }
173            Self::PeerId(_) => None,
174        }
175    }
176}
177
178impl From<NodeRecord> for AnyNode {
179    fn from(value: NodeRecord) -> Self {
180        Self::NodeRecord(value)
181    }
182}
183
184#[cfg(feature = "secp256k1")]
185impl From<Enr<secp256k1::SecretKey>> for AnyNode {
186    fn from(value: Enr<secp256k1::SecretKey>) -> Self {
187        Self::Enr(value)
188    }
189}
190
191impl FromStr for AnyNode {
192    type Err = String;
193
194    fn from_str(s: &str) -> Result<Self, Self::Err> {
195        if let Some(rem) = s.strip_prefix("enode://") {
196            if let Ok(record) = NodeRecord::from_str(s) {
197                return Ok(Self::NodeRecord(record))
198            }
199            // incomplete enode
200            if let Ok(peer_id) = PeerId::from_str(rem) {
201                return Ok(Self::PeerId(peer_id))
202            }
203            return Err(format!("invalid public key: {rem}"))
204        }
205        #[cfg(feature = "secp256k1")]
206        if s.starts_with("enr:") {
207            return Enr::from_str(s).map(AnyNode::Enr)
208        }
209        Err("missing 'enr:' prefix for base64-encoded record".to_string())
210    }
211}
212
213impl core::fmt::Display for AnyNode {
214    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
215        match self {
216            Self::NodeRecord(record) => write!(f, "{record}"),
217            #[cfg(feature = "secp256k1")]
218            Self::Enr(enr) => write!(f, "{enr}"),
219            Self::PeerId(peer_id) => {
220                write!(f, "enode://{}", alloy_primitives::hex::encode(peer_id.as_slice()))
221            }
222        }
223    }
224}
225
226/// Generic wrapper with peer id
227#[derive(Debug)]
228pub struct WithPeerId<T>(PeerId, pub T);
229
230impl<T> From<(PeerId, T)> for WithPeerId<T> {
231    fn from(value: (PeerId, T)) -> Self {
232        Self(value.0, value.1)
233    }
234}
235
236impl<T> WithPeerId<T> {
237    /// Wraps the value with the peerid.
238    pub const fn new(peer: PeerId, value: T) -> Self {
239        Self(peer, value)
240    }
241
242    /// Get the peer id
243    pub const fn peer_id(&self) -> PeerId {
244        self.0
245    }
246
247    /// Get the underlying data
248    pub const fn data(&self) -> &T {
249        &self.1
250    }
251
252    /// Returns ownership of the underlying data.
253    pub fn into_data(self) -> T {
254        self.1
255    }
256
257    /// Transform the data
258    pub fn transform<F: From<T>>(self) -> WithPeerId<F> {
259        WithPeerId(self.0, self.1.into())
260    }
261
262    /// Split the wrapper into [`PeerId`] and data tuple
263    pub fn split(self) -> (PeerId, T) {
264        (self.0, self.1)
265    }
266
267    /// Maps the inner value to a new value using the given function.
268    pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> WithPeerId<U> {
269        WithPeerId(self.0, op(self.1))
270    }
271}
272
273impl<T> WithPeerId<Option<T>> {
274    /// Returns `None` if the inner value is `None`, otherwise returns `Some(WithPeerId<T>)`.
275    pub fn transpose(self) -> Option<WithPeerId<T>> {
276        self.1.map(|v| WithPeerId(self.0, v))
277    }
278
279    /// Returns the contained Some value, consuming the self value.
280    ///
281    /// See also [`Option::unwrap`]
282    ///
283    /// # Panics
284    ///
285    /// Panics if the value is a None
286    pub fn unwrap(self) -> T {
287        self.1.unwrap()
288    }
289
290    /// Returns the transposed [`WithPeerId`] type with the contained Some value
291    ///
292    /// # Panics
293    ///
294    /// Panics if the value is a None
295    pub fn unwrapped(self) -> WithPeerId<T> {
296        self.transpose().unwrap()
297    }
298}
299
300#[cfg(test)]
301mod tests {
302    use super::*;
303
304    #[cfg(feature = "secp256k1")]
305    #[test]
306    fn test_node_record_parse() {
307        let url = "enode://6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0@10.3.58.6:30303?discport=30301";
308        let node: AnyNode = url.parse().unwrap();
309        assert_eq!(node, AnyNode::NodeRecord(NodeRecord {
310            address: std::net::IpAddr::V4([10,3,58,6].into()),
311            tcp_port: 30303,
312            udp_port: 30301,
313            id: "6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0".parse().unwrap(),
314        }));
315        assert_eq!(node.to_string(), url)
316    }
317
318    #[test]
319    fn test_peer_id_parse() {
320        let url = "enode://6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0";
321        let node: AnyNode = url.parse().unwrap();
322        assert_eq!(node, AnyNode::PeerId("6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0".parse().unwrap()));
323        assert_eq!(node.to_string(), url);
324
325        let url = "enode://";
326        let err = url.parse::<AnyNode>().unwrap_err();
327        assert_eq!(err, "invalid public key: ");
328    }
329
330    // <https://eips.ethereum.org/EIPS/eip-778>
331    #[cfg(feature = "secp256k1")]
332    #[test]
333    fn test_enr_parse() {
334        let url = "enr:-IS4QHCYrYZbAKWCBRlAy5zzaDZXJBGkcnh4MHcBFZntXNFrdvJjX04jRzjzCBOonrkTfj499SZuOh8R33Ls8RRcy5wBgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQPKY0yuDUmstAHYpMa2_oxVtw0RW_QAdpzBQA8yWM0xOIN1ZHCCdl8";
335        let node: AnyNode = url.parse().unwrap();
336        assert_eq!(
337            node.peer_id(),
338            "0xca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31387574077f301b421bc84df7266c44e9e6d569fc56be00812904767bf5ccd1fc7f"
339                .parse::<PeerId>()
340                .unwrap()
341        );
342        assert_eq!(node.to_string(), url);
343    }
344
345    #[test]
346    #[cfg(feature = "secp256k1")]
347    fn pk2id2pk() {
348        let prikey = secp256k1::SecretKey::new(&mut rand_08::thread_rng());
349        let pubkey = secp256k1::PublicKey::from_secret_key(secp256k1::SECP256K1, &prikey);
350        assert_eq!(pubkey, id2pk(pk2id(&pubkey)).unwrap());
351    }
352}
reth_network_peers/lib.rs

reth_network_peers/
lib.rs
