chore(sdk): Add NodePrimitives::BlockHeader and NodePrimitives::BlockBody

crates/optimism/node/Cargo.toml

@@ -39,6 +39,7 @@ reth-optimism-rpc.workspace = true
 reth-optimism-chainspec.workspace = true
 reth-optimism-consensus.workspace = true
 reth-optimism-forks.workspace = true
+reth-optimism-primitives.workspace = true
 
 # revm with required optimism features
 revm = { workspace = true, features = ["secp256k1", "blst", "c-kzg"] }
@@ -119,3 +120,7 @@ test-utils = [
     "revm/test-utils",
     "reth-optimism-node/test-utils",
 ]
+reth-codec = [
+    "reth-primitives/reth-codec",
+    "reth-optimism-primitives/reth-codec",
+]

crates/optimism/node/src/node.rs

@@ -9,8 +9,7 @@ use reth_db::transaction::{DbTx, DbTxMut};
 use reth_evm::{execute::BasicBlockExecutorProvider, ConfigureEvm};
 use reth_network::{NetworkConfig, NetworkHandle, NetworkManager, PeersInfo};
 use reth_node_api::{
-    AddOnsContext, EngineValidator, FullNodeComponents, FullNodePrimitives, NodeAddOns,
-    PayloadBuilder,
+    AddOnsContext, EngineValidator, FullNodeComponents, NodeAddOns, PayloadBuilder,
 };
 use reth_node_builder::{
     components::{
@@ -25,12 +24,13 @@ use reth_optimism_chainspec::OpChainSpec;
 use reth_optimism_consensus::OpBeaconConsensus;
 use reth_optimism_evm::{OpEvmConfig, OpExecutionStrategyFactory};
 use reth_optimism_payload_builder::builder::OpPayloadTransactions;
+use reth_optimism_primitives::OpPrimitives;
 use reth_optimism_rpc::{
     witness::{DebugExecutionWitnessApiServer, OpDebugWitnessApi},
     OpEthApi,
 };
 use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
-use reth_primitives::{Block, BlockBody, Receipt, TransactionSigned, TxType};
+use reth_primitives::BlockBody;
 use reth_provider::{
     providers::ChainStorage, BlockBodyWriter, CanonStateSubscriptions, DBProvider, EthStorage,
     ProviderResult,
@@ -49,16 +49,6 @@ use crate::{
     txpool::{OpTransactionPool, OpTransactionValidator},
     OpEngineTypes,
 };
-/// Optimism primitive types.
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub struct OpPrimitives;
-
-impl FullNodePrimitives for OpPrimitives {
-    type Block = Block;
-    type SignedTx = TransactionSigned;
-    type TxType = TxType;
-    type Receipt = Receipt;
-}
 
 /// Storage implementation for Optimism.
 #[derive(Debug, Default, Clone)]

crates/optimism/primitives/Cargo.toml

@@ -39,10 +39,21 @@ reth-codecs = { workspace = true, features = ["test-utils"] }
 rstest.workspace = true
 
 [features]
-default = ["reth-codec"]
+default = ["std", "reth-codec"]
+std = [
+    "reth-primitives-traits/std",
+    "reth-primitives/std",
+    "reth-node-types/std",
+    "reth-codecs/std",
+    "alloy-consensus/std",
+    "alloy-eips/std",
+    "alloy-primitives/std",
+    "serde/std",
+]
 reth-codec = [
     "dep:reth-codecs",
-    "reth-primitives/reth-codec"
+    "reth-primitives/reth-codec",
+    "reth-primitives-traits/reth-codec",
 ]
 serde = [
     "dep:serde",

crates/optimism/primitives/src/lib.rs

@@ -6,21 +6,25 @@
     issue_tracker_base_url = "https://github.com/paradigmxyz/reth/issues/"
 )]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(not(feature = "std"), no_std)]
 
 pub mod bedrock;
 pub mod tx_type;
 
 pub use tx_type::OpTxType;
 
-use reth_node_types::NodePrimitives;
-use reth_primitives::{Block, Receipt, TransactionSigned};
+use alloy_consensus::Header;
+use reth_node_types::FullNodePrimitives;
+use reth_primitives::{Block, BlockBody, Receipt, TransactionSigned};
 
 /// Optimism primitive types.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct OpPrimitives;
 
-impl NodePrimitives for OpPrimitives {
+impl FullNodePrimitives for OpPrimitives {
     type Block = Block;
+    type BlockHeader = Header;
+    type BlockBody = BlockBody;
     type SignedTx = TransactionSigned;
     type TxType = OpTxType;
     type Receipt = Receipt;

crates/primitives-traits/Cargo.toml

@@ -92,4 +92,5 @@ serde = [
     "revm-primitives/serde",
     "roaring/serde",
 	"revm-primitives/serde",
-]
+]
+reth-codec = []

crates/primitives-traits/src/block/body.rs

@@ -28,7 +28,6 @@ pub trait BlockBody:
     + MaybeSerde
 {
     /// Ordered list of signed transactions as committed in block.
-    // todo: requires trait for signed transaction
     type Transaction: Transaction;
 
     /// Returns reference to transactions in block.

crates/primitives-traits/src/block/header.rs

@@ -3,15 +3,14 @@
 use core::fmt;
 
 use alloy_primitives::Sealable;
-use reth_codecs::Compact;
 
-use crate::{InMemorySize, MaybeSerde};
+use crate::{InMemorySize, MaybeCompact, MaybeSerde};
 
 /// Helper trait that unifies all behaviour required by block header to support full node
 /// operations.
-pub trait FullBlockHeader: BlockHeader + Compact {}
+pub trait FullBlockHeader: BlockHeader + MaybeCompact {}
 
-impl<T> FullBlockHeader for T where T: BlockHeader + Compact {}
+impl<T> FullBlockHeader for T where T: BlockHeader + MaybeCompact {}
 
 /// Abstraction of a block header.
 pub trait BlockHeader:

crates/primitives-traits/src/block/mod.rs

@@ -5,18 +5,18 @@ pub mod header;
 
 use alloc::fmt;
 
-use alloy_rlp::{Decodable, Encodable};
-
 use crate::{BlockHeader, FullBlockBody, FullBlockHeader, InMemorySize, MaybeSerde};
 
 /// Helper trait that unifies all behaviour required by block to support full node operations.
 pub trait FullBlock:
-    Block<Header: FullBlockHeader, Body: FullBlockBody> + Encodable + Decodable
+    Block<Header: FullBlockHeader, Body: FullBlockBody> + alloy_rlp::Encodable + alloy_rlp::Decodable
 {
 }
 
 impl<T> FullBlock for T where
-    T: Block<Header: FullBlockHeader, Body: FullBlockBody> + Encodable + Decodable
+    T: Block<Header: FullBlockHeader, Body: FullBlockBody>
+        + alloy_rlp::Encodable
+        + alloy_rlp::Decodable
 {
 }
 

crates/primitives-traits/src/lib.rs

@@ -106,3 +106,17 @@ pub trait MaybeSerde {}
 impl<T> MaybeSerde for T where T: serde::Serialize + for<'de> serde::Deserialize<'de> {}
 #[cfg(not(feature = "serde"))]
 impl<T> MaybeSerde for T {}
+
+/// Helper trait that requires database encoding implementation since `reth-codec` feature is
+/// enabled.
+#[cfg(feature = "reth-codec")]
+pub trait MaybeCompact: reth_codecs::Compact {}
+/// Noop. Helper trait that would require database encoding implementation if `reth-codec` feature
+/// were enabled.
+#[cfg(not(feature = "reth-codec"))]
+pub trait MaybeCompact {}
+
+#[cfg(feature = "reth-codec")]
+impl<T> MaybeCompact for T where T: reth_codecs::Compact {}
+#[cfg(not(feature = "reth-codec"))]
+impl<T> MaybeCompact for T {}

crates/primitives-traits/src/node.rs

@@ -1,6 +1,8 @@
 use core::fmt;
 
-use crate::{BlockBody, FullBlock, FullReceipt, FullSignedTx, FullTxType, MaybeSerde};
+use crate::{
+    FullBlock, FullBlockBody, FullBlockHeader, FullReceipt, FullSignedTx, FullTxType, MaybeSerde,
+};
 
 /// Configures all the primitive types of the node.
 pub trait NodePrimitives:
@@ -17,6 +19,28 @@ pub trait NodePrimitives:
         + Eq
         + MaybeSerde
         + 'static;
+    /// Block header primitive.
+    type BlockHeader: Send
+        + Sync
+        + Unpin
+        + Clone
+        + Default
+        + fmt::Debug
+        + PartialEq
+        + Eq
+        + MaybeSerde
+        + 'static;
+    /// Block body primitive.
+    type BlockBody: Send
+        + Sync
+        + Unpin
+        + Clone
+        + Default
+        + fmt::Debug
+        + PartialEq
+        + Eq
+        + MaybeSerde
+        + 'static;
     /// Signed version of the transaction type.
     type SignedTx: Send
         + Sync
@@ -45,6 +69,8 @@ pub trait NodePrimitives:
 
 impl NodePrimitives for () {
     type Block = ();
+    type BlockHeader = ();
+    type BlockBody = ();
     type SignedTx = ();
     type TxType = ();
     type Receipt = ();
@@ -55,7 +81,11 @@ pub trait FullNodePrimitives:
     Send + Sync + Unpin + Clone + Default + fmt::Debug + PartialEq + Eq + 'static
 {
     /// Block primitive.
-    type Block: FullBlock<Body: BlockBody<Transaction = Self::SignedTx>>;
+    type Block: FullBlock<Header = Self::BlockHeader, Body = Self::BlockBody>;
+    /// Block header primitive.
+    type BlockHeader: FullBlockHeader + 'static;
+    /// Block body primitive.
+    type BlockBody: FullBlockBody<Transaction = Self::SignedTx> + 'static;
     /// Signed version of the transaction type.
     type SignedTx: FullSignedTx;
     /// Transaction envelope type ID.
@@ -66,9 +96,11 @@ pub trait FullNodePrimitives:
 
 impl<T> NodePrimitives for T
 where
-    T: FullNodePrimitives<Block: 'static, SignedTx: 'static, Receipt: 'static, TxType: 'static>,
+    T: FullNodePrimitives,
 {
     type Block = T::Block;
+    type BlockHeader = T::BlockHeader;
+    type BlockBody = T::BlockBody;
     type SignedTx = T::SignedTx;
     type TxType = T::TxType;
     type Receipt = T::Receipt;

crates/primitives-traits/src/receipt.rs

@@ -1,16 +1,17 @@
 //! Receipt abstraction
 
-use crate::{InMemorySize, MaybeSerde};
+use core::fmt;
+
 use alloc::vec::Vec;
 use alloy_consensus::TxReceipt;
 use alloy_primitives::B256;
-use core::fmt;
-use reth_codecs::Compact;
+
+use crate::{InMemorySize, MaybeCompact, MaybeSerde};
 
 /// Helper trait that unifies all behaviour required by receipt to support full node operations.
-pub trait FullReceipt: Receipt + Compact {}
+pub trait FullReceipt: Receipt + MaybeCompact {}
 
-impl<T> FullReceipt for T where T: ReceiptExt + Compact {}
+impl<T> FullReceipt for T where T: ReceiptExt + MaybeCompact {}
 
 /// Abstraction of a receipt.
 #[auto_impl::auto_impl(&, Arc)]

crates/primitives-traits/src/transaction/mod.rs

@@ -6,14 +6,13 @@ pub mod signed;
 use core::{fmt, hash::Hash};
 
 use alloy_primitives::B256;
-use reth_codecs::Compact;
 
-use crate::{FullTxType, InMemorySize, MaybeArbitrary, MaybeSerde, TxType};
+use crate::{FullTxType, InMemorySize, MaybeArbitrary, MaybeCompact, MaybeSerde, TxType};
 
 /// Helper trait that unifies all behaviour required by transaction to support full node operations.
-pub trait FullTransaction: Transaction<Type: FullTxType> + Compact {}
+pub trait FullTransaction: Transaction<Type: FullTxType> + MaybeCompact {}
 
-impl<T> FullTransaction for T where T: Transaction<Type: FullTxType> + Compact {}
+impl<T> FullTransaction for T where T: Transaction<Type: FullTxType> + MaybeCompact {}
 
 /// Abstraction of a transaction.
 pub trait Transaction:

crates/primitives-traits/src/transaction/signed.rs

@@ -5,20 +5,13 @@ use core::hash::Hash;
 
 use alloy_eips::eip2718::{Decodable2718, Encodable2718};
 use alloy_primitives::{keccak256, Address, PrimitiveSignature, TxHash, B256};
-use reth_codecs::Compact;
 
 use crate::{FillTxEnv, FullTransaction, InMemorySize, MaybeArbitrary, MaybeSerde, Transaction};
 
 /// Helper trait that unifies all behaviour required by block to support full node operations.
-pub trait FullSignedTx:
-    SignedTransaction<Transaction: FullTransaction> + FillTxEnv + Compact
-{
-}
+pub trait FullSignedTx: SignedTransaction<Transaction: FullTransaction> + FillTxEnv {}
 
-impl<T> FullSignedTx for T where
-    T: SignedTransaction<Transaction: FullTransaction> + FillTxEnv + Compact
-{
-}
+impl<T> FullSignedTx for T where T: SignedTransaction<Transaction: FullTransaction> + FillTxEnv {}
 
 /// A signed transaction.
 #[auto_impl::auto_impl(&, Arc)]

crates/primitives-traits/src/tx_type.rs

@@ -1,15 +1,14 @@
 use core::fmt;
 
 use alloy_primitives::{U64, U8};
-use reth_codecs::Compact;
 
-use crate::InMemorySize;
+use crate::{InMemorySize, MaybeCompact};
 
 /// Helper trait that unifies all behaviour required by transaction type ID to support full node
 /// operations.
-pub trait FullTxType: TxType + Compact {}
+pub trait FullTxType: TxType + MaybeCompact {}
 
-impl<T> FullTxType for T where T: TxType + Compact {}
+impl<T> FullTxType for T where T: TxType + MaybeCompact {}
 
 /// Trait representing the behavior of a transaction type.
 pub trait TxType:

crates/primitives/Cargo.toml

@@ -105,7 +105,12 @@ std = [
 	"serde/std",
 	"alloy-trie/std"
 ]
-reth-codec = ["dep:reth-codecs", "dep:zstd", "dep:modular-bitfield", "std"]
+reth-codec = [
+	"dep:reth-codecs",
+	"dep:zstd",
+	"dep:modular-bitfield", "std",
+	"reth-primitives-traits/reth-codec",
+]
 asm-keccak = ["alloy-primitives/asm-keccak", "revm-primitives/asm-keccak"]
 arbitrary = [
 	"dep:arbitrary",

crates/primitives/src/lib.rs

@@ -79,17 +79,10 @@ pub mod serde_bincode_compat {
 #[derive(Debug, Clone, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct EthPrimitives;
 
-#[cfg(feature = "reth-codec")]
 impl reth_primitives_traits::FullNodePrimitives for EthPrimitives {
     type Block = crate::Block;
-    type SignedTx = crate::TransactionSigned;
-    type TxType = crate::TxType;
-    type Receipt = crate::Receipt;
-}
-
-#[cfg(not(feature = "reth-codec"))]
-impl NodePrimitives for EthPrimitives {
-    type Block = crate::Block;
+    type BlockHeader = alloy_consensus::Header;
+    type BlockBody = crate::BlockBody;
     type SignedTx = crate::TransactionSigned;
     type TxType = crate::TxType;
     type Receipt = crate::Receipt;