chore: rm reth-primitives from downloaders (#15059)

Cargo.lock

@@ -7389,10 +7389,10 @@ dependencies = [
  "reth-consensus",
  "reth-db",
  "reth-db-api",
+ "reth-ethereum-primitives",
  "reth-metrics",
  "reth-network-p2p",
  "reth-network-peers",
- "reth-primitives",
  "reth-primitives-traits",
  "reth-provider",
  "reth-storage-api",

crates/net/downloaders/Cargo.toml

@@ -17,7 +17,6 @@ reth-config.workspace = true
 reth-consensus.workspace = true
 reth-network-p2p.workspace = true
 reth-network-peers.workspace = true
-reth-primitives.workspace = true
 reth-primitives-traits.workspace = true
 reth-storage-api.workspace = true
 reth-tasks.workspace = true
@@ -25,6 +24,7 @@ reth-tasks.workspace = true
 # optional deps for the test-utils feature
 reth-db = { workspace = true, optional = true }
 reth-db-api = { workspace = true, optional = true }
+reth-ethereum-primitives = { workspace = true, optional = true }
 reth-testing-utils = { workspace = true, optional = true }
 
 # ethereum
@@ -54,6 +54,7 @@ tempfile = { workspace = true, optional = true }
 itertools.workspace = true
 
 [dev-dependencies]
+reth-ethereum-primitives.workspace = true
 reth-chainspec.workspace = true
 reth-db = { workspace = true, features = ["test-utils"] }
 reth-db-api.workspace = true
@@ -80,8 +81,9 @@ test-utils = [
     "reth-network-p2p/test-utils",
     "reth-testing-utils",
     "reth-chainspec/test-utils",
-    "reth-primitives/test-utils",
     "reth-db-api?/test-utils",
     "reth-provider/test-utils",
     "reth-primitives-traits/test-utils",
+    "dep:reth-ethereum-primitives",
+    "reth-ethereum-primitives?/test-utils",
 ]

crates/net/downloaders/src/bodies/bodies.rs

@@ -14,8 +14,7 @@ use reth_network_p2p::{
     },
     error::{DownloadError, DownloadResult},
 };
-use reth_primitives::SealedHeader;
-use reth_primitives_traits::{size::InMemorySize, Block};
+use reth_primitives_traits::{size::InMemorySize, Block, SealedHeader};
 use reth_storage_api::HeaderProvider;
 use reth_tasks::{TaskSpawner, TokioTaskExecutor};
 use std::{
@@ -644,7 +643,7 @@ mod tests {
         let (_static_dir, static_dir_path) = create_test_static_files_dir();
 
         let mut downloader = BodiesDownloaderBuilder::default()
-            .build::<reth_primitives::Block, _, _>(
+            .build::<reth_ethereum_primitives::Block, _, _>(
                 client.clone(),
                 Arc::new(TestConsensus::default()),
                 ProviderFactory::<MockNodeTypesWithDB>::new(
@@ -689,7 +688,7 @@ mod tests {
 
         let mut downloader = BodiesDownloaderBuilder::default()
             .with_request_limit(request_limit)
-            .build::<reth_primitives::Block, _, _>(
+            .build::<reth_ethereum_primitives::Block, _, _>(
             client.clone(),
             Arc::new(TestConsensus::default()),
             ProviderFactory::<MockNodeTypesWithDB>::new(
@@ -723,7 +722,7 @@ mod tests {
         let mut downloader = BodiesDownloaderBuilder::default()
             .with_stream_batch_size(stream_batch_size)
             .with_request_limit(request_limit)
-            .build::<reth_primitives::Block, _, _>(
+            .build::<reth_ethereum_primitives::Block, _, _>(
                 client.clone(),
                 Arc::new(TestConsensus::default()),
                 ProviderFactory::<MockNodeTypesWithDB>::new(
@@ -761,7 +760,7 @@ mod tests {
 
         let mut downloader = BodiesDownloaderBuilder::default()
             .with_stream_batch_size(100)
-            .build::<reth_primitives::Block, _, _>(
+            .build::<reth_ethereum_primitives::Block, _, _>(
             client.clone(),
             Arc::new(TestConsensus::default()),
             ProviderFactory::<MockNodeTypesWithDB>::new(
@@ -807,7 +806,7 @@ mod tests {
             .with_stream_batch_size(10)
             .with_request_limit(1)
             .with_max_buffered_blocks_size_bytes(1)
-            .build::<reth_primitives::Block, _, _>(
+            .build::<reth_ethereum_primitives::Block, _, _>(
                 client.clone(),
                 Arc::new(TestConsensus::default()),
                 ProviderFactory::<MockNodeTypesWithDB>::new(
@@ -844,7 +843,7 @@ mod tests {
         let mut downloader = BodiesDownloaderBuilder::default()
             .with_request_limit(3)
             .with_stream_batch_size(100)
-            .build::<reth_primitives::Block, _, _>(
+            .build::<reth_ethereum_primitives::Block, _, _>(
                 client.clone(),
                 Arc::new(TestConsensus::default()),
                 ProviderFactory::<MockNodeTypesWithDB>::new(

crates/net/downloaders/src/bodies/queue.rs

@@ -9,8 +9,7 @@ use reth_network_p2p::{
     bodies::{client::BodiesClient, response::BlockResponse},
     error::DownloadResult,
 };
-use reth_primitives::SealedHeader;
-use reth_primitives_traits::Block;
+use reth_primitives_traits::{Block, SealedHeader};
 use std::{
     pin::Pin,
     sync::Arc,

crates/net/downloaders/src/bodies/request.rs

@@ -9,8 +9,7 @@ use reth_network_p2p::{
     priority::Priority,
 };
 use reth_network_peers::{PeerId, WithPeerId};
-use reth_primitives::{BlockBody, GotExpected, SealedBlock, SealedHeader};
-use reth_primitives_traits::{Block, InMemorySize};
+use reth_primitives_traits::{Block, GotExpected, InMemorySize, SealedBlock, SealedHeader};
 use std::{
     collections::VecDeque,
     mem,
@@ -171,7 +170,7 @@ where
         let bodies_len = bodies.len();
         let mut bodies = bodies.into_iter().peekable();
 
-        let mut total_size = bodies_capacity * mem::size_of::<BlockBody>();
+        let mut total_size = bodies_capacity * mem::size_of::<C::Body>();
         while bodies.peek().is_some() {
             let next_header = match self.pending_headers.pop_front() {
                 Some(header) => header,
@@ -266,6 +265,7 @@ mod tests {
         test_utils::{generate_bodies, TestBodiesClient},
     };
     use reth_consensus::test_utils::TestConsensus;
+    use reth_ethereum_primitives::Block;
     use reth_testing_utils::{generators, generators::random_header_range};
 
     /// Check if future returns empty bodies without dispatching any requests.
@@ -275,7 +275,7 @@ mod tests {
         let headers = random_header_range(&mut rng, 0..20, B256::ZERO);
 
         let client = Arc::new(TestBodiesClient::default());
-        let fut = BodiesRequestFuture::<reth_primitives::Block, _>::new(
+        let fut = BodiesRequestFuture::<Block, _>::new(
             client.clone(),
             Arc::new(TestConsensus::default()),
             BodyDownloaderMetrics::default(),
@@ -299,7 +299,7 @@ mod tests {
         let client = Arc::new(
             TestBodiesClient::default().with_bodies(bodies.clone()).with_max_batch_size(batch_size),
         );
-        let fut = BodiesRequestFuture::<reth_primitives::Block, _>::new(
+        let fut = BodiesRequestFuture::<Block, _>::new(
             client.clone(),
             Arc::new(TestConsensus::default()),
             BodyDownloaderMetrics::default(),

crates/net/downloaders/src/bodies/task.rs

@@ -195,11 +195,12 @@ mod tests {
         let client = Arc::new(
             TestBodiesClient::default().with_bodies(bodies.clone()).with_should_delay(true),
         );
-        let downloader = BodiesDownloaderBuilder::default().build::<reth_primitives::Block, _, _>(
-            client.clone(),
-            Arc::new(TestConsensus::default()),
-            factory,
-        );
+        let downloader = BodiesDownloaderBuilder::default()
+            .build::<reth_ethereum_primitives::Block, _, _>(
+                client.clone(),
+                Arc::new(TestConsensus::default()),
+                factory,
+            );
         let mut downloader = TaskDownloader::spawn(downloader);
 
         downloader.set_download_range(0..=19).expect("failed to set download range");
@@ -217,11 +218,12 @@ mod tests {
         reth_tracing::init_test_tracing();
         let factory = create_test_provider_factory();
 
-        let downloader = BodiesDownloaderBuilder::default().build::<reth_primitives::Block, _, _>(
-            Arc::new(TestBodiesClient::default()),
-            Arc::new(TestConsensus::default()),
-            factory,
-        );
+        let downloader = BodiesDownloaderBuilder::default()
+            .build::<reth_ethereum_primitives::Block, _, _>(
+                Arc::new(TestBodiesClient::default()),
+                Arc::new(TestConsensus::default()),
+                factory,
+            );
         let mut downloader = TaskDownloader::spawn(downloader);
 
         downloader.set_download_range(1..=0).expect("failed to set download range");

crates/net/downloaders/src/bodies/test_utils.rs

@@ -6,9 +6,9 @@ use alloy_consensus::BlockHeader;
 use alloy_primitives::B256;
 use reth_db::DatabaseEnv;
 use reth_db_api::{database::Database, tables, transaction::DbTxMut};
+use reth_ethereum_primitives::BlockBody;
 use reth_network_p2p::bodies::response::BlockResponse;
-use reth_primitives::{BlockBody, SealedBlock, SealedHeader};
-use reth_primitives_traits::Block;
+use reth_primitives_traits::{Block, SealedBlock, SealedHeader};
 use std::collections::HashMap;
 
 pub(crate) fn zip_blocks<'a, B: Block>(
@@ -31,7 +31,7 @@ pub(crate) fn zip_blocks<'a, B: Block>(
 pub(crate) fn create_raw_bodies(
     headers: impl IntoIterator<Item = SealedHeader>,
     bodies: &mut HashMap<B256, BlockBody>,
-) -> Vec<reth_primitives::Block> {
+) -> Vec<reth_ethereum_primitives::Block> {
     headers
         .into_iter()
         .map(|header| {

crates/net/downloaders/src/file_client.rs

@@ -1,5 +1,3 @@
-use std::{collections::HashMap, io, path::Path, sync::Arc};
-
 use alloy_consensus::BlockHeader;
 use alloy_eips::BlockHashOrNumber;
 use alloy_primitives::{BlockHash, BlockNumber, Sealable, B256};
@@ -15,8 +13,8 @@ use reth_network_p2p::{
     BlockClient,
 };
 use reth_network_peers::PeerId;
-use reth_primitives::{SealedBlock, SealedHeader};
-use reth_primitives_traits::{Block, BlockBody, FullBlock};
+use reth_primitives_traits::{Block, BlockBody, FullBlock, SealedBlock, SealedHeader};
+use std::{collections::HashMap, io, path::Path, sync::Arc};
 use thiserror::Error;
 use tokio::{fs::File, io::AsyncReadExt};
 use tokio_stream::StreamExt;
@@ -43,7 +41,7 @@ pub const DEFAULT_BYTE_LEN_CHUNK_CHAIN_FILE: u64 = 1_000_000_000;
 ///
 /// This reads the entire file into memory, so it is not suitable for large files.
 #[derive(Debug, Clone)]
-pub struct FileClient<B: Block = reth_primitives::Block> {
+pub struct FileClient<B: Block> {
     /// The buffered headers retrieved when fetching new bodies.
     headers: HashMap<BlockNumber, B::Header>,
 
@@ -197,7 +195,7 @@ impl<B: FullBlock> FileClient<B> {
     }
 }
 
-struct FileClientBuilder<B: Block = reth_primitives::Block> {
+struct FileClientBuilder<B: Block> {
     pub consensus: Arc<dyn Consensus<B, Error = ConsensusError>>,
     pub parent_header: Option<SealedHeader<B::Header>>,
 }
@@ -576,11 +574,11 @@ mod tests {
     use futures_util::stream::StreamExt;
     use rand::Rng;
     use reth_consensus::{noop::NoopConsensus, test_utils::TestConsensus};
+    use reth_ethereum_primitives::Block;
     use reth_network_p2p::{
         bodies::downloader::BodyDownloader,
         headers::downloader::{HeaderDownloader, SyncTarget},
     };
-    use reth_primitives::Block;
     use reth_provider::test_utils::create_test_provider_factory;
     use std::sync::Arc;
 
@@ -595,18 +593,17 @@ mod tests {
         // create an empty file
         let file = tempfile::tempfile().unwrap();
 
-        let client: Arc<FileClient> = Arc::new(
+        let client: Arc<FileClient<Block>> = Arc::new(
             FileClient::from_file(file.into(), NoopConsensus::arc())
                 .await
                 .unwrap()
                 .with_bodies(bodies.clone()),
         );
-        let mut downloader = BodiesDownloaderBuilder::default()
-            .build::<reth_primitives::Block, _, _>(
-                client.clone(),
-                Arc::new(TestConsensus::default()),
-                factory,
-            );
+        let mut downloader = BodiesDownloaderBuilder::default().build::<Block, _, _>(
+            client.clone(),
+            Arc::new(TestConsensus::default()),
+            factory,
+        );
         downloader.set_download_range(0..=19).expect("failed to set download range");
 
         assert_matches!(
@@ -625,7 +622,7 @@ mod tests {
         let p0 = child_header(&p1);
 
         let file = tempfile::tempfile().unwrap();
-        let client: Arc<FileClient> = Arc::new(
+        let client: Arc<FileClient<Block>> = Arc::new(
             FileClient::from_file(file.into(), NoopConsensus::arc()).await.unwrap().with_headers(
                 HashMap::from([
                     (0u64, p0.clone_header()),
@@ -656,7 +653,7 @@ mod tests {
         // Generate some random blocks
         let (file, headers, _) = generate_bodies_file(0..=19).await;
         // now try to read them back
-        let client: Arc<FileClient> =
+        let client: Arc<FileClient<Block>> =
             Arc::new(FileClient::from_file(file, NoopConsensus::arc()).await.unwrap());
 
         // construct headers downloader and use first header
@@ -682,18 +679,17 @@ mod tests {
         let (file, headers, mut bodies) = generate_bodies_file(0..=19).await;
 
         // now try to read them back
-        let client: Arc<FileClient> =
+        let client: Arc<FileClient<Block>> =
             Arc::new(FileClient::from_file(file, NoopConsensus::arc()).await.unwrap());
 
         // insert headers in db for the bodies downloader
         insert_headers(factory.db_ref().db(), &headers);
 
-        let mut downloader = BodiesDownloaderBuilder::default()
-            .build::<reth_primitives::Block, _, _>(
-                client.clone(),
-                Arc::new(TestConsensus::default()),
-                factory,
-            );
+        let mut downloader = BodiesDownloaderBuilder::default().build::<Block, _, _>(
+            client.clone(),
+            Arc::new(TestConsensus::default()),
+            factory,
+        );
         downloader.set_download_range(0..=19).expect("failed to set download range");
 
         assert_matches!(

crates/net/downloaders/src/headers/noop.rs

@@ -4,7 +4,7 @@ use reth_network_p2p::headers::{
     downloader::{HeaderDownloader, SyncTarget},
     error::HeadersDownloaderError,
 };
-use reth_primitives::SealedHeader;
+use reth_primitives_traits::SealedHeader;
 use std::fmt::Debug;
 
 /// A [`HeaderDownloader`] implementation that does nothing.

crates/net/downloaders/src/headers/reverse_headers.rs

@@ -20,7 +20,7 @@ use reth_network_p2p::{
     priority::Priority,
 };
 use reth_network_peers::PeerId;
-use reth_primitives::{GotExpected, SealedHeader};
+use reth_primitives_traits::{GotExpected, SealedHeader};
 use reth_tasks::{TaskSpawner, TokioTaskExecutor};
 use std::{
     cmp::{Ordering, Reverse},

crates/net/downloaders/src/headers/task.rs

@@ -6,7 +6,7 @@ use reth_network_p2p::headers::{
     downloader::{HeaderDownloader, SyncTarget},
     error::HeadersDownloaderResult,
 };
-use reth_primitives::SealedHeader;
+use reth_primitives_traits::SealedHeader;
 use reth_tasks::{TaskSpawner, TokioTaskExecutor};
 use std::{
     fmt::Debug,

crates/net/downloaders/src/headers/test_utils.rs

@@ -2,7 +2,7 @@
 
 #![allow(dead_code)]
 
-use reth_primitives::SealedHeader;
+use reth_primitives_traits::SealedHeader;
 
 /// Returns a new [`SealedHeader`] that's the child header of the given `parent`.
 pub(crate) fn child_header(parent: &SealedHeader) -> SealedHeader {

crates/net/downloaders/src/receipt_file_client.rs

@@ -1,7 +1,6 @@
 use std::{fmt, io};
 
 use futures::Future;
-use reth_primitives::Receipt;
 use tokio::io::AsyncReadExt;
 use tokio_stream::StreamExt;
 use tokio_util::codec::{Decoder, FramedRead};
@@ -203,9 +202,9 @@ where
     }
 }
 
-/// [`Receipt`] with block number.
+/// Receipt with block number.
 #[derive(Debug, PartialEq, Eq)]
-pub struct ReceiptWithBlockNumber<R = Receipt> {
+pub struct ReceiptWithBlockNumber<R> {
     /// Receipt.
     pub receipt: R,
     /// Block number.
@@ -220,7 +219,7 @@ mod test {
         hex, Bytes, Log, LogData,
     };
     use alloy_rlp::{Decodable, RlpDecodable};
-    use reth_primitives::{Receipt, TxType};
+    use reth_ethereum_primitives::{Receipt, TxType};
     use reth_tracing::init_test_tracing;
     use tokio_util::codec::Decoder;
 
@@ -240,7 +239,7 @@ mod test {
     #[rlp(trailing)]
     struct MockReceiptContainer(Option<MockReceipt>);
 
-    impl TryFrom<MockReceipt> for ReceiptWithBlockNumber {
+    impl TryFrom<MockReceipt> for ReceiptWithBlockNumber<Receipt> {
         type Error = FileClientError;
         fn try_from(exported_receipt: MockReceipt) -> Result<Self, Self::Error> {
             let MockReceipt { tx_type, status, cumulative_gas_used, logs, block_number: number } =
@@ -262,7 +261,7 @@ mod test {
     struct MockReceiptFileCodec;
 
     impl Decoder for MockReceiptFileCodec {
-        type Item = Option<ReceiptWithBlockNumber>;
+        type Item = Option<ReceiptWithBlockNumber<Receipt>>;
         type Error = FileClientError;
 
         fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
@@ -325,7 +324,7 @@ mod test {
         }
     }
 
-    fn receipt_block_1() -> ReceiptWithBlockNumber {
+    fn receipt_block_1() -> ReceiptWithBlockNumber<Receipt> {
         let log_1 = Log {
             address: address!("0x8ce8c13d816fe6daf12d6fd9e4952e1fc88850ae"),
             data: LogData::new(
@@ -379,7 +378,7 @@ mod test {
         ReceiptWithBlockNumber { receipt, number: 1 }
     }
 
-    fn receipt_block_2() -> ReceiptWithBlockNumber {
+    fn receipt_block_2() -> ReceiptWithBlockNumber<Receipt> {
         let log_1 = Log {
             address: address!("0x8ce8c13d816fe6daf12d6fd9e4952e1fc88850ae"),
             data: LogData::new(
@@ -417,7 +416,7 @@ mod test {
         ReceiptWithBlockNumber { receipt, number: 2 }
     }
 
-    fn receipt_block_3() -> ReceiptWithBlockNumber {
+    fn receipt_block_3() -> ReceiptWithBlockNumber<Receipt> {
         let log_1 = Log {
             address: address!("0x8ce8c13d816fe6daf12d6fd9e4952e1fc88850ae"),
             data: LogData::new(

crates/net/downloaders/src/test_utils/bodies_client.rs

@@ -1,11 +1,11 @@
 use alloy_primitives::B256;
+use reth_ethereum_primitives::BlockBody;
 use reth_network_p2p::{
     bodies::client::{BodiesClient, BodiesFut},
     download::DownloadClient,
     priority::Priority,
 };
 use reth_network_peers::PeerId;
-use reth_primitives::BlockBody;
 use std::{
     collections::HashMap,
     fmt::Debug,

crates/net/downloaders/src/test_utils/mod.rs

@@ -5,7 +5,7 @@
 use crate::{bodies::test_utils::create_raw_bodies, file_codec::BlockFileCodec};
 use alloy_primitives::B256;
 use futures::SinkExt;
-use reth_primitives::{BlockBody, SealedHeader};
+use reth_ethereum_primitives::BlockBody;
 use reth_testing_utils::generators::{self, random_block_range, BlockRangeParams};
 use std::{collections::HashMap, io::SeekFrom, ops::RangeInclusive};
 use tokio::{fs::File, io::AsyncSeekExt};
@@ -13,6 +13,7 @@ use tokio_util::codec::FramedWrite;
 
 mod bodies_client;
 pub use bodies_client::TestBodiesClient;
+use reth_primitives_traits::SealedHeader;
 
 /// Metrics scope used for testing.
 pub(crate) const TEST_SCOPE: &str = "downloaders.test";