feat(rpc): Implement TransactionCompat for generic RPC response builder (paradigmxyz#16694)

Author: RomanHodulak

Cargo.lock

@@ -70,6 +70,7 @@ serde = [
     "reth-trie/serde",
     "revm-database/serde",
     "revm-state?/serde",
+    "reth-storage-api/serde",
 ]
 test-utils = [
     "alloy-primitives/getrandom",

crates/chain-state/Cargo.toml

@@ -124,6 +124,7 @@ serde = [
     "reth-ethereum-primitives/serde",
     "reth-network-api/serde",
     "rand_08/serde",
+    "reth-storage-api/serde",
 ]
 test-utils = [
     "reth-transaction-pool/test-utils",

crates/net/network/Cargo.toml

@@ -5,8 +5,9 @@ use alloy_rpc_types_eth::{error::EthRpcErrorCode, BlockError};
 use alloy_transport::{RpcError, TransportErrorKind};
 use jsonrpsee_types::error::{INTERNAL_ERROR_CODE, INVALID_PARAMS_CODE};
 use op_revm::{OpHaltReason, OpTransactionError};
+use reth_evm::execute::ProviderError;
 use reth_optimism_evm::OpBlockExecutionError;
-use reth_rpc_eth_api::AsEthApiError;
+use reth_rpc_eth_api::{AsEthApiError, TransactionConversionError};
 use reth_rpc_eth_types::{error::api::FromEvmHalt, EthApiError};
 use reth_rpc_server_types::result::{internal_rpc_err, rpc_err};
 use revm::context_interface::result::{EVMError, InvalidTransaction};
@@ -160,12 +161,6 @@ impl From<SequencerClientError> for jsonrpsee_types::error::ErrorObject<'static>
     }
 }
 
-impl From<BlockError> for OpEthApiError {
-    fn from(error: BlockError) -> Self {
-        Self::Eth(error.into())
-    }
-}
-
 impl<T> From<EVMError<T, OpTransactionError>> for OpEthApiError
 where
     T: Into<EthApiError>,
@@ -193,3 +188,21 @@ impl FromEvmHalt<OpHaltReason> for OpEthApiError {
         }
     }
 }
+
+impl From<TransactionConversionError> for OpEthApiError {
+    fn from(value: TransactionConversionError) -> Self {
+        Self::Eth(EthApiError::from(value))
+    }
+}
+
+impl From<ProviderError> for OpEthApiError {
+    fn from(value: ProviderError) -> Self {
+        Self::Eth(EthApiError::from(value))
+    }
+}
+
+impl From<BlockError> for OpEthApiError {
+    fn from(value: BlockError) -> Self {
+        Self::Eth(EthApiError::from(value))
+    }
+}

crates/optimism/rpc/src/error.rs

@@ -8,6 +8,7 @@ mod block;
 mod call;
 mod pending_block;
 
+use crate::{eth::transaction::OpTxInfoMapper, OpEthApiError, SequencerClient};
 use alloy_primitives::U256;
 use eyre::WrapErr;
 use op_alloy_network::Optimism;
@@ -24,7 +25,7 @@ use reth_rpc_eth_api::{
         AddDevSigners, EthApiSpec, EthFees, EthSigner, EthState, LoadBlock, LoadFee, LoadState,
         SpawnBlocking, Trace,
     },
-    EthApiTypes, FromEvmError, FullEthApiServer, RpcNodeCore, RpcNodeCoreExt,
+    EthApiTypes, FromEvmError, FullEthApiServer, RpcConverter, RpcNodeCore, RpcNodeCoreExt,
 };
 use reth_rpc_eth_types::{EthStateCache, FeeHistoryCache, GasPriceOracle};
 use reth_storage_api::{
@@ -36,9 +37,7 @@ use reth_tasks::{
     TaskSpawner,
 };
 use reth_transaction_pool::TransactionPool;
-use std::{fmt, marker::PhantomData, sync::Arc};
-
-use crate::{OpEthApiError, SequencerClient};
+use std::{fmt, fmt::Formatter, marker::PhantomData, sync::Arc};
 
 /// Adapter for [`EthApiInner`], which holds all the data required to serve core `eth_` API.
 pub type EthApiNodeBackend<N> = EthApiInner<
@@ -68,6 +67,7 @@ pub struct OpEthApi<N: OpNodeCore, NetworkT = Optimism> {
     inner: Arc<OpEthApiInner<N>>,
     /// Marker for the network types.
     _nt: PhantomData<NetworkT>,
+    tx_resp_builder: RpcConverter<N::Primitives, NetworkT, OpEthApiError, OpTxInfoMapper<N>>,
 }
 
 impl<N: OpNodeCore, NetworkT> OpEthApi<N, NetworkT> {
@@ -77,13 +77,12 @@ impl<N: OpNodeCore, NetworkT> OpEthApi<N, NetworkT> {
         sequencer_client: Option<SequencerClient>,
         min_suggested_priority_fee: U256,
     ) -> Self {
+        let inner =
+            Arc::new(OpEthApiInner { eth_api, sequencer_client, min_suggested_priority_fee });
         Self {
-            inner: Arc::new(OpEthApiInner {
-                eth_api,
-                sequencer_client,
-                min_suggested_priority_fee,
-            }),
+            inner: inner.clone(),
             _nt: PhantomData,
+            tx_resp_builder: RpcConverter::with_mapper(OpTxInfoMapper::new(inner)),
         }
     }
 }
@@ -112,16 +111,18 @@ where
 
 impl<N, NetworkT> EthApiTypes for OpEthApi<N, NetworkT>
 where
-    Self: Send + Sync + std::fmt::Debug,
+    Self: Send + Sync + fmt::Debug,
     N: OpNodeCore,
-    NetworkT: op_alloy_network::Network + Clone + std::fmt::Debug,
+    NetworkT: op_alloy_network::Network + Clone + fmt::Debug,
+    <N as RpcNodeCore>::Primitives: fmt::Debug,
 {
     type Error = OpEthApiError;
     type NetworkTypes = NetworkT;
-    type TransactionCompat = Self;
+    type TransactionCompat =
+        RpcConverter<N::Primitives, NetworkT, OpEthApiError, OpTxInfoMapper<N>>;
 
     fn tx_resp_builder(&self) -> &Self::TransactionCompat {
-        self
+        &self.tx_resp_builder
     }
 }
 
@@ -202,6 +203,7 @@ where
     Self: Send + Sync + Clone + 'static,
     N: OpNodeCore,
     NetworkT: op_alloy_network::Network,
+    <N as RpcNodeCore>::Primitives: fmt::Debug,
 {
     #[inline]
     fn io_task_spawner(&self) -> impl TaskSpawner {
@@ -252,6 +254,7 @@ where
         Pool: TransactionPool,
     >,
     NetworkT: op_alloy_network::Network,
+    <N as RpcNodeCore>::Primitives: fmt::Debug,
 {
 }
 
@@ -305,7 +308,7 @@ impl<N: OpNodeCore, NetworkT> fmt::Debug for OpEthApi<N, NetworkT> {
 }
 
 /// Container type `OpEthApi`
-struct OpEthApiInner<N: OpNodeCore> {
+pub struct OpEthApiInner<N: OpNodeCore> {
     /// Gateway to node's core components.
     eth_api: EthApiNodeBackend<N>,
     /// Sequencer client, configured to forward submitted transactions to sequencer of given OP
@@ -317,6 +320,12 @@ struct OpEthApiInner<N: OpNodeCore> {
     min_suggested_priority_fee: U256,
 }
 
+impl<N: OpNodeCore> fmt::Debug for OpEthApiInner<N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct("OpEthApiInner").finish()
+    }
+}
+
 impl<N: OpNodeCore> OpEthApiInner<N> {
     /// Returns a reference to the [`EthApiNodeBackend`].
     const fn eth_api(&self) -> &EthApiNodeBackend<N> {

crates/optimism/rpc/src/eth/mod.rs

@@ -1,27 +1,29 @@
 //! Loads and formats OP transaction RPC response.
 
-use alloy_consensus::{transaction::Recovered, SignableTransaction};
-use alloy_primitives::{Bytes, Signature, B256};
-use alloy_rpc_types_eth::TransactionInfo;
-use op_alloy_consensus::{
-    transaction::{OpDepositInfo, OpTransactionInfo},
-    OpTxEnvelope,
+use crate::{
+    eth::{OpEthApiInner, OpNodeCore},
+    OpEthApi, OpEthApiError, SequencerClient,
 };
-use op_alloy_rpc_types::{OpTransactionRequest, Transaction};
-use reth_node_api::{FullNodeComponents, FullNodeTypes, NodeTypes};
+use alloy_primitives::{Bytes, B256};
+use alloy_rpc_types_eth::TransactionInfo;
+use op_alloy_consensus::{transaction::OpTransactionInfo, OpTxEnvelope};
+use reth_node_api::FullNodeComponents;
 use reth_optimism_primitives::DepositReceipt;
-use reth_primitives_traits::{NodePrimitives, TxTy};
 use reth_rpc_eth_api::{
     helpers::{EthSigner, EthTransactions, LoadTransaction, SpawnBlocking},
-    EthApiTypes, FromEthApiError, FullEthApiTypes, RpcNodeCore, RpcNodeCoreExt, TransactionCompat,
+    try_into_op_tx_info, EthApiTypes, FromEthApiError, FullEthApiTypes, RpcNodeCore,
+    RpcNodeCoreExt, TxInfoMapper,
 };
-use reth_rpc_eth_types::{utils::recover_raw_transaction, EthApiError};
+use reth_rpc_eth_types::utils::recover_raw_transaction;
 use reth_storage_api::{
-    BlockReader, BlockReaderIdExt, ProviderTx, ReceiptProvider, TransactionsProvider,
+    errors::ProviderError, BlockReader, BlockReaderIdExt, ProviderTx, ReceiptProvider,
+    TransactionsProvider,
 };
 use reth_transaction_pool::{PoolTransaction, TransactionOrigin, TransactionPool};
-
-use crate::{eth::OpNodeCore, OpEthApi, OpEthApiError, SequencerClient};
+use std::{
+    fmt::{Debug, Formatter},
+    sync::Arc,
+};
 
 impl<N> EthTransactions for OpEthApi<N>
 where
@@ -87,59 +89,39 @@ where
     }
 }
 
-impl<N> TransactionCompat for OpEthApi<N>
+/// Optimism implementation of [`TxInfoMapper`].
+///
+/// For deposits, receipt is fetched to extract `deposit_nonce` and `deposit_receipt_version`.
+/// Otherwise, it works like regular Ethereum implementation, i.e. uses [`TransactionInfo`].
+#[derive(Clone)]
+pub struct OpTxInfoMapper<N: OpNodeCore>(Arc<OpEthApiInner<N>>);
+
+impl<N: OpNodeCore> Debug for OpTxInfoMapper<N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("OpTxInfoMapper").finish()
+    }
+}
+
+impl<N: OpNodeCore> OpTxInfoMapper<N> {
+    /// Creates [`OpTxInfoMapper`] that uses [`ReceiptProvider`] borrowed from given `eth_api`.
+    pub const fn new(eth_api: Arc<OpEthApiInner<N>>) -> Self {
+        Self(eth_api)
+    }
+}
+
+impl<N> TxInfoMapper<&OpTxEnvelope> for OpTxInfoMapper<N>
 where
     N: FullNodeComponents,
     N::Provider: ReceiptProvider<Receipt: DepositReceipt>,
-    <<N as FullNodeTypes>::Types as NodeTypes>::Primitives: NodePrimitives<SignedTx = OpTxEnvelope>,
 {
-    type Primitives = <<N as FullNodeTypes>::Types as NodeTypes>::Primitives;
-    type Transaction = Transaction;
-    type Error = OpEthApiError;
+    type Out = OpTransactionInfo;
+    type Err = ProviderError;
 
-    fn fill(
+    fn try_map(
         &self,
-        tx: Recovered<TxTy<Self::Primitives>>,
+        tx: &OpTxEnvelope,
         tx_info: TransactionInfo,
-    ) -> Result<Self::Transaction, Self::Error> {
-        let tx = tx.convert::<TxTy<Self::Primitives>>();
-        let mut deposit_receipt_version = None;
-        let mut deposit_nonce = None;
-
-        if tx.is_deposit() {
-            // for depost tx we need to fetch the receipt
-            self.inner
-                .eth_api
-                .provider()
-                .receipt_by_hash(tx.tx_hash())
-                .map_err(Self::Error::from_eth_err)?
-                .inspect(|receipt| {
-                    if let Some(receipt) = receipt.as_deposit_receipt() {
-                        deposit_receipt_version = receipt.deposit_receipt_version;
-                        deposit_nonce = receipt.deposit_nonce;
-                    }
-                });
-        }
-
-        let tx_info = OpTransactionInfo::new(
-            tx_info,
-            OpDepositInfo { deposit_nonce, deposit_receipt_version },
-        );
-
-        Ok(Transaction::from_transaction(tx, tx_info))
-    }
-
-    fn build_simulate_v1_transaction(
-        &self,
-        request: alloy_rpc_types_eth::TransactionRequest,
-    ) -> Result<TxTy<Self::Primitives>, Self::Error> {
-        let request: OpTransactionRequest = request.into();
-        let Ok(tx) = request.build_typed_tx() else {
-            return Err(OpEthApiError::Eth(EthApiError::TransactionConversionError))
-        };
-
-        // Create an empty signature for the transaction.
-        let signature = Signature::new(Default::default(), Default::default(), false);
-        Ok(tx.into_signed(signature).into())
+    ) -> Result<Self::Out, ProviderError> {
+        try_into_op_tx_info(self.0.eth_api.provider(), tx, tx_info)
     }
 }

crates/optimism/rpc/src/eth/transaction.rs

@@ -54,5 +54,6 @@ serde = [
     "reth-trie?/serde",
     "reth-ethereum-forks/serde",
     "reth-primitives-traits/serde",
+    "reth-storage-api/serde",
 ]
 portable = ["revm/portable"]

crates/revm/Cargo.toml

@@ -30,7 +30,10 @@ pub use pubsub::EthPubSubApiServer;
 pub use reth_rpc_eth_types::error::{
     AsEthApiError, FromEthApiError, FromEvmError, IntoEthApiError,
 };
-pub use reth_rpc_types_compat::TransactionCompat;
+pub use reth_rpc_types_compat::{
+    try_into_op_tx_info, IntoRpcTx, RpcConverter, TransactionCompat, TransactionConversionError,
+    TryIntoSimTx, TxInfoMapper,
+};
 pub use types::{EthApiTypes, FullEthApiTypes, RpcBlock, RpcHeader, RpcReceipt, RpcTransaction};
 
 #[cfg(feature = "client")]

crates/rpc/rpc-eth-api/src/lib.rs

@@ -13,6 +13,7 @@ use reth_primitives_traits::transaction::{error::InvalidTransactionError, signed
 use reth_rpc_server_types::result::{
     block_id_to_str, internal_rpc_err, invalid_params_rpc_err, rpc_err, rpc_error_with_code,
 };
+use reth_rpc_types_compat::TransactionConversionError;
 use reth_transaction_pool::error::{
     Eip4844PoolTransactionError, Eip7702PoolTransactionError, InvalidPoolTransactionError,
     PoolError, PoolErrorKind, PoolTransactionError,
@@ -230,6 +231,12 @@ impl From<EthApiError> for jsonrpsee_types::error::ErrorObject<'static> {
     }
 }
 
+impl From<TransactionConversionError> for EthApiError {
+    fn from(_: TransactionConversionError) -> Self {
+        Self::TransactionConversionError
+    }
+}
+
 #[cfg(feature = "js-tracer")]
 impl From<revm_inspectors::tracing::js::JsInspectorError> for EthApiError {
     fn from(error: revm_inspectors::tracing::js::JsInspectorError) -> Self {

crates/rpc/rpc-eth-types/src/error/mod.rs

@@ -14,12 +14,22 @@ workspace = true
 [dependencies]
 # reth
 reth-primitives-traits.workspace = true
+reth-storage-api = { workspace = true, features = ["serde", "serde-bincode-compat"] }
 
 # ethereum
 alloy-primitives.workspace = true
 alloy-rpc-types-eth = { workspace = true, default-features = false, features = ["serde"] }
 alloy-consensus.workspace = true
+alloy-network.workspace = true
+
+# optimism
+op-alloy-consensus.workspace = true
+op-alloy-rpc-types.workspace = true
+reth-optimism-primitives = { workspace = true, features = ["serde", "serde-bincode-compat"] }
 
 # io
 serde.workspace = true
 jsonrpsee-types.workspace = true
+
+# error
+thiserror.workspace = true