use result for TransactionCompact::fill.

crates/optimism/rpc/src/error.rs

@@ -4,6 +4,7 @@ use alloy_rpc_types::error::EthRpcErrorCode;
 use jsonrpsee_types::error::INTERNAL_ERROR_CODE;
 use reth_optimism_evm::OptimismBlockExecutionError;
 use reth_primitives::revm_primitives::{InvalidTransaction, OptimismInvalidTransaction};
+use reth_provider::ProviderError;
 use reth_rpc_eth_api::AsEthApiError;
 use reth_rpc_eth_types::EthApiError;
 use reth_rpc_server_types::result::{internal_rpc_err, rpc_err};
@@ -113,3 +114,9 @@ impl From<SequencerClientError> for jsonrpsee_types::error::ErrorObject<'static>
         )
     }
 }
+
+impl From<ProviderError> for OpEthApiError {
+    fn from(error: ProviderError) -> Self {
+        Self::Eth(error.into())
+    }
+}

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

@@ -15,7 +15,7 @@ use reth_rpc_eth_api::{
 use reth_rpc_eth_types::utils::recover_raw_transaction;
 use reth_transaction_pool::{PoolTransaction, TransactionOrigin, TransactionPool};
 
-use crate::{OpEthApi, SequencerClient};
+use crate::{OpEthApi, OpEthApiError, SequencerClient};
 
 impl<N> EthTransactions for OpEthApi<N>
 where
@@ -76,12 +76,22 @@ where
     N: FullNodeComponents,
 {
     type Transaction = Transaction;
+    type TransactionError = OpEthApiError;
 
     fn fill(
         &self,
         tx: TransactionSignedEcRecovered,
         tx_info: TransactionInfo,
-    ) -> Self::Transaction {
+    ) -> Result<Self::Transaction, Self::TransactionError> {
+        //let signed_tx = tx.clone().into_signed();
+        //let hash = tx.hash;
+        //
+        //let mut inner =
+        //    EthTxBuilder.fill(tx, tx_info).expect("EthTxBuilder.fill should be infallible");
+        //
+        //if signed_tx.is_deposit() {
+        //    inner.gas_price = Some(signed_tx.max_fee_per_gas())
+        //}
         let from = tx.signer();
         let TransactionSigned { transaction, signature, hash } = tx.into_signed();
 
@@ -105,14 +115,12 @@ where
         let deposit_receipt_version = self
             .inner
             .provider()
-            .receipt_by_hash(hash)
-            .ok() // todo: change sig to return result
-            .flatten()
+            .receipt_by_hash(hash)?
             .and_then(|receipt| receipt.deposit_receipt_version);
 
         let TransactionInfo { block_hash, block_number, index: transaction_index, .. } = tx_info;
 
-        Transaction {
+        Ok(Transaction {
             inner: alloy_rpc_types::Transaction {
                 inner,
                 block_hash,
@@ -121,7 +129,7 @@ where
                 from,
             },
             deposit_receipt_version,
-        }
+        })
     }
 
     fn otterscan_api_truncate_input(tx: &mut Self::Transaction) {

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

@@ -501,7 +501,8 @@ where
         trace!(target: "rpc::eth", ?hash, "Serving eth_getTransactionByHash");
         Ok(EthTransactions::transaction_by_hash(self, hash)
             .await?
-            .map(|tx| tx.into_transaction(self.tx_resp_builder())))
+            .map(|tx| tx.into_transaction(self.tx_resp_builder()))
+            .transpose()?)
     }
 
     /// Handler for: `eth_getRawTransactionByBlockHashAndIndex`

crates/rpc/rpc-eth-api/src/helpers/transaction.rs

@@ -209,7 +209,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
                         tx.clone().with_signer(*signer),
                         tx_info,
                         self.tx_resp_builder(),
-                    )))
+                    )?))
                 }
             }
 
@@ -234,7 +234,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
                     RpcNodeCore::pool(self).get_transaction_by_sender_and_nonce(sender, nonce)
                 {
                     let transaction = tx.transaction.clone().into_consensus();
-                    return Ok(Some(from_recovered(transaction.into(), self.tx_resp_builder())));
+                    return Ok(Some(from_recovered(transaction.into(), self.tx_resp_builder())?));
                 }
             }
 
@@ -292,7 +292,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
                             )
                         })
                 })
-                .ok_or(EthApiError::HeaderNotFound(block_id).into())
+                .ok_or(EthApiError::HeaderNotFound(block_id))?
                 .map(Some)
         }
     }

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

@@ -41,13 +41,21 @@ pub type RpcReceipt<T> = <T as Network>::ReceiptResponse;
 
 /// Helper trait holds necessary trait bounds on [`EthApiTypes`] to implement `eth` API.
 pub trait FullEthApiTypes:
-    EthApiTypes<TransactionCompat: TransactionCompat<Transaction = RpcTransaction<Self::NetworkTypes>>>
+    EthApiTypes<
+    TransactionCompat: TransactionCompat<
+        Transaction = RpcTransaction<Self::NetworkTypes>,
+        TransactionError = Self::Error,
+    >,
+>
 {
 }
 
 impl<T> FullEthApiTypes for T where
     T: EthApiTypes<
-        TransactionCompat: TransactionCompat<Transaction = RpcTransaction<T::NetworkTypes>>,
+        TransactionCompat: TransactionCompat<
+            Transaction = RpcTransaction<T::NetworkTypes>,
+            TransactionError = T::Error,
+        >,
     >
 {
 }

crates/rpc/rpc-eth-types/src/transaction.rs

@@ -41,7 +41,10 @@ impl TransactionSource {
     }
 
     /// Conversion into network specific transaction type.
-    pub fn into_transaction<T: TransactionCompat>(self, resp_builder: &T) -> T::Transaction {
+    pub fn into_transaction<T: TransactionCompat>(
+        self,
+        resp_builder: &T,
+    ) -> Result<T::Transaction, T::TransactionError> {
         match self {
             Self::Pool(tx) => from_recovered(tx, resp_builder),
             Self::Block { transaction, index, block_hash, block_number, base_fee } => {

crates/rpc/rpc-types-compat/src/block.rs

@@ -88,7 +88,8 @@ pub fn from_block_full<T: TransactionCompat>(
 
             from_recovered_with_block_context::<T>(signed_tx_ec_recovered, tx_info, tx_resp_builder)
         })
-        .collect::<Vec<_>>();
+        .collect::<Result<Vec<_>, T::TransactionError>>()
+        .expect("fill should be infallible");
 
     Ok(from_block_with_transactions(
         block_length,

crates/rpc/rpc-types-compat/src/transaction/mod.rs

@@ -1,5 +1,6 @@
 //! Compatibility functions for rpc `Transaction` type.
 
+use core::error;
 use std::fmt;
 
 use alloy_consensus::Transaction as _;
@@ -19,7 +20,7 @@ pub fn from_recovered_with_block_context<T: TransactionCompat>(
     tx: TransactionSignedEcRecovered,
     tx_info: TransactionInfo,
     resp_builder: &T,
-) -> T::Transaction {
+) -> Result<T::Transaction, T::TransactionError> {
     resp_builder.fill(tx, tx_info)
 }
 
@@ -28,7 +29,7 @@ pub fn from_recovered_with_block_context<T: TransactionCompat>(
 pub fn from_recovered<T: TransactionCompat>(
     tx: TransactionSignedEcRecovered,
     resp_builder: &T,
-) -> T::Transaction {
+) -> Result<T::Transaction, T::TransactionError> {
     resp_builder.fill(tx, TransactionInfo::default())
 }
 
@@ -43,9 +44,16 @@ pub trait TransactionCompat: Send + Sync + Unpin + Clone + fmt::Debug {
         + Clone
         + fmt::Debug;
 
+    /// RPC transaction error type.
+    type TransactionError: error::Error;
+
     /// Create a new rpc transaction result for a _pending_ signed transaction, setting block
     /// environment related fields to `None`.
-    fn fill(&self, tx: TransactionSignedEcRecovered, tx_inf: TransactionInfo) -> Self::Transaction;
+    fn fill(
+        &self,
+        tx: TransactionSignedEcRecovered,
+        tx_inf: TransactionInfo,
+    ) -> Result<Self::Transaction, Self::TransactionError>;
 
     /// Truncates the input of a transaction to only the first 4 bytes.
     // todo: remove in favour of using constructor on `TransactionResponse` or similar

crates/rpc/rpc/src/eth/filter.rs

@@ -625,10 +625,10 @@ where
         let mut prepared_stream = self.txs_stream.lock().await;
 
         while let Ok(tx) = prepared_stream.try_recv() {
-            pending_txs.push(from_recovered(
-                tx.transaction.to_recovered_transaction(),
-                &self.tx_resp_builder,
-            ))
+            pending_txs.push(
+                from_recovered(tx.transaction.to_recovered_transaction(), &self.tx_resp_builder)
+                    .expect("fill should be infallible"),
+            );
         }
         FilterChanges::Transactions(pending_txs)
     }

crates/rpc/rpc/src/eth/helpers/types.rs

@@ -4,6 +4,7 @@ use alloy_consensus::{Signed, TxEip4844Variant, TxEnvelope};
 use alloy_network::{Ethereum, Network};
 use alloy_rpc_types::{Transaction, TransactionInfo};
 use reth_primitives::{TransactionSigned, TransactionSignedEcRecovered};
+use reth_rpc_eth_types::EthApiError;
 use reth_rpc_types_compat::TransactionCompat;
 
 /// Builds RPC transaction response for l1.
@@ -16,11 +17,13 @@ where
 {
     type Transaction = <Ethereum as Network>::TransactionResponse;
 
+    type TransactionError = EthApiError;
+
     fn fill(
         &self,
         tx: TransactionSignedEcRecovered,
         tx_info: TransactionInfo,
-    ) -> Self::Transaction {
+    ) -> Result<Self::Transaction, Self::TransactionError> {
         let from = tx.signer();
         let TransactionSigned { transaction, signature, hash } = tx.into_signed();
 
@@ -46,7 +49,7 @@ where
 
         let TransactionInfo { block_hash, block_number, index: transaction_index, .. } = tx_info;
 
-        Transaction { inner, block_hash, block_number, transaction_index, from }
+        Ok(Transaction { inner, block_hash, block_number, transaction_index, from })
     }
 
     fn otterscan_api_truncate_input(tx: &mut Self::Transaction) {

crates/rpc/rpc/src/eth/pubsub.rs

@@ -147,10 +147,13 @@ where
                     Params::Bool(true) => {
                         // full transaction objects requested
                         let stream = pubsub.full_pending_transaction_stream().map(|tx| {
-                            EthSubscriptionResult::FullTransaction(Box::new(from_recovered(
-                                tx.transaction.to_recovered_transaction(),
-                                &tx_resp_builder,
-                            )))
+                            EthSubscriptionResult::FullTransaction(Box::new(
+                                from_recovered(
+                                    tx.transaction.to_recovered_transaction(),
+                                    &tx_resp_builder,
+                                )
+                                .expect("fill should be infallible"),
+                            ))
                         });
                         return pipe_from_stream(accepted_sink, stream).await
                     }

crates/rpc/rpc/src/txpool.rs

@@ -47,7 +47,8 @@ where
         {
             content.entry(tx.sender()).or_default().insert(
                 tx.nonce().to_string(),
-                from_recovered(tx.clone().into_consensus().into(), resp_builder),
+                from_recovered(tx.clone().into_consensus().into(), resp_builder)
+                    .expect("fill should be infallible"),
             );
         }