primitives: rm more alloy_primitives reexports (#11255)

Cargo.lock

@@ -2635,6 +2635,7 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
 name = "example-beacon-api-sidecar-fetcher"
 version = "0.1.0"
 dependencies = [
+ "alloy-primitives",
  "alloy-rpc-types-beacon",
  "clap",
  "eyre",
@@ -2665,6 +2666,7 @@ dependencies = [
 name = "example-bsc-p2p"
 version = "0.0.0"
 dependencies = [
+ "alloy-primitives",
  "reth-chainspec",
  "reth-discv4",
  "reth-network",
@@ -2683,6 +2685,7 @@ name = "example-custom-dev-node"
 version = "0.0.0"
 dependencies = [
  "alloy-genesis",
+ "alloy-primitives",
  "eyre",
  "futures-util",
  "reth",
@@ -2779,6 +2782,7 @@ dependencies = [
 name = "example-custom-rlpx-subprotocol"
 version = "0.0.0"
 dependencies = [
+ "alloy-primitives",
  "eyre",
  "futures",
  "rand 0.8.5",
@@ -2874,6 +2878,7 @@ dependencies = [
 name = "example-polygon-p2p"
 version = "0.0.0"
 dependencies = [
+ "alloy-primitives",
  "reth-chainspec",
  "reth-discv4",
  "reth-network",
@@ -6311,6 +6316,7 @@ version = "1.0.7"
 dependencies = [
  "alloy-eips",
  "alloy-json-rpc",
+ "alloy-primitives",
  "alloy-provider",
  "alloy-pubsub",
  "alloy-rpc-client",
@@ -6616,6 +6622,7 @@ version = "1.0.7"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
+ "alloy-primitives",
  "alloy-provider",
  "alloy-rpc-types",
  "alloy-rpc-types-engine",
@@ -6624,7 +6631,6 @@ dependencies = [
  "futures",
  "reqwest",
  "reth-node-api",
- "reth-node-core",
  "reth-rpc-api",
  "reth-rpc-builder",
  "reth-tracing",

bin/reth-bench/Cargo.toml

@@ -36,6 +36,7 @@ alloy-pubsub.workspace = true
 alloy-json-rpc.workspace = true
 alloy-rpc-client.workspace = true
 alloy-eips.workspace = true
+alloy-primitives.workspace = true
 
 # reqwest
 reqwest = { workspace = true, default-features = false, features = [

bin/reth-bench/src/bench/new_payload_fcu.rs

@@ -11,13 +11,14 @@ use crate::{
     },
     valid_payload::{call_forkchoice_updated, call_new_payload},
 };
+use alloy_primitives::B256;
 use alloy_provider::Provider;
 use alloy_rpc_types_engine::ForkchoiceState;
 use clap::Parser;
 use csv::Writer;
 use reth_cli_runner::CliContext;
 use reth_node_core::args::BenchmarkArgs;
-use reth_primitives::{Block, B256};
+use reth_primitives::Block;
 use reth_rpc_types_compat::engine::payload::block_to_payload;
 use std::time::Instant;
 use tracing::{debug, info};

bin/reth-bench/src/bench/new_payload_only.rs

@@ -10,12 +10,13 @@ use crate::{
     },
     valid_payload::call_new_payload,
 };
+use alloy_primitives::B256;
 use alloy_provider::Provider;
 use clap::Parser;
 use csv::Writer;
 use reth_cli_runner::CliContext;
 use reth_node_core::args::BenchmarkArgs;
-use reth_primitives::{Block, B256};
+use reth_primitives::Block;
 use reth_rpc_types_compat::engine::payload::block_to_payload;
 use std::time::Instant;
 use tracing::{debug, info};

bin/reth-bench/src/valid_payload.rs

@@ -2,6 +2,7 @@
 //! response. This is useful for benchmarking, as it allows us to wait for a payload to be valid
 //! before sending additional calls.
 
+use alloy_primitives::B256;
 use alloy_provider::{ext::EngineApi, Network};
 use alloy_rpc_types_engine::{
     ExecutionPayload, ExecutionPayloadInputV2, ExecutionPayloadV1, ExecutionPayloadV3,
@@ -9,7 +10,6 @@ use alloy_rpc_types_engine::{
 };
 use alloy_transport::{Transport, TransportResult};
 use reth_node_api::EngineApiMessageVersion;
-use reth_primitives::B256;
 use tracing::error;
 
 /// An extension trait for providers that implement the engine API, to wait for a VALID response.

bin/reth/src/commands/debug_cmd/build_block.rs

@@ -1,6 +1,6 @@
 //! Command for debugging block building.
 use alloy_consensus::TxEip4844;
-use alloy_primitives::Address;
+use alloy_primitives::{Address, B256, U256};
 use alloy_rlp::Decodable;
 use alloy_rpc_types::engine::{BlobsBundleV1, PayloadAttributes};
 use clap::Parser;
@@ -27,7 +27,6 @@ use reth_payload_builder::database::CachedReads;
 use reth_primitives::{
     revm_primitives::KzgSettings, BlobTransaction, BlobTransactionSidecar, Bytes,
     PooledTransactionsElement, SealedBlock, SealedBlockWithSenders, Transaction, TransactionSigned,
-    B256, U256,
 };
 use reth_provider::{
     providers::BlockchainProvider, BlockHashReader, BlockReader, BlockWriter, ChainSpecProvider,

bin/reth/src/commands/debug_cmd/execution.rs

@@ -1,7 +1,7 @@
 //! Command for debugging execution.
 
 use crate::{args::NetworkArgs, utils::get_single_header};
-use alloy_primitives::BlockNumber;
+use alloy_primitives::{BlockNumber, B256};
 use clap::Parser;
 use futures::{stream::select as stream_select, StreamExt};
 use reth_beacon_consensus::EthBeaconConsensus;
@@ -23,7 +23,7 @@ use reth_network_api::NetworkInfo;
 use reth_network_p2p::{headers::client::HeadersClient, BlockClient};
 use reth_node_api::{NodeTypesWithDB, NodeTypesWithDBAdapter, NodeTypesWithEngine};
 use reth_node_ethereum::EthExecutorProvider;
-use reth_primitives::{BlockHashOrNumber, B256};
+use reth_primitives::BlockHashOrNumber;
 use reth_provider::{
     BlockExecutionWriter, ChainSpecProvider, ProviderFactory, StageCheckpointReader,
 };

crates/consensus/debug-client/Cargo.toml

@@ -13,7 +13,6 @@ workspace = true
 [dependencies]
 # reth
 reth-node-api.workspace = true
-reth-node-core.workspace = true
 reth-rpc-api.workspace = true
 reth-rpc-builder.workspace = true
 reth-tracing.workspace = true
@@ -24,6 +23,7 @@ alloy-eips.workspace = true
 alloy-provider = { workspace = true, features = ["ws"] }
 alloy-rpc-types.workspace = true
 alloy-rpc-types-engine.workspace = true
+alloy-primitives.workspace = true
 
 auto_impl.workspace = true
 futures.workspace = true

crates/consensus/debug-client/src/client.rs

@@ -1,9 +1,9 @@
 use alloy_consensus::TxEnvelope;
 use alloy_eips::eip2718::Encodable2718;
+use alloy_primitives::B256;
 use alloy_rpc_types::{Block, BlockTransactions};
 use alloy_rpc_types_engine::{ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3};
 use reth_node_api::EngineTypes;
-use reth_node_core::primitives::B256;
 use reth_rpc_builder::auth::AuthServerHandle;
 use reth_tracing::tracing::warn;
 use ringbuffer::{AllocRingBuffer, RingBuffer};

crates/engine/tree/src/tree/persistence_state.rs

@@ -1,5 +1,5 @@
 use alloy_eips::BlockNumHash;
-use reth_primitives::B256;
+use alloy_primitives::B256;
 use std::{collections::VecDeque, time::Instant};
 use tokio::sync::oneshot;
 use tracing::{debug, trace};

crates/exex/exex/src/wal/mod.rs

@@ -9,8 +9,8 @@ pub use storage::Storage;
 use std::{path::Path, sync::Arc};
 
 use alloy_eips::BlockNumHash;
+use alloy_primitives::B256;
 use reth_exex_types::ExExNotification;
-use reth_primitives::B256;
 use reth_tracing::tracing::{debug, instrument};
 
 /// WAL is a write-ahead log (WAL) that stores the notifications sent to ExExes.

crates/net/downloaders/src/receipt_file_client.rs

@@ -213,9 +213,9 @@ pub struct ReceiptWithBlockNumber {
 
 #[cfg(test)]
 mod test {
-    use alloy_primitives::{hex, Address, Bytes, Log, LogData, B256};
+    use alloy_primitives::{bytes::BytesMut, hex, Address, Bytes, Log, LogData, B256};
     use alloy_rlp::{Decodable, RlpDecodable};
-    use reth_primitives::{Buf, BytesMut, Receipt, TxType};
+    use reth_primitives::{Buf, Receipt, TxType};
     use reth_tracing::init_test_tracing;
     use tokio_util::codec::Decoder;
 

crates/net/network/src/protocol.rs

@@ -9,12 +9,12 @@ use std::{
     pin::Pin,
 };
 
+use alloy_primitives::bytes::BytesMut;
 use futures::Stream;
 use reth_eth_wire::{
     capability::SharedCapabilities, multiplex::ProtocolConnection, protocol::Protocol,
 };
 use reth_network_api::{Direction, PeerId};
-use reth_primitives::BytesMut;
 
 /// A trait that allows to offer additional RLPx-based application-level protocols when establishing
 /// a peer-to-peer connection.

crates/net/network/tests/it/multiplex.rs

@@ -7,6 +7,7 @@ use std::{
     task::{ready, Context, Poll},
 };
 
+use alloy_primitives::bytes::BytesMut;
 use futures::{Stream, StreamExt};
 use reth_eth_wire::{
     capability::SharedCapabilities, multiplex::ProtocolConnection, protocol::Protocol,
@@ -16,7 +17,6 @@ use reth_network::{
     test_utils::Testnet,
 };
 use reth_network_api::{Direction, PeerId};
-use reth_primitives::BytesMut;
 use reth_provider::test_utils::MockEthProvider;
 use tokio::sync::{mpsc, oneshot};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -26,8 +26,9 @@ use crate::multiplex::proto::{PingPongProtoMessage, PingPongProtoMessageKind};
 /// A simple Rlpx subprotocol that sends pings and pongs
 mod proto {
     use super::*;
+    use alloy_primitives::bytes::BufMut;
     use reth_eth_wire::Capability;
-    use reth_primitives::{Buf, BufMut};
+    use reth_primitives::Buf;
 
     #[repr(u8)]
     #[derive(Clone, Copy, Debug, PartialEq, Eq)]

crates/node/builder/src/setup.rs

@@ -2,7 +2,7 @@
 
 use std::sync::Arc;
 
-use alloy_primitives::BlockNumber;
+use alloy_primitives::{BlockNumber, B256};
 use reth_config::{config::StageConfig, PruneConfig};
 use reth_consensus::Consensus;
 use reth_downloaders::{
@@ -14,7 +14,6 @@ use reth_exex::ExExManagerHandle;
 use reth_network_p2p::{
     bodies::downloader::BodyDownloader, headers::downloader::HeaderDownloader, BlockClient,
 };
-use reth_node_core::primitives::B256;
 use reth_provider::{providers::ProviderNodeTypes, ProviderFactory};
 use reth_stages::{prelude::DefaultStages, stages::ExecutionStage, Pipeline, StageSet};
 use reth_static_file::StaticFileProducer;

crates/node/core/src/args/gas_price_oracle.rs

@@ -1,4 +1,4 @@
-use crate::primitives::U256;
+use alloy_primitives::U256;
 use clap::Args;
 use reth_rpc_eth_types::GasPriceOracleConfig;
 use reth_rpc_server_types::constants::gas_oracle::{

crates/optimism/cli/src/commands/init_state/bedrock.rs

@@ -1,7 +1,7 @@
-use alloy_primitives::{BlockNumber, B256};
+use alloy_primitives::{BlockNumber, B256, U256};
 use reth_optimism_primitives::bedrock::{BEDROCK_HEADER, BEDROCK_HEADER_HASH, BEDROCK_HEADER_TTD};
 use reth_primitives::{
-    BlockBody, Header, SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, U256,
+    BlockBody, Header, SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment,
 };
 use reth_provider::{
     providers::StaticFileProvider, BlockWriter, StageCheckpointWriter, StaticFileWriter,

crates/optimism/primitives/src/bedrock.rs

@@ -1,7 +1,7 @@
 //! OP mainnet bedrock related data.
 
-use alloy_primitives::{b256, bloom, bytes, B256, B64, U256};
-use reth_primitives::{address, Header};
+use alloy_primitives::{address, b256, bloom, bytes, B256, B64, U256};
+use reth_primitives::Header;
 use reth_primitives_traits::constants::EMPTY_OMMER_ROOT_HASH;
 
 /// Transaction 0x9ed8f713b2cc6439657db52dcd2fdb9cc944915428f3c6e2a7703e242b259cb9 in block 985,

crates/payload/builder/src/lib.rs

@@ -27,8 +27,9 @@
 //! use std::future::Future;
 //! use std::pin::Pin;
 //! use std::task::{Context, Poll};
+//! use alloy_primitives::U256;
 //! use reth_payload_builder::{EthBuiltPayload, PayloadBuilderError, KeepPayloadJobAlive, EthPayloadBuilderAttributes, PayloadJob, PayloadJobGenerator};
-//! use reth_primitives::{Block, Header, U256};
+//! use reth_primitives::{Block, Header};
 //!
 //! /// The generator type that creates new jobs that builds empty blocks.
 //! pub struct EmptyBlockPayloadJobGenerator;

crates/primitives/src/block.rs

@@ -1,12 +1,12 @@
 use crate::{
     Bytes, GotExpected, Header, SealedHeader, TransactionSigned, TransactionSignedEcRecovered,
-    Withdrawals, B256,
+    Withdrawals,
 };
 use alloc::vec::Vec;
 pub use alloy_eips::eip1898::{
     BlockHashOrNumber, BlockId, BlockNumHash, BlockNumberOrTag, ForkBlock, RpcBlockHash,
 };
-use alloy_primitives::{Address, Sealable};
+use alloy_primitives::{Address, Sealable, B256};
 use alloy_rlp::{Decodable, Encodable, RlpDecodable, RlpEncodable};
 use derive_more::{Deref, DerefMut};
 #[cfg(any(test, feature = "arbitrary"))]

crates/primitives/src/lib.rs

@@ -69,11 +69,7 @@ pub use transaction::{
 };
 
 // Re-exports
-pub use alloy_primitives::{
-    self, address, b256, bloom, bytes,
-    bytes::{Buf, BufMut, BytesMut},
-    hex, Bytes, TxHash, B256, U256, U64,
-};
+pub use alloy_primitives::{self, bloom, bytes, bytes::Buf, hex, Bytes, TxHash};
 pub use reth_ethereum_forks::*;
 pub use revm_primitives::{self, JumpTable};
 

crates/primitives/src/proofs.rs

@@ -2,11 +2,11 @@
 
 use crate::{
     constants::EMPTY_OMMER_ROOT_HASH, Header, Receipt, ReceiptWithBloom, ReceiptWithBloomRef,
-    Request, TransactionSigned, Withdrawal, B256,
+    Request, TransactionSigned, Withdrawal,
 };
 use alloc::vec::Vec;
 use alloy_eips::eip7685::Encodable7685;
-use alloy_primitives::keccak256;
+use alloy_primitives::{keccak256, B256};
 use reth_trie_common::root::{ordered_trie_root, ordered_trie_root_with_encoder};
 
 /// Calculate a transaction root.
@@ -65,9 +65,9 @@ pub fn calculate_ommers_root(ommers: &[Header]) -> B256 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{constants::EMPTY_ROOT_HASH, Block, U256};
+    use crate::{constants::EMPTY_ROOT_HASH, Block};
     use alloy_genesis::GenesisAccount;
-    use alloy_primitives::{b256, hex_literal::hex, Address};
+    use alloy_primitives::{b256, hex_literal::hex, Address, U256};
     use alloy_rlp::Decodable;
     use reth_chainspec::{HOLESKY, MAINNET, SEPOLIA};
     use reth_trie_common::root::{state_root_ref_unhashed, state_root_unhashed};

crates/primitives/src/receipt.rs

@@ -1,11 +1,11 @@
 #[cfg(feature = "reth-codec")]
 use crate::compression::{RECEIPT_COMPRESSOR, RECEIPT_DECOMPRESSOR};
 use crate::{
-    logs_bloom, Bytes, TxType, B256, EIP1559_TX_TYPE_ID, EIP2930_TX_TYPE_ID, EIP4844_TX_TYPE_ID,
+    logs_bloom, Bytes, TxType, EIP1559_TX_TYPE_ID, EIP2930_TX_TYPE_ID, EIP4844_TX_TYPE_ID,
     EIP7702_TX_TYPE_ID,
 };
 use alloc::{vec, vec::Vec};
-use alloy_primitives::{Bloom, Log};
+use alloy_primitives::{Bloom, Log, B256};
 use alloy_rlp::{length_of_length, Decodable, Encodable, RlpDecodable, RlpEncodable};
 use bytes::{Buf, BufMut};
 use core::{cmp::Ordering, ops::Deref};

crates/primitives/src/transaction/access_list.rs

@@ -2,9 +2,8 @@
 
 #[cfg(test)]
 mod tests {
-    use crate::B256;
     use alloy_eips::eip2930::{AccessList, AccessListItem};
-    use alloy_primitives::Address;
+    use alloy_primitives::{Address, B256};
     use alloy_rlp::{RlpDecodable, RlpDecodableWrapper, RlpEncodable, RlpEncodableWrapper};
     use proptest::proptest;
     use proptest_arbitrary_interop::arb;

crates/primitives/src/transaction/compat.rs

@@ -1,5 +1,5 @@
-use crate::{Transaction, TransactionSigned, U256};
-use alloy_primitives::{Address, TxKind};
+use crate::{Transaction, TransactionSigned};
+use alloy_primitives::{Address, TxKind, U256};
 use revm_primitives::{AuthorizationList, TxEnv};
 
 /// Implements behaviour to fill a [`TxEnv`] from another transaction.

crates/primitives/src/transaction/error.rs

@@ -1,4 +1,5 @@
-use crate::{GotExpectedBoxed, U256};
+use crate::GotExpectedBoxed;
+use alloy_primitives::U256;
 
 /// Represents error variants that can happen when trying to validate a
 /// [Transaction](crate::Transaction)

crates/primitives/src/transaction/meta.rs

@@ -1,4 +1,4 @@
-use crate::B256;
+use alloy_primitives::B256;
 
 /// Additional fields in the context of a block that contains this transaction.
 #[derive(Debug, Clone, Copy, Default, Eq, PartialEq)]

crates/primitives/src/transaction/mod.rs

@@ -1,8 +1,8 @@
 //! Transaction types.
 
-use crate::{BlockHashOrNumber, Bytes, TxHash, B256, U256};
+use crate::{BlockHashOrNumber, Bytes, TxHash};
 use alloy_eips::eip7702::SignedAuthorization;
-use alloy_primitives::{keccak256, Address, TxKind};
+use alloy_primitives::{keccak256, Address, TxKind, B256, U256};
 
 use alloy_consensus::{SignableTransaction, TxEip1559, TxEip2930, TxEip4844, TxEip7702, TxLegacy};
 use alloy_eips::eip2930::AccessList;
@@ -1708,9 +1708,9 @@ mod tests {
         hex,
         transaction::{signature::Signature, TxEip1559, TxKind, TxLegacy},
         Bytes, Transaction, TransactionSigned, TransactionSignedEcRecovered,
-        TransactionSignedNoHash, B256, U256,
+        TransactionSignedNoHash,
     };
-    use alloy_primitives::{address, b256, bytes, Address, Parity};
+    use alloy_primitives::{address, b256, bytes, Address, Parity, B256, U256};
     use alloy_rlp::{Decodable, Encodable, Error as RlpError};
     use reth_chainspec::MIN_TRANSACTION_GAS;
     use reth_codecs::Compact;

crates/primitives/src/transaction/pooled.rs

@@ -8,14 +8,14 @@ use super::{
 };
 use crate::{
     BlobTransaction, BlobTransactionSidecar, Bytes, Signature, Transaction, TransactionSigned,
-    TransactionSignedEcRecovered, TxHash, B256, EIP4844_TX_TYPE_ID,
+    TransactionSignedEcRecovered, TxHash, EIP4844_TX_TYPE_ID,
 };
 use alloc::vec::Vec;
 use alloy_consensus::{
     transaction::{TxEip1559, TxEip2930, TxEip4844, TxLegacy},
     SignableTransaction, TxEip4844WithSidecar,
 };
-use alloy_primitives::Address;
+use alloy_primitives::{Address, B256};
 use alloy_rlp::{Decodable, Encodable, Error as RlpError, Header, EMPTY_LIST_CODE};
 use bytes::Buf;
 use derive_more::{AsRef, Deref};

crates/primitives/src/transaction/signature.rs

@@ -1,5 +1,5 @@
-use crate::{transaction::util::secp256k1, B256, U256};
-use alloy_primitives::{Address, Parity};
+use crate::transaction::util::secp256k1;
+use alloy_primitives::{Address, Parity, B256, U256};
 use alloy_rlp::{Decodable, Error as RlpError};
 
 pub use alloy_primitives::Signature;
@@ -119,9 +119,9 @@ mod tests {
         transaction::signature::{
             legacy_parity, recover_signer, recover_signer_unchecked, SECP256K1N_HALF,
         },
-        Signature, B256, U256,
+        Signature,
     };
-    use alloy_primitives::{Address, Parity};
+    use alloy_primitives::{Address, Parity, B256, U256};
     use std::str::FromStr;
 
     #[test]

crates/primitives/src/transaction/variant.rs

@@ -2,9 +2,9 @@
 //! `TransactionSignedEcRecovered`
 
 use crate::{
-    Transaction, TransactionSigned, TransactionSignedEcRecovered, TransactionSignedNoHash, B256,
+    Transaction, TransactionSigned, TransactionSignedEcRecovered, TransactionSignedNoHash,
 };
-use alloy_primitives::Address;
+use alloy_primitives::{Address, B256};
 use core::ops::Deref;
 
 /// Represents various different transaction formats used in reth.

crates/revm/src/database.rs

@@ -1,7 +1,7 @@
 use crate::primitives::alloy_primitives::{BlockNumber, StorageKey, StorageValue};
-use alloy_primitives::Address;
+use alloy_primitives::{Address, B256, U256};
 use core::ops::{Deref, DerefMut};
-use reth_primitives::{Account, B256, U256};
+use reth_primitives::Account;
 use reth_storage_errors::provider::{ProviderError, ProviderResult};
 use revm::{
     db::DatabaseRef,

crates/revm/src/state_change.rs

@@ -1,7 +1,7 @@
-use alloy_primitives::{map::HashMap, Address};
+use alloy_primitives::{map::HashMap, Address, U256};
 use reth_chainspec::EthereumHardforks;
 use reth_consensus_common::calc;
-use reth_primitives::{Block, Withdrawal, Withdrawals, U256};
+use reth_primitives::{Block, Withdrawal, Withdrawals};
 
 /// Collect all balance changes at the end of the block.
 ///

crates/revm/src/test_utils.rs

@@ -2,9 +2,9 @@ use alloc::vec::Vec;
 use alloy_primitives::{
     keccak256,
     map::{HashMap, HashSet},
-    Address, BlockNumber, StorageKey,
+    Address, BlockNumber, StorageKey, B256, U256,
 };
-use reth_primitives::{Account, Bytecode, Bytes, B256, U256};
+use reth_primitives::{Account, Bytecode, Bytes};
 use reth_storage_api::{
     AccountReader, BlockHashReader, StateProofProvider, StateProvider, StateRootProvider,
     StorageRootProvider,

crates/stages/stages/benches/setup/mod.rs

@@ -1,5 +1,5 @@
 #![allow(unreachable_pub)]
-use alloy_primitives::Address;
+use alloy_primitives::{Address, B256, U256};
 use itertools::concat;
 use reth_chainspec::ChainSpec;
 use reth_db::{tables, test_utils::TempDatabase, Database, DatabaseEnv};
@@ -7,7 +7,7 @@ use reth_db_api::{
     cursor::DbCursorRO,
     transaction::{DbTx, DbTxMut},
 };
-use reth_primitives::{alloy_primitives::Sealable, Account, SealedBlock, SealedHeader, B256, U256};
+use reth_primitives::{alloy_primitives::Sealable, Account, SealedBlock, SealedHeader};
 use reth_provider::{DatabaseProvider, DatabaseProviderFactory, TrieWriter};
 use reth_stages::{
     stages::{AccountHashingStage, StorageHashingStage},

crates/stages/stages/src/lib.rs

@@ -17,7 +17,7 @@
 //! # use reth_downloaders::headers::reverse_headers::ReverseHeadersDownloaderBuilder;
 //! # use reth_network_p2p::test_utils::{TestBodiesClient, TestHeadersClient};
 //! # use reth_evm_ethereum::execute::EthExecutorProvider;
-//! # use reth_primitives::B256;
+//! # use alloy_primitives::B256;
 //! # use reth_chainspec::MAINNET;
 //! # use reth_prune_types::PruneModes;
 //! # use reth_network_peers::PeerId;

crates/stages/stages/src/sets.rs

@@ -41,11 +41,11 @@ use crate::{
     },
     StageSet, StageSetBuilder,
 };
+use alloy_primitives::B256;
 use reth_config::config::StageConfig;
 use reth_consensus::Consensus;
 use reth_evm::execute::BlockExecutorProvider;
 use reth_network_p2p::{bodies::downloader::BodyDownloader, headers::downloader::HeaderDownloader};
-use reth_primitives::B256;
 use reth_provider::HeaderSyncGapProvider;
 use reth_prune_types::PruneModes;
 use reth_stages_api::Stage;

crates/stages/stages/src/stages/bodies.rs

@@ -622,7 +622,7 @@ mod tests {
                 UnwindStageTestRunner,
             },
         };
-        use alloy_primitives::{BlockHash, BlockNumber, TxNumber};
+        use alloy_primitives::{BlockHash, BlockNumber, TxNumber, B256};
         use futures_util::Stream;
         use reth_db::{static_file::HeaderMask, tables};
         use reth_db_api::{
@@ -637,9 +637,7 @@ mod tests {
             },
             error::DownloadResult,
         };
-        use reth_primitives::{
-            BlockBody, Header, SealedBlock, SealedHeader, StaticFileSegment, B256,
-        };
+        use reth_primitives::{BlockBody, Header, SealedBlock, SealedHeader, StaticFileSegment};
         use reth_provider::{
             providers::StaticFileWriter, test_utils::MockNodeTypesWithDB, HeaderProvider,
             ProviderFactory, StaticFileProviderFactory, TransactionsProvider,

crates/stages/stages/src/stages/execution.rs

@@ -658,14 +658,14 @@ where
 mod tests {
     use super::*;
     use crate::test_utils::TestStageDB;
-    use alloy_primitives::{hex_literal::hex, keccak256, Address};
+    use alloy_primitives::{address, hex_literal::hex, keccak256, Address, B256, U256};
     use alloy_rlp::Decodable;
     use assert_matches::assert_matches;
     use reth_chainspec::ChainSpecBuilder;
     use reth_db_api::{models::AccountBeforeTx, transaction::DbTxMut};
     use reth_evm_ethereum::execute::EthExecutorProvider;
     use reth_execution_errors::BlockValidationError;
-    use reth_primitives::{address, Account, Bytecode, SealedBlock, StorageEntry, B256, U256};
+    use reth_primitives::{Account, Bytecode, SealedBlock, StorageEntry};
     use reth_provider::{
         test_utils::create_test_provider_factory, AccountReader, DatabaseProviderFactory,
         ReceiptProvider, StaticFileProviderFactory,

crates/stages/stages/src/stages/hashing_account.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::keccak256;
+use alloy_primitives::{keccak256, B256};
 use itertools::Itertools;
 use reth_config::config::{EtlConfig, HashingConfig};
 use reth_db::{tables, RawKey, RawTable, RawValue};
@@ -7,7 +7,7 @@ use reth_db_api::{
     transaction::{DbTx, DbTxMut},
 };
 use reth_etl::Collector;
-use reth_primitives::{Account, B256};
+use reth_primitives::Account;
 use reth_provider::{AccountExtReader, DBProvider, HashingWriter, StatsReader};
 use reth_stages_api::{
     AccountHashingCheckpoint, EntitiesCheckpoint, ExecInput, ExecOutput, Stage, StageCheckpoint,
@@ -65,8 +65,8 @@ impl AccountHashingStage {
         provider: &reth_provider::DatabaseProvider<Tx, Spec>,
         opts: SeedOpts,
     ) -> Result<Vec<(alloy_primitives::Address, reth_primitives::Account)>, StageError> {
+        use alloy_primitives::U256;
         use reth_db_api::models::AccountBeforeTx;
-        use reth_primitives::U256;
         use reth_provider::{StaticFileProviderFactory, StaticFileWriter};
         use reth_testing_utils::{
             generators,
@@ -298,8 +298,9 @@ mod tests {
         stage_test_suite_ext, ExecuteStageTestRunner, StageTestRunner, TestRunnerError,
         UnwindStageTestRunner,
     };
+    use alloy_primitives::U256;
     use assert_matches::assert_matches;
-    use reth_primitives::{Account, U256};
+    use reth_primitives::Account;
     use reth_provider::providers::StaticFileWriter;
     use reth_stages_api::StageUnitCheckpoint;
     use test_utils::*;

crates/stages/stages/src/stages/hashing_storage.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::keccak256;
+use alloy_primitives::{bytes::BufMut, keccak256, B256};
 use itertools::Itertools;
 use reth_config::config::{EtlConfig, HashingConfig};
 use reth_db::tables;
@@ -9,7 +9,7 @@ use reth_db_api::{
     transaction::{DbTx, DbTxMut},
 };
 use reth_etl::Collector;
-use reth_primitives::{BufMut, StorageEntry, B256};
+use reth_primitives::StorageEntry;
 use reth_provider::{DBProvider, HashingWriter, StatsReader, StorageReader};
 use reth_stages_api::{
     EntitiesCheckpoint, ExecInput, ExecOutput, Stage, StageCheckpoint, StageError, StageId,
@@ -212,14 +212,14 @@ mod tests {
         stage_test_suite_ext, ExecuteStageTestRunner, StageTestRunner, TestRunnerError,
         TestStageDB, UnwindStageTestRunner,
     };
-    use alloy_primitives::Address;
+    use alloy_primitives::{Address, U256};
     use assert_matches::assert_matches;
     use rand::Rng;
     use reth_db_api::{
         cursor::{DbCursorRW, DbDupCursorRO},
         models::StoredBlockBodyIndices,
     };
-    use reth_primitives::{SealedBlock, U256};
+    use reth_primitives::SealedBlock;
     use reth_provider::providers::StaticFileWriter;
     use reth_testing_utils::generators::{
         self, random_block_range, random_contract_account_range, BlockRangeParams,

crates/stages/stages/src/stages/headers.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::{BlockHash, BlockNumber};
+use alloy_primitives::{BlockHash, BlockNumber, B256};
 use futures_util::StreamExt;
 use reth_codecs::Compact;
 use reth_config::config::EtlConfig;
@@ -11,7 +11,7 @@ use reth_db_api::{
 };
 use reth_etl::Collector;
 use reth_network_p2p::headers::{downloader::HeaderDownloader, error::HeadersDownloaderError};
-use reth_primitives::{SealedHeader, StaticFileSegment, B256};
+use reth_primitives::{SealedHeader, StaticFileSegment};
 use reth_provider::{
     providers::{StaticFileProvider, StaticFileWriter},
     BlockHashReader, DBProvider, HeaderProvider, HeaderSyncGap, HeaderSyncGapProvider,
@@ -378,10 +378,11 @@ mod tests {
     use crate::test_utils::{
         stage_test_suite, ExecuteStageTestRunner, StageTestRunner, UnwindStageTestRunner,
     };
+    use alloy_primitives::B256;
     use assert_matches::assert_matches;
     use reth_execution_types::ExecutionOutcome;
     use reth_primitives::{
-        alloy_primitives::Sealable, BlockBody, SealedBlock, SealedBlockWithSenders, B256,
+        alloy_primitives::Sealable, BlockBody, SealedBlock, SealedBlockWithSenders,
     };
     use reth_provider::{BlockWriter, ProviderFactory, StaticFileProviderFactory};
     use reth_stages_api::StageUnitCheckpoint;

crates/stages/stages/src/stages/index_account_history.rs

@@ -148,7 +148,7 @@ mod tests {
         stage_test_suite_ext, ExecuteStageTestRunner, StageTestRunner, TestRunnerError,
         TestStageDB, UnwindStageTestRunner,
     };
-    use alloy_primitives::BlockNumber;
+    use alloy_primitives::{address, BlockNumber, B256};
     use itertools::Itertools;
     use reth_db::BlockNumberList;
     use reth_db_api::{
@@ -159,7 +159,6 @@ mod tests {
         },
         transaction::DbTx,
     };
-    use reth_primitives::{address, B256};
     use reth_provider::{providers::StaticFileWriter, DatabaseProviderFactory};
     use reth_testing_utils::generators::{
         self, random_block_range, random_changeset_range, random_contract_account_range,

crates/stages/stages/src/stages/index_storage_history.rs

@@ -153,7 +153,7 @@ mod tests {
         stage_test_suite_ext, ExecuteStageTestRunner, StageTestRunner, TestRunnerError,
         TestStageDB, UnwindStageTestRunner,
     };
-    use alloy_primitives::{Address, BlockNumber};
+    use alloy_primitives::{address, b256, Address, BlockNumber, B256, U256};
     use itertools::Itertools;
     use reth_db::BlockNumberList;
     use reth_db_api::{
@@ -164,7 +164,7 @@ mod tests {
         },
         transaction::DbTx,
     };
-    use reth_primitives::{address, b256, StorageEntry, B256, U256};
+    use reth_primitives::StorageEntry;
     use reth_provider::{providers::StaticFileWriter, DatabaseProviderFactory};
     use reth_testing_utils::generators::{
         self, random_block_range, random_changeset_range, random_contract_account_range,

crates/stages/stages/src/stages/merkle.rs

@@ -1,9 +1,9 @@
-use alloy_primitives::BlockNumber;
+use alloy_primitives::{BlockNumber, B256};
 use reth_codecs::Compact;
 use reth_consensus::ConsensusError;
 use reth_db::tables;
 use reth_db_api::transaction::{DbTx, DbTxMut};
-use reth_primitives::{alloy_primitives::Sealable, GotExpected, SealedHeader, B256};
+use reth_primitives::{alloy_primitives::Sealable, GotExpected, SealedHeader};
 use reth_provider::{
     DBProvider, HeaderProvider, ProviderError, StageCheckpointReader, StageCheckpointWriter,
     StatsReader, TrieWriter,
@@ -374,10 +374,10 @@ mod tests {
         stage_test_suite_ext, ExecuteStageTestRunner, StageTestRunner, StorageKind,
         TestRunnerError, TestStageDB, UnwindStageTestRunner,
     };
-    use alloy_primitives::keccak256;
+    use alloy_primitives::{keccak256, U256};
     use assert_matches::assert_matches;
     use reth_db_api::cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO};
-    use reth_primitives::{SealedBlock, StaticFileSegment, StorageEntry, U256};
+    use reth_primitives::{SealedBlock, StaticFileSegment, StorageEntry};
     use reth_provider::{providers::StaticFileWriter, StaticFileProviderFactory};
     use reth_stages_api::StageUnitCheckpoint;
     use reth_testing_utils::generators::{

crates/stages/stages/src/stages/mod.rs

@@ -42,7 +42,7 @@ use utils::*;
 mod tests {
     use super::*;
     use crate::test_utils::{StorageKind, TestStageDB};
-    use alloy_primitives::{hex_literal::hex, keccak256, BlockNumber};
+    use alloy_primitives::{address, hex_literal::hex, keccak256, BlockNumber, B256, U256};
     use alloy_rlp::Decodable;
     use reth_chainspec::ChainSpecBuilder;
     use reth_db::{
@@ -56,7 +56,7 @@ mod tests {
     };
     use reth_evm_ethereum::execute::EthExecutorProvider;
     use reth_exex::ExExManagerHandle;
-    use reth_primitives::{address, Account, Bytecode, SealedBlock, StaticFileSegment, B256, U256};
+    use reth_primitives::{Account, Bytecode, SealedBlock, StaticFileSegment};
     use reth_provider::{
         providers::{StaticFileProvider, StaticFileWriter},
         test_utils::MockNodeTypesWithDB,

crates/stages/stages/src/stages/prune.rs

@@ -169,7 +169,8 @@ mod tests {
         stage_test_suite_ext, ExecuteStageTestRunner, StageTestRunner, StorageKind,
         TestRunnerError, TestStageDB, UnwindStageTestRunner,
     };
-    use reth_primitives::{SealedBlock, B256};
+    use alloy_primitives::B256;
+    use reth_primitives::SealedBlock;
     use reth_provider::{
         providers::StaticFileWriter, TransactionsProvider, TransactionsProviderExt,
     };

crates/stages/stages/src/stages/sender_recovery.rs

@@ -334,10 +334,10 @@ struct FailedSenderRecoveryError {
 
 #[cfg(test)]
 mod tests {
-    use alloy_primitives::BlockNumber;
+    use alloy_primitives::{BlockNumber, B256};
     use assert_matches::assert_matches;
     use reth_db_api::cursor::DbCursorRO;
-    use reth_primitives::{SealedBlock, TransactionSigned, B256};
+    use reth_primitives::{SealedBlock, TransactionSigned};
     use reth_provider::{
         providers::StaticFileWriter, DatabaseProviderFactory, PruneCheckpointWriter,
         StaticFileProviderFactory, TransactionsProvider,

crates/stages/stages/src/stages/tx_lookup.rs

@@ -250,9 +250,9 @@ mod tests {
         stage_test_suite_ext, ExecuteStageTestRunner, StageTestRunner, StorageKind,
         TestRunnerError, TestStageDB, UnwindStageTestRunner,
     };
-    use alloy_primitives::BlockNumber;
+    use alloy_primitives::{BlockNumber, B256};
     use assert_matches::assert_matches;
-    use reth_primitives::{SealedBlock, B256};
+    use reth_primitives::SealedBlock;
     use reth_provider::{
         providers::StaticFileWriter, DatabaseProviderFactory, StaticFileProviderFactory,
     };

crates/stages/stages/src/test_utils/test_db.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::{keccak256, Address, BlockNumber, TxNumber};
+use alloy_primitives::{keccak256, Address, BlockNumber, TxNumber, B256, U256};
 use reth_chainspec::MAINNET;
 use reth_db::{
     tables,
@@ -15,8 +15,7 @@ use reth_db_api::{
     DatabaseError as DbError,
 };
 use reth_primitives::{
-    Account, Receipt, SealedBlock, SealedHeader, StaticFileSegment, StorageEntry, TxHash, B256,
-    U256,
+    Account, Receipt, SealedBlock, SealedHeader, StaticFileSegment, StorageEntry, TxHash,
 };
 use reth_provider::{
     providers::{StaticFileProvider, StaticFileProviderRWRefMut, StaticFileWriter},

crates/storage/provider/src/providers/state/macros.rs

@@ -52,7 +52,7 @@ macro_rules! delegate_provider_impls {
             }
             StateProofProvider $(where [$($generics)*])? {
                 fn proof(&self, input: reth_trie::TrieInput, address: alloy_primitives::Address, slots: &[alloy_primitives::B256]) -> reth_storage_errors::provider::ProviderResult<reth_trie::AccountProof>;
-                fn multiproof(&self, input: reth_trie::TrieInput, targets: alloy_primitives::map::HashMap<reth_primitives::B256, alloy_primitives::map::HashSet<alloy_primitives::B256>>) -> reth_storage_errors::provider::ProviderResult<reth_trie::MultiProof>;
+                fn multiproof(&self, input: reth_trie::TrieInput, targets: alloy_primitives::map::HashMap<alloy_primitives::B256, alloy_primitives::map::HashSet<alloy_primitives::B256>>) -> reth_storage_errors::provider::ProviderResult<reth_trie::MultiProof>;
                 fn witness(&self, input: reth_trie::TrieInput, target: reth_trie::HashedPostState) -> reth_storage_errors::provider::ProviderResult<alloy_primitives::map::HashMap<alloy_primitives::B256, alloy_primitives::Bytes>>;
             }
         );

crates/storage/provider/src/test_utils/blocks.rs

@@ -2,15 +2,16 @@
 use crate::{DatabaseProviderRW, ExecutionOutcome};
 use alloy_consensus::TxLegacy;
 use alloy_primitives::{
-    hex_literal::hex, map::HashMap, Address, BlockNumber, Log, Parity, Sealable, TxKind,
+    b256, hex_literal::hex, map::HashMap, Address, BlockNumber, Log, Parity, Sealable, TxKind,
+    B256, U256,
 };
 use once_cell::sync::Lazy;
 use reth_db::tables;
 use reth_db_api::{database::Database, models::StoredBlockBodyIndices};
 use reth_primitives::{
-    alloy_primitives, b256, Account, BlockBody, Bytes, Header, Receipt, SealedBlock,
+    alloy_primitives, Account, BlockBody, Bytes, Header, Receipt, SealedBlock,
     SealedBlockWithSenders, SealedHeader, Signature, Transaction, TransactionSigned, TxType,
-    Withdrawal, Withdrawals, B256, U256,
+    Withdrawal, Withdrawals,
 };
 use reth_trie::root::{state_root_unhashed, storage_root_unhashed};
 use revm::{db::BundleState, primitives::AccountInfo};

crates/trie/db/src/state.rs

@@ -77,9 +77,10 @@ pub trait DatabaseStateRoot<'a, TX>: Sized {
     /// # Example
     ///
     /// ```
+    /// use alloy_primitives::U256;
     /// use reth_db::test_utils::create_test_rw_db;
     /// use reth_db_api::database::Database;
-    /// use reth_primitives::{Account, U256};
+    /// use reth_primitives::Account;
     /// use reth_trie::{updates::TrieUpdates, HashedPostState, StateRoot};
     /// use reth_trie_db::DatabaseStateRoot;
     ///
@@ -267,10 +268,10 @@ impl<TX: DbTx> DatabaseHashedPostState<TX> for HashedPostState {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_primitives::{map::HashMap, Address};
+    use alloy_primitives::{map::HashMap, Address, U256};
     use reth_db::test_utils::create_test_rw_db;
     use reth_db_api::database::Database;
-    use reth_primitives::{hex, revm_primitives::AccountInfo, U256};
+    use reth_primitives::{hex, revm_primitives::AccountInfo};
     use revm::db::BundleState;
 
     #[test]

examples/beacon-api-sidecar-fetcher/Cargo.toml

@@ -10,6 +10,7 @@ reth.workspace = true
 reth-node-ethereum.workspace = true
 
 alloy-rpc-types-beacon.workspace = true
+alloy-primitives.workspace = true
 
 clap.workspace = true
 eyre.workspace = true

examples/beacon-api-sidecar-fetcher/src/main.rs

@@ -18,11 +18,12 @@ use std::{
     net::{IpAddr, Ipv4Addr},
 };
 
+use alloy_primitives::B256;
 use clap::Parser;
 use futures_util::{stream::FuturesUnordered, StreamExt};
 use mined_sidecar::MinedSidecarStream;
 use reth::{
-    args::utils::DefaultChainSpecParser, builder::NodeHandle, cli::Cli, primitives::B256,
+    args::utils::DefaultChainSpecParser, builder::NodeHandle, cli::Cli,
     providers::CanonStateSubscriptions,
 };
 use reth_node_ethereum::EthereumNode;

examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs

@@ -1,10 +1,11 @@
 use crate::BeaconSidecarConfig;
+use alloy_primitives::B256;
 use alloy_rpc_types_beacon::sidecar::{BeaconBlobBundle, SidecarIterator};
 use eyre::Result;
 use futures_util::{stream::FuturesUnordered, Future, Stream, StreamExt};
 use reqwest::{Error, StatusCode};
 use reth::{
-    primitives::{BlobTransaction, SealedBlockWithSenders, B256},
+    primitives::{BlobTransaction, SealedBlockWithSenders},
     providers::CanonStateNotification,
     transaction_pool::{BlobStoreError, TransactionPoolExt},
 };

examples/bsc-p2p/Cargo.toml

@@ -16,9 +16,15 @@ reth-network-peers.workspace = true
 reth-primitives.workspace = true
 reth-tracing.workspace = true
 
-secp256k1 = { workspace = true, features = ["global-context", "rand-std", "recovery"] }
+secp256k1 = { workspace = true, features = [
+    "global-context",
+    "rand-std",
+    "recovery",
+] }
 
 tokio.workspace = true
 tokio-stream.workspace = true
 
 serde_json.workspace = true
+
+alloy-primitives.workspace = true

examples/bsc-p2p/src/chainspec.rs

@@ -1,8 +1,8 @@
+use alloy_primitives::{b256, B256};
 use reth_chainspec::{
     once_cell_set, BaseFeeParams, Chain, ChainHardforks, ChainSpec, EthereumHardfork, ForkCondition,
 };
 use reth_network_peers::NodeRecord;
-use reth_primitives::{b256, B256};
 
 use std::sync::Arc;
 

examples/custom-dev-node/Cargo.toml

@@ -19,3 +19,4 @@ tokio.workspace = true
 serde_json.workspace = true
 
 alloy-genesis.workspace = true
+alloy-primitives.workspace = true

examples/custom-dev-node/src/main.rs

@@ -6,6 +6,7 @@
 use std::sync::Arc;
 
 use alloy_genesis::Genesis;
+use alloy_primitives::{b256, hex};
 use futures_util::StreamExt;
 use reth::{
     builder::{NodeBuilder, NodeHandle},
@@ -16,7 +17,6 @@ use reth::{
 use reth_chainspec::ChainSpec;
 use reth_node_core::{args::RpcServerArgs, node_config::NodeConfig};
 use reth_node_ethereum::EthereumNode;
-use reth_primitives::{b256, hex};
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {

examples/custom-engine-types/src/main.rs

@@ -23,7 +23,7 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use alloy_genesis::Genesis;
-use alloy_primitives::Address;
+use alloy_primitives::{Address, B256};
 use alloy_rpc_types::{
     engine::{
         ExecutionPayloadEnvelopeV2, ExecutionPayloadEnvelopeV3, ExecutionPayloadEnvelopeV4,
@@ -64,7 +64,7 @@ use reth_payload_builder::{
     EthBuiltPayload, EthPayloadBuilderAttributes, PayloadBuilderError, PayloadBuilderHandle,
     PayloadBuilderService,
 };
-use reth_primitives::{Withdrawals, B256};
+use reth_primitives::Withdrawals;
 use reth_tracing::{RethTracer, Tracer};
 
 /// A custom payload attributes type.

examples/custom-evm/src/main.rs

@@ -3,7 +3,7 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 
 use alloy_genesis::Genesis;
-use alloy_primitives::Address;
+use alloy_primitives::{address, Address, U256};
 use reth::{
     builder::{
         components::{ExecutorBuilder, PayloadServiceBuilder},
@@ -11,7 +11,6 @@ use reth::{
     },
     payload::{EthBuiltPayload, EthPayloadBuilderAttributes},
     primitives::{
-        address,
         revm_primitives::{Env, PrecompileResult},
         Bytes,
     },
@@ -39,7 +38,7 @@ use reth_node_ethereum::{
 };
 use reth_primitives::{
     revm_primitives::{CfgEnvWithHandlerCfg, TxEnv},
-    Header, TransactionSigned, U256,
+    Header, TransactionSigned,
 };
 use reth_tracing::{RethTracer, Tracer};
 use std::sync::Arc;

examples/custom-rlpx-subprotocol/Cargo.toml

@@ -21,3 +21,4 @@ tokio-stream.workspace = true
 eyre.workspace = true
 rand.workspace = true
 tracing.workspace = true
+alloy-primitives.workspace = true

examples/custom-rlpx-subprotocol/src/subprotocol/connection/mod.rs

@@ -1,7 +1,7 @@
 use super::protocol::proto::{CustomRlpxProtoMessage, CustomRlpxProtoMessageKind};
+use alloy_primitives::bytes::BytesMut;
 use futures::{Stream, StreamExt};
 use reth_eth_wire::multiplex::ProtocolConnection;
-use reth_primitives::BytesMut;
 use std::{
     pin::Pin,
     task::{ready, Context, Poll},

examples/custom-rlpx-subprotocol/src/subprotocol/protocol/proto.rs

@@ -1,8 +1,8 @@
 //! Simple RLPx Ping Pong protocol that also support sending messages,
 //! following [RLPx specs](https://github.com/ethereum/devp2p/blob/master/rlpx.md)
 
+use alloy_primitives::bytes::{Buf, BufMut, BytesMut};
 use reth_eth_wire::{protocol::Protocol, Capability};
-use reth_primitives::{Buf, BufMut, BytesMut};
 
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]

examples/db-access/src/main.rs

@@ -1,9 +1,9 @@
-use alloy_primitives::Address;
+use alloy_primitives::{Address, B256};
 use alloy_rpc_types::{Filter, FilteredParams};
 use reth_chainspec::ChainSpecBuilder;
 use reth_node_ethereum::EthereumNode;
 use reth_node_types::NodeTypesWithDBAdapter;
-use reth_primitives::{alloy_primitives::Sealable, SealedHeader, B256};
+use reth_primitives::{alloy_primitives::Sealable, SealedHeader};
 use reth_provider::{
     providers::StaticFileProvider, AccountReader, BlockReader, BlockSource, HeaderProvider,
     ProviderFactory, ReceiptProvider, StateProvider, TransactionsProvider,

examples/polygon-p2p/Cargo.toml

@@ -8,7 +8,11 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-secp256k1 = { workspace = true, features = ["global-context", "rand-std", "recovery"] }
+secp256k1 = { workspace = true, features = [
+    "global-context",
+    "rand-std",
+    "recovery",
+] }
 tokio.workspace = true
 reth-network.workspace = true
 reth-chainspec.workspace = true
@@ -18,3 +22,4 @@ reth-tracing.workspace = true
 tokio-stream.workspace = true
 reth-provider = { workspace = true, features = ["test-utils"] }
 reth-discv4 = { workspace = true, features = ["test-utils"] }
+alloy-primitives.workspace = true

examples/polygon-p2p/src/chain_cfg.rs

@@ -1,8 +1,9 @@
+use alloy_primitives::{b256, B256};
 use reth_chainspec::{
     once_cell_set, BaseFeeParams, Chain, ChainHardforks, ChainSpec, EthereumHardfork, ForkCondition,
 };
 use reth_discv4::NodeRecord;
-use reth_primitives::{b256, Head, B256};
+use reth_primitives::Head;
 
 use std::sync::Arc;
 

examples/stateful-precompile/src/main.rs

@@ -3,14 +3,14 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 
 use alloy_genesis::Genesis;
-use alloy_primitives::Address;
+use alloy_primitives::{Address, U256};
 use parking_lot::RwLock;
 use reth::{
     api::NextBlockEnvAttributes,
     builder::{components::ExecutorBuilder, BuilderContext, NodeBuilder},
     primitives::{
         revm_primitives::{BlockEnv, CfgEnvWithHandlerCfg, Env, PrecompileResult, TxEnv},
-        Bytes, U256,
+        Bytes,
     },
     revm::{
         handler::register::EvmHandler,

testing/testing-utils/src/genesis_allocator.rs

@@ -18,8 +18,8 @@ use std::{
 ///
 /// # Example
 /// ```
-/// # use alloy_primitives::Address;
-/// # use reth_primitives::{U256, hex, Bytes};
+/// # use alloy_primitives::{Address, U256};
+/// # use reth_primitives::{hex, Bytes};
 /// # use reth_testing_utils::GenesisAllocator;
 /// # use std::str::FromStr;
 /// let mut allocator = GenesisAllocator::default();