feat: add custom transaction type to custom-node example (#15296)

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

@@ -4,6 +4,8 @@ pub mod header;
 pub use header::*;
 pub mod block;
 pub use block::*;
+pub mod tx;
+pub use tx::*;
 
 use reth_optimism_primitives::{OpReceipt, OpTransactionSigned};
 use reth_primitives_traits::NodePrimitives;

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

@@ -0,0 +1,189 @@
+use alloy_consensus::Transaction;
+use alloy_eips::{eip2718::Eip2718Result, Decodable2718, Encodable2718, Typed2718};
+use alloy_primitives::{PrimitiveSignature, TxHash};
+use alloy_rlp::{BufMut, Decodable, Encodable, Result as RlpResult};
+use reth_codecs::Compact;
+use reth_optimism_primitives::{
+    serde_bincode_compat::OpTransactionSigned as BincodeCompatOpTransactionSigned,
+    OpTransactionSigned,
+};
+use reth_primitives_traits::{
+    serde_bincode_compat::SerdeBincodeCompat, transaction::signed::RecoveryError, InMemorySize,
+    SignedTransaction,
+};
+use revm_primitives::{Address, Bytes};
+
+pub const TRANSFER_TX_TYPE_ID: u8 = 127;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Hash, Eq, PartialEq)]
+pub struct CustomTransaction {
+    inner: OpTransactionSigned,
+}
+
+impl Transaction for CustomTransaction {
+    fn chain_id(&self) -> Option<alloy_primitives::ChainId> {
+        self.inner.chain_id()
+    }
+
+    fn nonce(&self) -> u64 {
+        self.inner.nonce()
+    }
+
+    fn gas_limit(&self) -> u64 {
+        self.inner.gas_limit()
+    }
+
+    fn gas_price(&self) -> Option<u128> {
+        self.inner.gas_price()
+    }
+
+    fn max_fee_per_gas(&self) -> u128 {
+        self.inner.max_fee_per_gas()
+    }
+
+    fn max_priority_fee_per_gas(&self) -> Option<u128> {
+        self.inner.max_priority_fee_per_gas()
+    }
+
+    fn max_fee_per_blob_gas(&self) -> Option<u128> {
+        self.inner.max_fee_per_blob_gas()
+    }
+
+    fn priority_fee_or_price(&self) -> u128 {
+        self.inner.priority_fee_or_price()
+    }
+
+    fn effective_gas_price(&self, base_fee: Option<u64>) -> u128 {
+        self.inner.effective_gas_price(base_fee)
+    }
+
+    fn is_dynamic_fee(&self) -> bool {
+        self.inner.is_dynamic_fee()
+    }
+
+    fn kind(&self) -> revm_primitives::TxKind {
+        self.inner.kind()
+    }
+
+    fn is_create(&self) -> bool {
+        false
+    }
+
+    fn value(&self) -> revm_primitives::U256 {
+        self.inner.value()
+    }
+
+    fn input(&self) -> &revm_primitives::Bytes {
+        // CustomTransactions have no input data
+        static EMPTY_BYTES: Bytes = Bytes::new();
+        &EMPTY_BYTES
+    }
+
+    fn access_list(&self) -> Option<&alloy_eips::eip2930::AccessList> {
+        self.inner.access_list()
+    }
+
+    fn blob_versioned_hashes(&self) -> Option<&[revm_primitives::B256]> {
+        self.inner.blob_versioned_hashes()
+    }
+
+    fn authorization_list(&self) -> Option<&[alloy_eips::eip7702::SignedAuthorization]> {
+        self.inner.authorization_list()
+    }
+}
+
+impl SignedTransaction for CustomTransaction {
+    fn recover_signer(&self) -> Result<Address, RecoveryError> {
+        self.inner.recover_signer()
+    }
+
+    fn recover_signer_unchecked(&self) -> Result<Address, RecoveryError> {
+        self.inner.recover_signer_unchecked()
+    }
+
+    fn recover_signer_unchecked_with_buf(
+        &self,
+        buf: &mut Vec<u8>,
+    ) -> Result<Address, RecoveryError> {
+        self.inner.recover_signer_unchecked_with_buf(buf)
+    }
+
+    fn tx_hash(&self) -> &TxHash {
+        self.inner.tx_hash()
+    }
+
+    fn signature(&self) -> &PrimitiveSignature {
+        self.inner.signature()
+    }
+}
+
+impl Typed2718 for CustomTransaction {
+    fn ty(&self) -> u8 {
+        TRANSFER_TX_TYPE_ID
+    }
+}
+
+impl Decodable2718 for CustomTransaction {
+    fn typed_decode(ty: u8, buf: &mut &[u8]) -> Eip2718Result<Self> {
+        Ok(Self { inner: OpTransactionSigned::typed_decode(ty, buf)? })
+    }
+
+    fn fallback_decode(buf: &mut &[u8]) -> Eip2718Result<Self> {
+        Ok(Self { inner: OpTransactionSigned::fallback_decode(buf)? })
+    }
+}
+
+impl Encodable2718 for CustomTransaction {
+    fn encode_2718(&self, out: &mut dyn BufMut) {
+        self.inner.encode_2718(out)
+    }
+
+    fn encode_2718_len(&self) -> usize {
+        self.inner.encode_2718_len()
+    }
+}
+
+impl Decodable for CustomTransaction {
+    fn decode(buf: &mut &[u8]) -> RlpResult<Self> {
+        Ok(Self { inner: OpTransactionSigned::decode(buf)? })
+    }
+}
+
+impl Encodable for CustomTransaction {
+    fn encode(&self, out: &mut dyn BufMut) {
+        self.inner.encode(out)
+    }
+}
+
+impl InMemorySize for CustomTransaction {
+    fn size(&self) -> usize {
+        self.inner.size()
+    }
+}
+
+impl SerdeBincodeCompat for CustomTransaction {
+    type BincodeRepr<'a> = BincodeCompatOpTransactionSigned<'a>;
+
+    fn as_repr(&self) -> Self::BincodeRepr<'_> {
+        self.inner.as_repr()
+    }
+
+    fn from_repr(repr: Self::BincodeRepr<'_>) -> Self {
+        Self { inner: repr.into() }
+    }
+}
+
+impl Compact for CustomTransaction {
+    fn to_compact<B>(&self, buf: &mut B) -> usize
+    where
+        B: alloy_rlp::bytes::BufMut + AsMut<[u8]>,
+    {
+        self.inner.to_compact(buf)
+    }
+
+    fn from_compact(buf: &[u8], len: usize) -> (Self, &[u8]) {
+        let (inner, buf) = OpTransactionSigned::from_compact(buf, len);
+
+        (Self { inner }, buf)
+    }
+}