reth_eth_wire/
hello.rs

1use crate::{Capability, EthVersion, ProtocolVersion};
2use alloy_rlp::{RlpDecodable, RlpEncodable};
3use reth_codecs::add_arbitrary_tests;
4use reth_network_peers::PeerId;
5use reth_primitives_traits::constants::RETH_CLIENT_VERSION;
6
7/// The default tcp port for p2p.
8///
9/// Note: this is the same as discovery port: `DEFAULT_DISCOVERY_PORT`
10pub(crate) const DEFAULT_TCP_PORT: u16 = 30303;
11
12use crate::protocol::Protocol;
13#[cfg(feature = "serde")]
14use serde::{Deserialize, Serialize};
15
16/// This is a superset of [`HelloMessage`] that provides additional protocol [Protocol] information
17/// about the number of messages used by each capability in order to do proper message ID
18/// multiplexing.
19///
20/// This type is required for the `p2p` handshake because the [`HelloMessage`] does not share the
21/// number of messages used by each capability.
22///
23/// To get the encodable [`HelloMessage`] without the additional protocol information, use the
24/// [`HelloMessageWithProtocols::message`].
25#[derive(Debug, Clone, PartialEq, Eq)]
26#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
27pub struct HelloMessageWithProtocols {
28    /// The version of the `p2p` protocol.
29    pub protocol_version: ProtocolVersion,
30    /// Specifies the client software identity, as a human-readable string (e.g.
31    /// "Ethereum(++)/1.0.0").
32    pub client_version: String,
33    /// The list of supported capabilities and their versions.
34    pub protocols: Vec<Protocol>,
35    /// The port that the client is listening on, zero indicates the client is not listening.
36    ///
37    /// By default this is `30303` which is the same as the default discovery port.
38    pub port: u16,
39    /// The secp256k1 public key corresponding to the node's private key.
40    pub id: PeerId,
41}
42
43impl HelloMessageWithProtocols {
44    /// Starts a new `HelloMessageProtocolsBuilder`
45    ///
46    /// ```
47    /// use reth_eth_wire::HelloMessageWithProtocols;
48    /// use reth_network_peers::pk2id;
49    /// use secp256k1::{SecretKey, SECP256K1};
50    /// let secret_key = SecretKey::new(&mut rand_08::thread_rng());
51    /// let id = pk2id(&secret_key.public_key(SECP256K1));
52    /// let status = HelloMessageWithProtocols::builder(id).build();
53    /// ```
54    pub const fn builder(id: PeerId) -> HelloMessageBuilder {
55        HelloMessageBuilder::new(id)
56    }
57
58    /// Returns the raw [`HelloMessage`] without the additional protocol information.
59    #[inline]
60    pub fn message(&self) -> HelloMessage {
61        HelloMessage {
62            protocol_version: self.protocol_version,
63            client_version: self.client_version.clone(),
64            capabilities: self.protocols.iter().map(|p| p.cap.clone()).collect(),
65            port: self.port,
66            id: self.id,
67        }
68    }
69
70    /// Converts the type into a [`HelloMessage`] without the additional protocol information.
71    pub fn into_message(self) -> HelloMessage {
72        HelloMessage {
73            protocol_version: self.protocol_version,
74            client_version: self.client_version,
75            capabilities: self.protocols.into_iter().map(|p| p.cap).collect(),
76            port: self.port,
77            id: self.id,
78        }
79    }
80
81    /// Returns true if the set of protocols contains the given protocol.
82    #[inline]
83    pub fn contains_protocol(&self, protocol: &Protocol) -> bool {
84        self.protocols.iter().any(|p| p.cap == protocol.cap)
85    }
86
87    /// Adds a new protocol to the set.
88    ///
89    /// Returns an error if the protocol already exists.
90    #[inline]
91    pub fn try_add_protocol(&mut self, protocol: Protocol) -> Result<(), Protocol> {
92        if self.contains_protocol(&protocol) {
93            Err(protocol)
94        } else {
95            self.protocols.push(protocol);
96            Ok(())
97        }
98    }
99
100    /// Toggles advertisement of the `snap/2` satellite protocol (EIP-8189).
101    ///
102    /// snap/2 is negotiated as an `RLPx` capability and rides alongside `eth` on the same
103    /// connection. Disabling removes any advertised `snap` capability of any version.
104    pub fn with_snap(mut self, enable: bool) -> Self {
105        if enable {
106            let _ = self.try_add_protocol(Protocol::snap_2());
107        } else {
108            self.protocols.retain(|p| p.cap.name != "snap");
109        }
110        self
111    }
112}
113
114// TODO: determine if we should allow for the extra fields at the end like EIP-706 suggests
115/// Raw rlpx protocol message used in the `p2p` handshake, containing information about the
116/// supported `RLPx` protocol version and capabilities.
117///
118/// See also <https://github.com/ethereum/devp2p/blob/master/rlpx.md#hello-0x00>
119#[derive(Clone, Debug, PartialEq, Eq, RlpEncodable, RlpDecodable)]
120#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
121#[cfg_attr(any(test, feature = "arbitrary"), derive(arbitrary::Arbitrary))]
122#[add_arbitrary_tests(rlp)]
123pub struct HelloMessage {
124    /// The version of the `p2p` protocol.
125    pub protocol_version: ProtocolVersion,
126    /// Specifies the client software identity, as a human-readable string (e.g.
127    /// "Ethereum(++)/1.0.0").
128    pub client_version: String,
129    /// The list of supported capabilities and their versions.
130    pub capabilities: Vec<Capability>,
131    /// The port that the client is listening on, zero indicates the client is not listening.
132    pub port: u16,
133    /// The secp256k1 public key corresponding to the node's private key.
134    pub id: PeerId,
135}
136
137// === impl HelloMessage ===
138
139impl HelloMessage {
140    /// Starts a new `HelloMessageBuilder`
141    ///
142    /// ```
143    /// use reth_eth_wire::HelloMessage;
144    /// use reth_network_peers::pk2id;
145    /// use secp256k1::{SecretKey, SECP256K1};
146    /// let secret_key = SecretKey::new(&mut rand_08::thread_rng());
147    /// let id = pk2id(&secret_key.public_key(SECP256K1));
148    /// let status = HelloMessage::builder(id).build();
149    /// ```
150    pub const fn builder(id: PeerId) -> HelloMessageBuilder {
151        HelloMessageBuilder::new(id)
152    }
153}
154
155/// Builder for [`HelloMessageWithProtocols`]
156#[derive(Debug)]
157pub struct HelloMessageBuilder {
158    /// The version of the `p2p` protocol.
159    pub protocol_version: Option<ProtocolVersion>,
160    /// Specifies the client software identity, as a human-readable string (e.g.
161    /// "Ethereum(++)/1.0.0").
162    pub client_version: Option<String>,
163    /// The list of supported protocols.
164    pub protocols: Option<Vec<Protocol>>,
165    /// The port that the client is listening on, zero indicates the client is not listening.
166    pub port: Option<u16>,
167    /// The secp256k1 public key corresponding to the node's private key.
168    pub id: PeerId,
169}
170
171// === impl HelloMessageBuilder ===
172
173impl HelloMessageBuilder {
174    /// Create a new builder to configure a [`HelloMessage`]
175    pub const fn new(id: PeerId) -> Self {
176        Self { protocol_version: None, client_version: None, protocols: None, port: None, id }
177    }
178
179    /// Sets the port the client is listening on
180    pub const fn port(mut self, port: u16) -> Self {
181        self.port = Some(port);
182        self
183    }
184
185    /// Adds a new protocol to use.
186    pub fn protocol(mut self, protocols: impl Into<Protocol>) -> Self {
187        self.protocols.get_or_insert_with(Vec::new).push(protocols.into());
188        self
189    }
190
191    /// Sets protocols to use.
192    pub fn protocols(mut self, protocols: impl IntoIterator<Item = Protocol>) -> Self {
193        self.protocols.get_or_insert_with(Vec::new).extend(protocols);
194        self
195    }
196
197    /// Sets client version.
198    pub fn client_version(mut self, client_version: impl Into<String>) -> Self {
199        self.client_version = Some(client_version.into());
200        self
201    }
202
203    /// Sets protocol version.
204    pub const fn protocol_version(mut self, protocol_version: ProtocolVersion) -> Self {
205        self.protocol_version = Some(protocol_version);
206        self
207    }
208
209    /// Consumes the type and returns the configured [`HelloMessage`]
210    ///
211    /// Unset fields will be set to their default values:
212    /// - `protocol_version`: [`ProtocolVersion::V5`]
213    /// - `client_version`: [`RETH_CLIENT_VERSION`]
214    /// - `capabilities`: All [`EthVersion`]
215    pub fn build(self) -> HelloMessageWithProtocols {
216        let Self { protocol_version, client_version, protocols, port, id } = self;
217        HelloMessageWithProtocols {
218            protocol_version: protocol_version.unwrap_or_default(),
219            client_version: client_version.unwrap_or_else(|| RETH_CLIENT_VERSION.to_string()),
220            protocols: protocols.unwrap_or_else(|| {
221                EthVersion::ALL_VERSIONS.iter().copied().map(Into::into).collect()
222            }),
223            port: port.unwrap_or(DEFAULT_TCP_PORT),
224            id,
225        }
226    }
227}
228
229#[cfg(test)]
230mod tests {
231    use crate::{
232        p2pstream::P2PMessage, Capability, EthVersion, HelloMessage, HelloMessageWithProtocols,
233        ProtocolVersion,
234    };
235    use alloy_rlp::{Decodable, Encodable, EMPTY_STRING_CODE};
236    use reth_network_peers::pk2id;
237    use secp256k1::{SecretKey, SECP256K1};
238
239    #[test]
240    fn test_hello_encoding_round_trip() {
241        let secret_key = SecretKey::new(&mut rand_08::thread_rng());
242        let id = pk2id(&secret_key.public_key(SECP256K1));
243        let hello = P2PMessage::Hello(HelloMessage {
244            protocol_version: ProtocolVersion::V5,
245            client_version: "reth/0.1.0".to_string(),
246            capabilities: vec![Capability::new_static("eth", EthVersion::Eth67 as usize)],
247            port: 30303,
248            id,
249        });
250
251        let mut hello_encoded = Vec::new();
252        hello.encode(&mut hello_encoded);
253
254        let hello_decoded = P2PMessage::decode(&mut &hello_encoded[..]).unwrap();
255
256        assert_eq!(hello, hello_decoded);
257    }
258
259    #[test]
260    fn hello_encoding_length() {
261        let secret_key = SecretKey::new(&mut rand_08::thread_rng());
262        let id = pk2id(&secret_key.public_key(SECP256K1));
263        let hello = P2PMessage::Hello(HelloMessage {
264            protocol_version: ProtocolVersion::V5,
265            client_version: "reth/0.1.0".to_string(),
266            capabilities: vec![Capability::new_static("eth", EthVersion::Eth67 as usize)],
267            port: 30303,
268            id,
269        });
270
271        let mut hello_encoded = Vec::new();
272        hello.encode(&mut hello_encoded);
273
274        assert_eq!(hello_encoded.len(), hello.length());
275    }
276    //TODO: add test for eth70 here once we have fully support it
277
278    #[test]
279    fn test_default_protocols_still_include_eth69() {
280        // ensure that older eth/69 remains advertised for compatibility
281        let secret_key = SecretKey::new(&mut rand_08::thread_rng());
282        let id = pk2id(&secret_key.public_key(SECP256K1));
283        let hello = HelloMessageWithProtocols::builder(id).build();
284
285        let has_eth69 = hello
286            .protocols
287            .iter()
288            .any(|p| p.cap.name == "eth" && p.cap.version == EthVersion::Eth69 as usize);
289        assert!(has_eth69, "Default protocols should include Eth69");
290    }
291
292    #[test]
293    fn hello_message_id_prefix() {
294        // ensure that the hello message id is prefixed
295        let secret_key = SecretKey::new(&mut rand_08::thread_rng());
296        let id = pk2id(&secret_key.public_key(SECP256K1));
297        let hello = P2PMessage::Hello(HelloMessage {
298            protocol_version: ProtocolVersion::V5,
299            client_version: "reth/0.1.0".to_string(),
300            capabilities: vec![Capability::new_static("eth", EthVersion::Eth67 as usize)],
301            port: 30303,
302            id,
303        });
304
305        let mut hello_encoded = Vec::new();
306        hello.encode(&mut hello_encoded);
307
308        // zero is encoded as 0x80, the empty string code in RLP
309        assert_eq!(hello_encoded[0], EMPTY_STRING_CODE);
310    }
311}
reth_eth_wire/hello.rs

reth_eth_wire/
hello.rs
