feat: add eth-wire

Cargo.toml

@@ -10,6 +10,7 @@ members = [
     "crates/executor",
     "crates/interfaces",
     "crates/net/p2p",
+    "crates/net/eth-wire",
     "crates/net/rpc",
     "crates/net/rpc-api",
     "crates/net/rpc-types",

crates/net/eth-wire/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "reth-eth-wire"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/foundry-rs/reth"
+readme = "README.md"
+
+[dependencies]
+bytes = { version = "1.1" }
+
+# can remove these restrictions once ethereum-types is bumped across the board
+fastrlp = { version = "0.1.3", features = ["alloc", "derive", "std", "ethereum-types"] }
+ethereum-forkid = "=0.10"
+hex = "0.4"
+thiserror = "1"
+
+# reth
+reth-primitives = { path = "../../primitives" }
+
+[dev-dependencies]
+hex-literal = "0.3"
+ethers-core = { git = "https://github.com/gakonst/ethers-rs", default-features = false }

crates/net/eth-wire/src/lib.rs

@@ -0,0 +1,14 @@
+#![warn(missing_docs, unreachable_pub)]
+#![deny(unused_must_use, rust_2018_idioms)]
+#![doc(test(
+    no_crate_inject,
+    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
+))]
+
+//! Types for the eth wire protocol.
+
+mod status;
+pub use status::Status;
+
+mod version;
+pub use version::EthVersion;

crates/net/eth-wire/src/status.rs

@@ -0,0 +1,210 @@
+use ethereum_forkid::ForkId;
+use fastrlp::{RlpDecodable, RlpEncodable};
+use reth_primitives::{Chain, H256, U256};
+use std::fmt::{Debug, Display};
+
+/// The status message is used in the eth protocol handshake to ensure that peers are on the same
+/// network and are following the same fork.
+/// The total difficulty and best block hash are used to identify whether or not the requesting
+/// client should be sent historical blocks for a full blockchain sync.
+///
+/// When performing a handshake, the total difficulty is not guaranteed to correspond to the block
+/// hash. This information should be treated as untrusted.
+#[derive(Copy, Clone, PartialEq, Eq, RlpEncodable, RlpDecodable)]
+pub struct Status {
+    /// The current protocol version. For example, peers running `eth/66` would have a version of
+    /// 66.
+    pub version: u8,
+
+    /// The chain id, as introduced in
+    /// [EIP155](https://eips.ethereum.org/EIPS/eip-155#list-of-chain-ids).
+    pub chain: Chain,
+
+    /// Total difficulty of the best chain.
+    pub total_difficulty: U256,
+
+    /// The highest difficulty block hash the peer has seen
+    pub blockhash: H256,
+
+    /// The genesis hash of the peer's chain.
+    pub genesis: H256,
+
+    /// The fork identifier, a [CRC32
+    /// checksum](https://en.wikipedia.org/wiki/Cyclic_redundancy_check#CRC-32_algorithm) for
+    /// identifying the peer's fork as defined by
+    /// [EIP-2124](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2124.md).
+    /// This was added in [`eth/64`](https://eips.ethereum.org/EIPS/eip-2364)
+    pub forkid: ForkId,
+}
+
+impl Display for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let hexed_blockhash = hex::encode(self.blockhash);
+        let hexed_genesis = hex::encode(self.genesis);
+        write!(
+            f,
+            "Status {{ version: {}, chain: {}, total_difficulty: {}, blockhash: {}, genesis: {}, forkid: {:X?} }}",
+            self.version,
+            self.chain,
+            self.total_difficulty,
+            hexed_blockhash,
+            hexed_genesis,
+            self.forkid
+        )
+    }
+}
+
+impl Debug for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let hexed_blockhash = hex::encode(self.blockhash);
+        let hexed_genesis = hex::encode(self.genesis);
+        if f.alternate() {
+            write!(
+                f,
+                "Status {{\n\tversion: {:?},\n\tchain: {:?},\n\ttotal_difficulty: {:?},\n\tblockhash: {},\n\tgenesis: {},\n\tforkid: {:X?}\n}}",
+                self.version,
+                self.chain,
+                self.total_difficulty,
+                hexed_blockhash,
+                hexed_genesis,
+                self.forkid
+            )
+        } else {
+            write!(
+                f,
+                "Status {{ version: {:?}, chain: {:?}, total_difficulty: {:?}, blockhash: {}, genesis: {}, forkid: {:X?} }}",
+                self.version,
+                self.chain,
+                self.total_difficulty,
+                hexed_blockhash,
+                hexed_genesis,
+                self.forkid
+            )
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use ethereum_forkid::{ForkHash, ForkId};
+    use ethers_core::types::Chain as NamedChain;
+    use fastrlp::{Decodable, Encodable};
+    use hex_literal::hex;
+    use reth_primitives::{Chain, H256, U256};
+
+    use crate::{EthVersion, Status};
+
+    #[test]
+    fn encode_eth_status_message() {
+        let expected = hex!("f85643018a07aac59dabcdd74bc567a0feb27336ca7923f8fab3bd617fcb6e75841538f71c1bcfc267d7838489d9e13da0d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3c684b715077d80");
+        let status = Status {
+            version: EthVersion::Eth67 as u8,
+            chain: Chain::Named(NamedChain::Mainnet),
+            total_difficulty: U256::from(36206751599115524359527u128),
+            blockhash: H256::from_str(
+                "feb27336ca7923f8fab3bd617fcb6e75841538f71c1bcfc267d7838489d9e13d",
+            )
+            .unwrap(),
+            genesis: H256::from_str(
+                "d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3",
+            )
+            .unwrap(),
+            forkid: ForkId { hash: ForkHash([0xb7, 0x15, 0x07, 0x7d]), next: 0 },
+        };
+
+        let mut rlp_status = vec![];
+        status.encode(&mut rlp_status);
+        assert_eq!(rlp_status, expected);
+    }
+
+    #[test]
+    fn decode_eth_status_message() {
+        let data = hex!("f85643018a07aac59dabcdd74bc567a0feb27336ca7923f8fab3bd617fcb6e75841538f71c1bcfc267d7838489d9e13da0d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3c684b715077d80");
+        let expected = Status {
+            version: EthVersion::Eth67 as u8,
+            chain: Chain::Named(NamedChain::Mainnet),
+            total_difficulty: U256::from(36206751599115524359527u128),
+            blockhash: H256::from_str(
+                "feb27336ca7923f8fab3bd617fcb6e75841538f71c1bcfc267d7838489d9e13d",
+            )
+            .unwrap(),
+            genesis: H256::from_str(
+                "d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3",
+            )
+            .unwrap(),
+            forkid: ForkId { hash: ForkHash([0xb7, 0x15, 0x07, 0x7d]), next: 0 },
+        };
+        let status = Status::decode(&mut &data[..]).unwrap();
+        assert_eq!(status, expected);
+    }
+
+    #[test]
+    fn encode_network_status_message() {
+        let expected = hex!("f850423884024190faa0f8514c4680ef27700751b08f37645309ce65a449616a3ea966bf39dd935bb27ba00d21840abff46b96c84b2ac9e10e4f5cdaeb5693cb665db62a2f3b02d2d57b5bc6845d43d2fd80");
+        let status = Status {
+            version: EthVersion::Eth66 as u8,
+            chain: Chain::Named(NamedChain::BinanceSmartChain),
+            total_difficulty: U256::from(37851386u64),
+            blockhash: H256::from_str(
+                "f8514c4680ef27700751b08f37645309ce65a449616a3ea966bf39dd935bb27b",
+            )
+            .unwrap(),
+            genesis: H256::from_str(
+                "0d21840abff46b96c84b2ac9e10e4f5cdaeb5693cb665db62a2f3b02d2d57b5b",
+            )
+            .unwrap(),
+            forkid: ForkId { hash: ForkHash([0x5d, 0x43, 0xd2, 0xfd]), next: 0 },
+        };
+
+        let mut rlp_status = vec![];
+        status.encode(&mut rlp_status);
+        assert_eq!(rlp_status, expected);
+    }
+
+    #[test]
+    fn decode_network_status_message() {
+        let data = hex!("f850423884024190faa0f8514c4680ef27700751b08f37645309ce65a449616a3ea966bf39dd935bb27ba00d21840abff46b96c84b2ac9e10e4f5cdaeb5693cb665db62a2f3b02d2d57b5bc6845d43d2fd80");
+        let expected = Status {
+            version: EthVersion::Eth66 as u8,
+            chain: Chain::Named(NamedChain::BinanceSmartChain),
+            total_difficulty: U256::from(37851386u64),
+            blockhash: H256::from_str(
+                "f8514c4680ef27700751b08f37645309ce65a449616a3ea966bf39dd935bb27b",
+            )
+            .unwrap(),
+            genesis: H256::from_str(
+                "0d21840abff46b96c84b2ac9e10e4f5cdaeb5693cb665db62a2f3b02d2d57b5b",
+            )
+            .unwrap(),
+            forkid: ForkId { hash: ForkHash([0x5d, 0x43, 0xd2, 0xfd]), next: 0 },
+        };
+        let status = Status::decode(&mut &data[..]).unwrap();
+        assert_eq!(status, expected);
+    }
+
+    #[test]
+    fn decode_another_network_status_message() {
+        let data = hex!("f86142820834936d68fcffffffffffffffffffffffffdeab81b8a0523e8163a6d620a4cc152c547a05f28a03fec91a2a615194cb86df9731372c0ca06499dccdc7c7def3ebb1ce4c6ee27ec6bd02aee570625ca391919faf77ef27bdc6841a67ccd880");
+        let expected = Status {
+            version: EthVersion::Eth66 as u8,
+            chain: Chain::Id(2100),
+            total_difficulty: U256::from_str(
+                "0x000000000000000000000000006d68fcffffffffffffffffffffffffdeab81b8",
+            )
+            .unwrap(),
+            blockhash: H256::from_str(
+                "523e8163a6d620a4cc152c547a05f28a03fec91a2a615194cb86df9731372c0c",
+            )
+            .unwrap(),
+            genesis: H256::from_str(
+                "6499dccdc7c7def3ebb1ce4c6ee27ec6bd02aee570625ca391919faf77ef27bd",
+            )
+            .unwrap(),
+            forkid: ForkId { hash: ForkHash([0x1a, 0x67, 0xcc, 0xd8]), next: 0 },
+        };
+        let status = Status::decode(&mut &data[..]).unwrap();
+        assert_eq!(status, expected);
+    }
+}