docs: typos & cleanup (#4296)

docs/crates/db.md

@@ -8,7 +8,7 @@ The database is a central component to Reth, enabling persistent storage for dat
 
 Within Reth, the database is organized via "tables". A table is any struct that implements the `Table` trait.
 
-[File: crates/storage/db/src/abstraction/table.rs](https://github.com/paradigmxyz/reth/blob/main/crates/storage/db/src/abstraction/table.rs#L56-L65)
+[File: crates/storage/db/src/abstraction/table.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/storage/db/src/abstraction/table.rs#L55-L82)
 
 ```rust ignore
 pub trait Table: Send + Sync + Debug + 'static {
@@ -23,7 +23,7 @@ pub trait Table: Send + Sync + Debug + 'static {
 }
 
 //--snip--
-pub trait Key: Encode + Decode + Ord {}
+pub trait Key: Encode + Decode + Ord + Clone + Serialize + for<'a> Deserialize<'a> {}
 
 //--snip--
 pub trait Value: Compress + Decompress + Serialize {}
@@ -32,38 +32,42 @@ pub trait Value: Compress + Decompress + Serialize {}
 
 The `Table` trait has two generic values, `Key` and `Value`, which need to implement the `Key` and `Value` traits, respectively. The `Encode` trait is responsible for transforming data into bytes so it can be stored in the database, while the `Decode` trait transforms the bytes back into its original form. Similarly, the `Compress` and `Decompress` traits transform the data to and from a compressed format when storing or reading data from the database.
 
-There are many tables within the node, all used to store different types of data from `Headers` to `Transactions` and more. Below is a list of all of the tables. You can follow [this link](https://github.com/paradigmxyz/reth/blob/main/crates/storage/db/src/tables/mod.rs#L36) if you would like to see the table definitions for any of the tables below.
+There are many tables within the node, all used to store different types of data from `Headers` to `Transactions` and more. Below is a list of all of the tables. You can follow [this link](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/storage/db/src/tables/mod.rs#L161-L188) if you would like to see the table definitions for any of the tables below.
 
 - CanonicalHeaders
 - HeaderTD
 - HeaderNumbers
 - Headers
-- BlockBodies
+- BlockBodyIndices
 - BlockOmmers
+- BlockWithdrawals
+- TransactionBlock
 - Transactions
 - TxHashNumber
 - Receipts
-- Logs
 - PlainAccountState
 - PlainStorageState
 - Bytecodes
-- BlockTransitionIndex
-- TxTransitionIndex
 - AccountHistory
 - StorageHistory
 - AccountChangeSet
 - StorageChangeSet
+- HashedAccount
+- HashedStorage
+- AccountsTrie
+- StoragesTrie
 - TxSenders
-- Config
 - SyncStage
+- SyncStageProgress
+- PruneCheckpoints
 
 <br>
 
 ## Database
 
-Reth's database design revolves around it's main [Database trait](https://github.com/paradigmxyz/reth/blob/0d9b9a392d4196793736522f3fc2ac804991b45d/crates/interfaces/src/db/mod.rs#L33), which takes advantage of [generic associated types](https://blog.rust-lang.org/2022/10/28/gats-stabilization.html) and [a few design tricks](https://sabrinajewson.org/blog/the-better-alternative-to-lifetime-gats#the-better-gats) to implement the database's functionality across many types. Let's take a quick look at the `Database` trait and how it works.
+Reth's database design revolves around it's main [Database trait](https://github.com/paradigmxyz/reth/blob/eaca2a4a7fbbdc2f5cd15eab9a8a18ede1891bda/crates/storage/db/src/abstraction/database.rs#L21), which takes advantage of [generic associated types](https://blog.rust-lang.org/2022/10/28/gats-stabilization.html) and [a few design tricks](https://sabrinajewson.org/blog/the-better-alternative-to-lifetime-gats#the-better-gats) to implement the database's functionality across many types. Let's take a quick look at the `Database` trait and how it works.
 
-[File: crates/storage/db/src/abstraction/database.rs](https://github.com/paradigmxyz/reth/blob/main/crates/storage/db/src/abstraction/database.rs#L19)
+[File: crates/storage/db/src/abstraction/database.rs](https://github.com/paradigmxyz/reth/blob/eaca2a4a7fbbdc2f5cd15eab9a8a18ede1891bda/crates/storage/db/src/abstraction/database.rs#L21)
 
 ```rust ignore
 /// Main Database trait that spawns transactions to be executed.

docs/crates/discv4.md

@@ -5,24 +5,28 @@ The `discv4` crate plays an important role in Reth, enabling discovery of other
 ## Starting the Node Discovery Protocol
 As mentioned in the network and stages chapters, when the node is first started up, the `node::Command::execute()` function is called, which initializes the node and starts to run the Reth pipeline. Throughout the initialization of the node, there are many processes that are are started. One of the processes that is initialized is the p2p network which starts the node discovery protocol amongst other tasks.  
 
-[File: bin/reth/src/node/mod.rs](https://github.com/paradigmxyz/reth/blob/main/bin/reth/src/node/mod.rs#L95)
+[File: bin/reth/src/node/mod.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/bin/reth/src/node/mod.rs#L314-L322)
 ```rust ignore
   pub async fn execute(&self) -> eyre::Result<()> {
     //--snip--
-    let network = config
-        .network_config(db.clone(), chain_id, genesis_hash, self.network.disable_discovery)
-        .start_network()
-        .await?;
+    let network = self
+            .start_network(
+                network_config,
+                &ctx.task_executor,
+                transaction_pool.clone(),
+                default_peers_path,
+            )
+            .await?;
 
-    info!(peer_id = ?network.peer_id(), local_addr = %network.local_addr(), "Started p2p networking");
+    info!(target: "reth::cli", peer_id = %network.peer_id(), local_addr = %network.local_addr(), "Connected to P2P network");
 
     //--snip--
     }
 ```
 
 During this process, a new `NetworkManager` is created through the `NetworkManager::new()` function, which starts the discovery protocol through a handful of newly spawned tasks. Lets take a look at how this actually works under the hood. 
 
-[File: crates/net/network/src/manager.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/network/src/manager.rs#L147)
+[File: crates/net/network/src/manager.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/network/src/manager.rs#L89)
 ```rust ignore
 impl<C> NetworkManager<C>
 where
@@ -37,6 +41,7 @@ where
             mut discovery_v4_config,
             discovery_addr,
             boot_nodes,
+            dns_discovery_config,
             //--snip--
             ..
         } = config;
@@ -50,16 +55,18 @@ where
             disc_config
         });
 
-        let discovery = Discovery::new(discovery_addr, secret_key, discovery_v4_config).await?;
+        let discovery =
+            Discovery::new(discovery_addr, secret_key, discovery_v4_config, dns_discovery_config)
+            .await?;
 
     //--snip--
     }
 }
 ```
 
-First, the `NetworkConfig` is deconstructed and the `disc_config` is updated to merge configured [bootstrap nodes](https://github.com/paradigmxyz/reth/blob/main/crates/net/discv4/src/bootnodes.rs#L8) and add the `forkid` to adhere to [EIP 868](https://eips.ethereum.org/EIPS/eip-868). This updated configuration variable is then passed into the `Discovery::new()` function. Note that `Discovery` is a catch all for all discovery services, which include discv4, DNS discovery and others in the future.
+First, the `NetworkConfig` is deconstructed and the `disc_config` is updated to merge configured [bootstrap nodes](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/primitives/src/net.rs#L120-L151) and add the `forkid` to adhere to [EIP 868](https://eips.ethereum.org/EIPS/eip-868). This updated configuration variable is then passed into the `Discovery::new()` function. Note that `Discovery` is a catch all for all discovery services, which include discv4, DNS discovery and others in the future.
 
-[File: crates/net/network/src/discovery.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/network/src/discovery.rs#L51)
+[File: crates/net/network/src/discovery.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/network/src/discovery.rs#L53)
 ```rust ignore
 impl Discovery {
     /// Spawns the discovery service.
@@ -70,6 +77,7 @@ impl Discovery {
         discovery_addr: SocketAddr,
         sk: SecretKey,
         discv4_config: Option<Discv4Config>,
+        dns_discovery_config: Option<DnsDiscoveryConfig>,
     ) -> Result<Self, NetworkError> {
         let local_enr = NodeRecord::from_secret_key(discovery_addr, &sk);
 
@@ -86,6 +94,20 @@ impl Discovery {
             (None, None, None)
         };
 
+        // setup DNS discovery
+        let (_dns_discovery, dns_discovery_updates, _dns_disc_service) =
+            if let Some(dns_config) = dns_discovery_config {
+                let (mut service, dns_disc) = DnsDiscoveryService::new_pair(
+                    Arc::new(DnsResolver::from_system_conf()?),
+                    dns_config,
+                );
+                let dns_discovery_updates = service.node_record_stream();
+                let dns_disc_service = service.spawn();
+                (Some(dns_disc), Some(dns_discovery_updates), Some(dns_disc_service))
+            } else {
+                (None, None, None)
+            };
+
         Ok(Self {
             local_enr,
             discv4,

docs/crates/eth-wire.md

@@ -12,7 +12,7 @@ This crate can be thought of as having 2 components:
 ## Types
 The most basic Eth-wire type is an `ProtocolMessage`. It describes all messages that reth can send/receive.
 
-[File: crates/net/eth-wire/src/types/message.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/types/message.rs)
+[File: crates/net/eth-wire/src/types/message.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/types/message.rs)
 ```rust, ignore
 /// An `eth` protocol message, containing a message ID and payload.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -50,7 +50,7 @@ pub enum EthMessageID {
 Messages can either be broadcast to the network, or can be a request/response message to a single peer. This 2nd type of message is 
 described using a `RequestPair` struct, which is simply a concatenation of the underlying message with a request id.
 
-[File: crates/net/eth-wire/src/types/message.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/types/message.rs)
+[File: crates/net/eth-wire/src/types/message.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/types/message.rs)
 ```rust, ignore
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct RequestPair<T> {
@@ -62,7 +62,7 @@ pub struct RequestPair<T> {
 Every `Ethmessage` has a correspoding rust struct which implements the `Encodable` and `Decodable` traits.
 These traits are defined as follows:
 
-[Crate: crates/common/rlp](https://github.com/paradigmxyz/reth/blob/main/crates/common/rlp)
+[Crate: crates/rlp](https://github.com/paradigmxyz/reth/tree/1563506aea09049a85e5cc72c2894f3f7a371581/crates/rlp)
 ```rust, ignore
 pub trait Decodable: Sized {
     fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError>;
@@ -93,7 +93,7 @@ The items in the list are transactions in the format described in the main Ether
 
 In reth, this is represented as:
 
-[File: crates/net/eth-wire/src/types/broadcast.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/types/broadcast.rs)
+[File: crates/net/eth-wire/src/types/broadcast.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/types/broadcast.rs)
 ```rust,ignore
 pub struct Transactions(
     /// New transactions for the peer to include in its mempool.
@@ -103,7 +103,7 @@ pub struct Transactions(
 
 And the corresponding trait implementations are present in the primitives crate.
 
-[File: crates/primitives/src/transaction/mod.rs](https://github.com/paradigmxyz/reth/blob/main/crates/primitives/src/transaction/mod.rs)
+[File: crates/primitives/src/transaction/mod.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/primitives/src/transaction/mod.rs)
 ```rust, ignore
 #[main_codec]
 #[derive(Debug, Clone, PartialEq, Eq, Hash, AsRef, Deref, Default)]
@@ -131,7 +131,7 @@ impl Decodable for TransactionSigned {
         // Implementation omitted for brevity
         //...
     }
-
+}
 ```
 Now that we know how the types work, let's take a look at how these are utilized in the network.
 
@@ -146,7 +146,7 @@ The lowest level stream to communicate with other peers is the P2P stream. It ta
 Decompression/Compression of bytes is done with snappy algorithm ([EIP 706](https://eips.ethereum.org/EIPS/eip-706)) 
 using the external `snap` crate. 
 
-[File: crates/net/eth-wire/src/p2pstream.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/p2pstream.rs)
+[File: crates/net/eth-wire/src/p2pstream.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/p2pstream.rs)
 ```rust,ignore
 #[pin_project]
 pub struct P2PStream<S> {
@@ -164,7 +164,7 @@ pub struct P2PStream<S> {
 To manage pinging, an instance of the `Pinger` struct is used. This is a state machine which keeps track of how many pings
 we have sent/received and the timeouts associated with them.
 
-[File: crates/net/eth-wire/src/pinger.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/pinger.rs)
+[File: crates/net/eth-wire/src/pinger.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/pinger.rs)
 ```rust,ignore
 #[derive(Debug)]
 pub(crate) struct Pinger {
@@ -190,7 +190,7 @@ pub(crate) enum PingState {
 
 State transitions are then implemented like a future, with the `poll_ping` function advancing the state of the pinger.
 
-[File: crates/net/eth-wire/src/pinger.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/pinger.rs)
+[File: crates/net/eth-wire/src/pinger.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/pinger.rs)
 ```rust, ignore
 pub(crate) fn poll_ping(
     &mut self,
@@ -218,12 +218,12 @@ pub(crate) fn poll_ping(
 ```
 
 ### Sending and receiving data
-To send and recieve data, the P2PStream itself is a future which implemenents the `Stream` and `Sink` traits from the `futures` crate.
+To send and receive data, the P2PStream itself is a future which implements the `Stream` and `Sink` traits from the `futures` crate.
 
 For the `Stream` trait, the `inner` stream is polled, decompressed and returned. Most of the code is just 
 error handling and is omitted here for clarity.
 
-[File: crates/net/eth-wire/src/p2pstream.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/p2pstream.rs)
+[File: crates/net/eth-wire/src/p2pstream.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/p2pstream.rs)
 ```rust,ignore
 
 impl<S> Stream for P2PStream<S> {
@@ -250,7 +250,7 @@ impl<S> Stream for P2PStream<S> {
 Similarly, for the `Sink` trait, we do the reverse, compressing and sending data out to the `inner` stream.
 The important functions in this trait are shown below.
 
-[File: crates/net/eth-wire/src/p2pstream.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/p2pstream.rs)
+[File: crates/net/eth-wire/src/p2pstream.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/p2pstream.rs)
 ```rust, ignore
 impl<S> Sink<Bytes> for P2PStream<S> {
     fn start_send(self: Pin<&mut Self>, item: Bytes) -> Result<(), Self::Error> {
@@ -287,7 +287,7 @@ impl<S> Sink<Bytes> for P2PStream<S> {
 ## EthStream
 The EthStream is very simple, it does not keep track of any state, it simply wraps the P2Pstream.
 
-[File: crates/net/eth-wire/src/ethstream.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/ethstream.rs)
+[File: crates/net/eth-wire/src/ethstream.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/ethstream.rs)
 ```rust,ignore
 #[pin_project]
 pub struct EthStream<S> {
@@ -298,7 +298,7 @@ pub struct EthStream<S> {
 EthStream's only job is to perform the RLP decoding/encoding, using the `ProtocolMessage::decode()` and `ProtocolMessage::encode()`
 functions we looked at earlier. 
 
-[File: crates/net/eth-wire/src/ethstream.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/ethstream.rs)
+[File: crates/net/eth-wire/src/ethstream.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/ethstream.rs)
 ```rust,ignore
 impl<S, E> Stream for EthStream<S> {
     // ...
@@ -341,7 +341,7 @@ To perform these, reth has special `Unauthed` versions of streams described abov
 
 The `UnauthedP2Pstream` does the `Hello` handshake and returns a `P2PStream`.
 
-[File: crates/net/eth-wire/src/p2pstream.rs](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/p2pstream.rs)
+[File: crates/net/eth-wire/src/p2pstream.rs](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/p2pstream.rs)
 ```rust, ignore
 #[pin_project]
 pub struct UnauthedP2PStream<S> {
@@ -370,6 +370,6 @@ impl<S> UnauthedP2PStream<S> {
 }
 
 ```
-Similary, UnauthedEthStream does the `Status` handshake and returns an `EthStream`. The code is [here](https://github.com/paradigmxyz/reth/blob/main/crates/net/eth-wire/src/ethstream.rs)
+Similarly, UnauthedEthStream does the `Status` handshake and returns an `EthStream`. The code is [here](https://github.com/paradigmxyz/reth/blob/1563506aea09049a85e5cc72c2894f3f7a371581/crates/net/eth-wire/src/ethstream.rs)