refactor: move ExtendedTxEnvelope to reth-primitives-traits

examples/custom-node/src/primitives/extended_op_tx_envelope.rs → crates/primitives-traits/src/extended.rs

@@ -1,21 +1,27 @@
-use alloy_consensus::{error::ValueError, Transaction};
+use crate::{
+    size::InMemorySize,
+    transaction::signed::{RecoveryError, SignedTransaction},
+};
+use alloc::vec::Vec;
+use alloy_consensus::Transaction;
 use alloy_eips::{
     eip2718::{Eip2718Error, Eip2718Result, IsTyped2718},
     eip2930::AccessList,
     eip7702::SignedAuthorization,
     Decodable2718, Encodable2718, Typed2718,
 };
-use alloy_primitives::{bytes::Buf, ChainId, Signature, TxHash};
+use alloy_primitives::{ChainId, TxHash};
 use alloy_rlp::{BufMut, Decodable, Encodable, Result as RlpResult};
-use op_alloy_consensus::{OpPooledTransaction, OpTxEnvelope};
-use reth_codecs::Compact;
-use reth_ethereum::primitives::{
-    serde_bincode_compat::SerdeBincodeCompat, transaction::signed::RecoveryError, InMemorySize,
-    SignedTransaction,
-};
 use revm_primitives::{Address, Bytes, TxKind, B256, U256};
 
-use super::CustomTransactionEnvelope;
+#[cfg(feature = "op")]
+use op_alloy_consensus::{OpPooledTransaction, OpTxEnvelope};
+
+#[cfg(feature = "op")]
+use alloy_primitives::Signature;
+
+#[cfg(feature = "op")]
+use alloy_consensus::error::ValueError;
 
 macro_rules! delegate {
     ($self:expr => $tx:ident.$method:ident($($arg:expr),*)) => {
@@ -33,44 +39,44 @@ macro_rules! delegate {
 ///
 /// Note: The other transaction type variants must not overlap with the builtin one, transaction
 /// types must be unique.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Hash, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Debug, Clone, Hash, Eq, PartialEq)]
 pub enum ExtendedTxEnvelope<BuiltIn, Other> {
+    /// The builtin transaction type.
     BuiltIn(BuiltIn),
+    /// The other transaction type.
     Other(Other),
 }
 
-pub type ExtendedOpTxEnvelope<T> = ExtendedTxEnvelope<OpTxEnvelope, T>;
-
-impl TryFrom<ExtendedTxEnvelope<OpTxEnvelope, CustomTransactionEnvelope>>
-    for ExtendedTxEnvelope<OpPooledTransaction, CustomTransactionEnvelope>
+#[cfg(feature = "op")]
+impl<Tx> TryFrom<ExtendedTxEnvelope<OpTxEnvelope, Tx>>
+    for ExtendedTxEnvelope<OpPooledTransaction, Tx>
 {
     type Error = OpTxEnvelope;
 
-    fn try_from(
-        value: ExtendedTxEnvelope<OpTxEnvelope, CustomTransactionEnvelope>,
-    ) -> Result<Self, Self::Error> {
+    fn try_from(value: ExtendedTxEnvelope<OpTxEnvelope, Tx>) -> Result<Self, Self::Error> {
         match value {
             ExtendedTxEnvelope::BuiltIn(tx) => {
                 let converted_tx: OpPooledTransaction = tx.clone().try_into().map_err(|_| tx)?;
-                Ok(ExtendedTxEnvelope::BuiltIn(converted_tx))
+                Ok(Self::BuiltIn(converted_tx))
             }
-            ExtendedTxEnvelope::Other(tx) => Ok(ExtendedTxEnvelope::Other(tx)),
+            ExtendedTxEnvelope::Other(tx) => Ok(Self::Other(tx)),
         }
     }
 }
 
-impl From<OpPooledTransaction> for ExtendedTxEnvelope<OpTxEnvelope, CustomTransactionEnvelope> {
+#[cfg(feature = "op")]
+impl<Tx> From<OpPooledTransaction> for ExtendedTxEnvelope<OpTxEnvelope, Tx> {
     fn from(tx: OpPooledTransaction) -> Self {
-        ExtendedTxEnvelope::BuiltIn(tx.into())
+        Self::BuiltIn(tx.into())
     }
 }
 
-impl TryFrom<ExtendedTxEnvelope<OpTxEnvelope, CustomTransactionEnvelope>> for OpPooledTransaction {
+#[cfg(feature = "op")]
+impl<Tx> TryFrom<ExtendedTxEnvelope<OpTxEnvelope, Tx>> for OpPooledTransaction {
     type Error = ValueError<OpTxEnvelope>;
 
-    fn try_from(
-        _tx: ExtendedTxEnvelope<OpTxEnvelope, CustomTransactionEnvelope>,
-    ) -> Result<Self, Self::Error> {
+    fn try_from(_tx: ExtendedTxEnvelope<OpTxEnvelope, Tx>) -> Result<Self, Self::Error> {
         match _tx {
             ExtendedTxEnvelope::BuiltIn(inner) => inner.try_into(),
             ExtendedTxEnvelope::Other(_tx) => Err(ValueError::new(
@@ -303,38 +309,49 @@ where
     }
 }
 
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub enum ExtendedTxEnvelopeRepr<'a, B: SerdeBincodeCompat, T: SerdeBincodeCompat> {
-    BuiltIn(B::BincodeRepr<'a>),
-    Other(T::BincodeRepr<'a>),
-}
+#[cfg(feature = "serde-bincode-compat")]
+mod serde_bincode_compat {
+    use super::*;
+    use crate::serde_bincode_compat::SerdeBincodeCompat;
 
-impl<B, T> SerdeBincodeCompat for ExtendedTxEnvelope<B, T>
-where
-    B: SerdeBincodeCompat + std::fmt::Debug,
-    T: SerdeBincodeCompat + std::fmt::Debug,
-{
-    type BincodeRepr<'a> = ExtendedTxEnvelopeRepr<'a, B, T>;
+    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+    #[derive(Debug)]
+    pub enum ExtendedTxEnvelopeRepr<'a, B: SerdeBincodeCompat, T: SerdeBincodeCompat> {
+        BuiltIn(B::BincodeRepr<'a>),
+        Other(T::BincodeRepr<'a>),
+    }
 
-    fn as_repr(&self) -> Self::BincodeRepr<'_> {
-        match self {
-            Self::BuiltIn(tx) => ExtendedTxEnvelopeRepr::BuiltIn(tx.as_repr()),
-            Self::Other(tx) => ExtendedTxEnvelopeRepr::Other(tx.as_repr()),
+    impl<B, T> SerdeBincodeCompat for ExtendedTxEnvelope<B, T>
+    where
+        B: SerdeBincodeCompat + core::fmt::Debug,
+        T: SerdeBincodeCompat + core::fmt::Debug,
+    {
+        type BincodeRepr<'a> = ExtendedTxEnvelopeRepr<'a, B, T>;
+
+        fn as_repr(&self) -> Self::BincodeRepr<'_> {
+            match self {
+                Self::BuiltIn(tx) => ExtendedTxEnvelopeRepr::BuiltIn(tx.as_repr()),
+                Self::Other(tx) => ExtendedTxEnvelopeRepr::Other(tx.as_repr()),
+            }
         }
-    }
 
-    fn from_repr(repr: Self::BincodeRepr<'_>) -> Self {
-        match repr {
-            ExtendedTxEnvelopeRepr::BuiltIn(tx_repr) => Self::BuiltIn(B::from_repr(tx_repr)),
-            ExtendedTxEnvelopeRepr::Other(tx_repr) => Self::Other(T::from_repr(tx_repr)),
+        fn from_repr(repr: Self::BincodeRepr<'_>) -> Self {
+            match repr {
+                ExtendedTxEnvelopeRepr::BuiltIn(tx_repr) => Self::BuiltIn(B::from_repr(tx_repr)),
+                ExtendedTxEnvelopeRepr::Other(tx_repr) => Self::Other(T::from_repr(tx_repr)),
+            }
         }
     }
 }
 
-impl<B, T> Compact for ExtendedTxEnvelope<B, T>
+#[cfg(feature = "reth-codec")]
+use alloy_primitives::bytes::Buf;
+
+#[cfg(feature = "reth-codec")]
+impl<B, T> reth_codecs::Compact for ExtendedTxEnvelope<B, T>
 where
-    B: Transaction + IsTyped2718 + Compact,
-    T: Transaction + Compact,
+    B: Transaction + IsTyped2718 + reth_codecs::Compact,
+    T: Transaction + reth_codecs::Compact,
 {
     fn to_compact<Buf>(&self, buf: &mut Buf) -> usize
     where

crates/primitives-traits/src/lib.rs

@@ -122,6 +122,8 @@ pub use storage::StorageEntry;
 
 pub mod sync;
 
+mod extended;
+pub use extended::ExtendedTxEnvelope;
 /// Common header types
 pub mod header;
 pub use header::{Header, HeaderError, SealedHeader, SealedHeaderFor};

examples/custom-node/src/network.rs

@@ -2,7 +2,6 @@ use crate::{
     chainspec::CustomChainSpec,
     primitives::{
         CustomHeader, CustomNodePrimitives, CustomTransactionEnvelope, ExtendedOpTxEnvelope,
-        ExtendedTxEnvelope,
     },
 };
 use alloy_consensus::{Block, BlockBody};
@@ -15,7 +14,7 @@ use reth_ethereum::{
     pool::{PoolTransaction, TransactionPool},
 };
 use reth_node_builder::{components::NetworkBuilder, BuilderContext};
-use reth_op::OpReceipt;
+use reth_op::{primitives::ExtendedTxEnvelope, OpReceipt};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
 #[non_exhaustive]

examples/custom-node/src/pool.rs

@@ -1,4 +1,5 @@
 // use jsonrpsee::tracing::{debug, info};
+use crate::primitives::CustomTransactionEnvelope;
 use op_alloy_consensus::{interop::SafetyLevel, OpTxEnvelope};
 use reth_chain_state::CanonStateSubscriptions;
 use reth_node_builder::{
@@ -17,11 +18,10 @@ use reth_op::{
         blobstore::DiskFileBlobStore, CoinbaseTipOrdering, EthPoolTransaction,
         TransactionValidationTaskExecutor,
     },
+    primitives::ExtendedTxEnvelope,
 };
 use reth_optimism_forks::OpHardforks;
 
-use crate::primitives::{CustomTransactionEnvelope, ExtendedTxEnvelope};
-
 #[derive(Debug, Clone)]
 pub struct CustomPoolBuilder<
     T = OpPooledTransaction<ExtendedTxEnvelope<OpTxEnvelope, CustomTransactionEnvelope>>,

examples/custom-node/src/primitives/block.rs

@@ -1,6 +1,4 @@
-use crate::primitives::CustomHeader;
-
-use super::{CustomTransactionEnvelope, ExtendedOpTxEnvelope};
+use crate::primitives::{CustomHeader, CustomTransactionEnvelope, ExtendedOpTxEnvelope};
 
 /// The Block type of this node
 pub type Block =

examples/custom-node/src/primitives/mod.rs

@@ -9,8 +9,6 @@ pub use tx::*;
 
 pub mod tx_type;
 pub use tx_type::*;
-pub mod extended_op_tx_envelope;
-pub use extended_op_tx_envelope::*;
 pub mod tx_custom;
 pub use tx_custom::*;
 

examples/custom-node/src/primitives/tx.rs

@@ -9,15 +9,20 @@ use alloy_consensus::{
 use alloy_eips::{eip2718::Eip2718Result, Decodable2718, Encodable2718, Typed2718};
 use alloy_primitives::{keccak256, Signature, TxHash};
 use alloy_rlp::{BufMut, Decodable, Encodable, Result as RlpResult};
+use op_alloy_consensus::OpTxEnvelope;
 use reth_codecs::{
     alloy::transaction::{FromTxCompact, ToTxCompact},
     Compact,
 };
 use reth_ethereum::primitives::{serde_bincode_compat::SerdeBincodeCompat, InMemorySize};
-use reth_op::primitives::SignedTransaction;
+use reth_op::primitives::{ExtendedTxEnvelope, SignedTransaction};
 use revm_primitives::{Address, Bytes};
 use serde::{Deserialize, Serialize};
 
+/// A [`SignedTransaction`] implementation that combines the [`OpTxEnvelope`] and another
+/// transaction type.
+pub type ExtendedOpTxEnvelope<T> = ExtendedTxEnvelope<OpTxEnvelope, T>;
+
 #[derive(Debug, Clone, Serialize, Deserialize, Hash, Eq, PartialEq)]
 pub struct CustomTransactionEnvelope {
     pub inner: Signed<TxCustom>,