From a4b408848fa0f430fdabcd03465c9c5b2e5e9f70 Mon Sep 17 00:00:00 2001
From: yohkaz <yoh.kzl@gmail.com>
Date: Wed, 29 Jan 2025 11:44:06 +0200
Subject: [PATCH] Make impls for MockEthProvider more generic (#14055)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>
---
 .../storage/provider/src/test_utils/mock.rs   | 111 ++++++++++--------
 1 file changed, 59 insertions(+), 52 deletions(-)

diff --git a/crates/storage/provider/src/test_utils/mock.rs b/crates/storage/provider/src/test_utils/mock.rs
index bf8d9affbd..b3b9f420b0 100644
--- a/crates/storage/provider/src/test_utils/mock.rs
+++ b/crates/storage/provider/src/test_utils/mock.rs
@@ -5,7 +5,9 @@ use crate::{
     ReceiptProviderIdExt, StateProvider, StateProviderBox, StateProviderFactory, StateReader,
     StateRootProvider, TransactionVariant, TransactionsProvider, WithdrawalsProvider,
 };
-use alloy_consensus::{constants::EMPTY_ROOT_HASH, transaction::TransactionMeta, Header};
+use alloy_consensus::{
+    constants::EMPTY_ROOT_HASH, transaction::TransactionMeta, Header, Transaction,
+};
 use alloy_eips::{eip4895::Withdrawals, BlockHashOrNumber, BlockId, BlockNumberOrTag};
 use alloy_primitives::{
     keccak256,
@@ -56,6 +58,17 @@ pub struct MockEthProvider<T = TransactionSigned> {
 }
 
 impl<T> MockEthProvider<T> {
+    /// Create a new, empty instance
+    pub fn new() -> Self {
+        Self {
+            blocks: Default::default(),
+            headers: Default::default(),
+            accounts: Default::default(),
+            chain_spec: Arc::new(reth_chainspec::ChainSpecBuilder::mainnet().build()),
+            state_roots: Default::default(),
+        }
+    }
+
     /// Add block to local block store
     pub fn add_block(&self, hash: B256, block: Block<T>) {
         self.add_header(hash, block.header.clone());
@@ -100,15 +113,9 @@ impl<T> MockEthProvider<T> {
     }
 }
 
-impl<T> Default for MockEthProvider<T> {
+impl Default for MockEthProvider {
     fn default() -> Self {
-        Self {
-            blocks: Default::default(),
-            headers: Default::default(),
-            accounts: Default::default(),
-            chain_spec: Arc::new(reth_chainspec::ChainSpecBuilder::mainnet().build()),
-            state_roots: Default::default(),
-        }
+        Self::new()
     }
 }
 
@@ -160,11 +167,11 @@ impl NodeTypes for MockNode {
     type Storage = EthStorage;
 }
 
-impl StateCommitmentProvider for MockEthProvider {
+impl<T: Transaction> StateCommitmentProvider for MockEthProvider<T> {
     type StateCommitment = <MockNode as NodeTypes>::StateCommitment;
 }
 
-impl DatabaseProviderFactory for MockEthProvider {
+impl<T: Transaction> DatabaseProviderFactory for MockEthProvider<T> {
     type DB = DatabaseMock;
     type Provider = DatabaseProvider<TxMock, MockNode>;
     type ProviderRW = DatabaseProvider<TxMock, MockNode>;
@@ -178,7 +185,7 @@ impl DatabaseProviderFactory for MockEthProvider {
     }
 }
 
-impl HeaderProvider for MockEthProvider {
+impl<T: Transaction> HeaderProvider for MockEthProvider<T> {
     type Header = Header;
 
     fn header(&self, block_hash: &BlockHash) -> ProviderResult<Option<Header>> {
@@ -237,7 +244,7 @@ impl HeaderProvider for MockEthProvider {
     }
 }
 
-impl ChainSpecProvider for MockEthProvider {
+impl<T: Transaction> ChainSpecProvider for MockEthProvider<T> {
     type ChainSpec = ChainSpec;
 
     fn chain_spec(&self) -> Arc<ChainSpec> {
@@ -245,8 +252,8 @@ impl ChainSpecProvider for MockEthProvider {
     }
 }
 
-impl TransactionsProvider for MockEthProvider {
-    type Transaction = TransactionSigned;
+impl<T: SignedTransaction> TransactionsProvider for MockEthProvider<T> {
+    type Transaction = T;
 
     fn transaction_id(&self, tx_hash: TxHash) -> ProviderResult<Option<TxNumber>> {
         let lock = self.blocks.lock();
@@ -278,7 +285,7 @@ impl TransactionsProvider for MockEthProvider {
         Ok(transaction)
     }
 
-    fn transaction_by_hash(&self, hash: TxHash) -> ProviderResult<Option<TransactionSigned>> {
+    fn transaction_by_hash(&self, hash: TxHash) -> ProviderResult<Option<Self::Transaction>> {
         Ok(self.blocks.lock().iter().find_map(|(_, block)| {
             block.body.transactions.iter().find(|tx| *tx.tx_hash() == hash).cloned()
         }))
@@ -384,7 +391,7 @@ impl TransactionsProvider for MockEthProvider {
     }
 }
 
-impl ReceiptProvider for MockEthProvider {
+impl<T: Transaction> ReceiptProvider for MockEthProvider<T> {
     type Receipt = Receipt;
 
     fn receipt(&self, _id: TxNumber) -> ProviderResult<Option<Receipt>> {
@@ -407,9 +414,9 @@ impl ReceiptProvider for MockEthProvider {
     }
 }
 
-impl ReceiptProviderIdExt for MockEthProvider {}
+impl<T: Transaction> ReceiptProviderIdExt for MockEthProvider<T> {}
 
-impl BlockHashReader for MockEthProvider {
+impl<T: Transaction> BlockHashReader for MockEthProvider<T> {
     fn block_hash(&self, number: u64) -> ProviderResult<Option<B256>> {
         let lock = self.blocks.lock();
 
@@ -433,7 +440,7 @@ impl BlockHashReader for MockEthProvider {
     }
 }
 
-impl BlockNumReader for MockEthProvider {
+impl<T: Transaction> BlockNumReader for MockEthProvider<T> {
     fn chain_info(&self) -> ProviderResult<ChainInfo> {
         let best_block_number = self.best_block_number()?;
         let lock = self.headers.lock();
@@ -464,7 +471,7 @@ impl BlockNumReader for MockEthProvider {
     }
 }
 
-impl BlockIdReader for MockEthProvider {
+impl<T: Transaction> BlockIdReader for MockEthProvider<T> {
     fn pending_block_num_hash(&self) -> ProviderResult<Option<alloy_eips::BlockNumHash>> {
         Ok(None)
     }
@@ -478,18 +485,18 @@ impl BlockIdReader for MockEthProvider {
     }
 }
 
-impl BlockReader for MockEthProvider {
-    type Block = Block;
+impl<T: SignedTransaction> BlockReader for MockEthProvider<T> {
+    type Block = Block<T>;
 
     fn find_block_by_hash(
         &self,
         hash: B256,
         _source: BlockSource,
-    ) -> ProviderResult<Option<Block>> {
+    ) -> ProviderResult<Option<Self::Block>> {
         self.block(hash.into())
     }
 
-    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
         let lock = self.blocks.lock();
         match id {
             BlockHashOrNumber::Hash(hash) => Ok(lock.get(&hash).cloned()),
@@ -497,17 +504,17 @@ impl BlockReader for MockEthProvider {
         }
     }
 
-    fn pending_block(&self) -> ProviderResult<Option<SealedBlock>> {
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlock<Self::Block>>> {
         Ok(None)
     }
 
-    fn pending_block_with_senders(
+    fn pending_block_with_senders(&self) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
+        Ok(None)
+    }
+
+    fn pending_block_and_receipts(
         &self,
-    ) -> ProviderResult<Option<RecoveredBlock<reth_primitives::Block>>> {
-        Ok(None)
-    }
-
-    fn pending_block_and_receipts(&self) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>> {
+    ) -> ProviderResult<Option<(SealedBlock<Self::Block>, Vec<Receipt>)>> {
         Ok(None)
     }
 
@@ -515,7 +522,7 @@ impl BlockReader for MockEthProvider {
         &self,
         _id: BlockHashOrNumber,
         _transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<RecoveredBlock<reth_primitives::Block>>> {
+    ) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
         Ok(None)
     }
 
@@ -523,11 +530,11 @@ impl BlockReader for MockEthProvider {
         &self,
         _id: BlockHashOrNumber,
         _transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<RecoveredBlock<reth_primitives::Block>>> {
+    ) -> ProviderResult<Option<RecoveredBlock<Self::Block>>> {
         Ok(None)
     }
 
-    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>> {
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
         let lock = self.blocks.lock();
 
         let mut blocks: Vec<_> =
@@ -540,20 +547,20 @@ impl BlockReader for MockEthProvider {
     fn block_with_senders_range(
         &self,
         _range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<RecoveredBlock<reth_primitives::Block>>> {
+    ) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
         Ok(vec![])
     }
 
     fn sealed_block_with_senders_range(
         &self,
         _range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<RecoveredBlock<reth_primitives::Block>>> {
+    ) -> ProviderResult<Vec<RecoveredBlock<Self::Block>>> {
         Ok(vec![])
     }
 }
 
-impl BlockReaderIdExt for MockEthProvider {
-    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Block>> {
+impl<T: SignedTransaction> BlockReaderIdExt for MockEthProvider<T> {
+    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Block<T>>> {
         match id {
             BlockId::Number(num) => self.block_by_number_or_tag(num),
             BlockId::Hash(hash) => self.block_by_hash(hash.block_hash),
@@ -579,13 +586,13 @@ impl BlockReaderIdExt for MockEthProvider {
     }
 }
 
-impl AccountReader for MockEthProvider {
+impl<T: Transaction> AccountReader for MockEthProvider<T> {
     fn basic_account(&self, address: &Address) -> ProviderResult<Option<Account>> {
         Ok(self.accounts.lock().get(address).cloned().map(|a| a.account))
     }
 }
 
-impl StageCheckpointReader for MockEthProvider {
+impl<T: Transaction> StageCheckpointReader for MockEthProvider<T> {
     fn get_stage_checkpoint(&self, _id: StageId) -> ProviderResult<Option<StageCheckpoint>> {
         Ok(None)
     }
@@ -599,7 +606,7 @@ impl StageCheckpointReader for MockEthProvider {
     }
 }
 
-impl StateRootProvider for MockEthProvider {
+impl<T: Transaction> StateRootProvider for MockEthProvider<T> {
     fn state_root(&self, _state: HashedPostState) -> ProviderResult<B256> {
         Ok(self.state_roots.lock().pop().unwrap_or_default())
     }
@@ -625,7 +632,7 @@ impl StateRootProvider for MockEthProvider {
     }
 }
 
-impl StorageRootProvider for MockEthProvider {
+impl<T: Transaction> StorageRootProvider for MockEthProvider<T> {
     fn storage_root(
         &self,
         _address: Address,
@@ -653,7 +660,7 @@ impl StorageRootProvider for MockEthProvider {
     }
 }
 
-impl StateProofProvider for MockEthProvider {
+impl<T: Transaction> StateProofProvider for MockEthProvider<T> {
     fn proof(
         &self,
         _input: TrieInput,
@@ -680,13 +687,13 @@ impl StateProofProvider for MockEthProvider {
     }
 }
 
-impl HashedPostStateProvider for MockEthProvider {
+impl<T: Transaction> HashedPostStateProvider for MockEthProvider<T> {
     fn hashed_post_state(&self, _state: &revm::db::BundleState) -> HashedPostState {
         HashedPostState::default()
     }
 }
 
-impl StateProvider for MockEthProvider {
+impl<T: Transaction> StateProvider for MockEthProvider<T> {
     fn storage(
         &self,
         account: Address,
@@ -709,7 +716,7 @@ impl StateProvider for MockEthProvider {
     }
 }
 
-impl StateProviderFactory for MockEthProvider {
+impl<T: SignedTransaction> StateProviderFactory for MockEthProvider<T> {
     fn latest(&self) -> ProviderResult<StateProviderBox> {
         Ok(Box::new(self.clone()))
     }
@@ -761,7 +768,7 @@ impl StateProviderFactory for MockEthProvider {
     }
 }
 
-impl WithdrawalsProvider for MockEthProvider {
+impl<T: Transaction> WithdrawalsProvider for MockEthProvider<T> {
     fn withdrawals_by_block(
         &self,
         _id: BlockHashOrNumber,
@@ -771,13 +778,13 @@ impl WithdrawalsProvider for MockEthProvider {
     }
 }
 
-impl OmmersProvider for MockEthProvider {
+impl<T: Transaction> OmmersProvider for MockEthProvider<T> {
     fn ommers(&self, _id: BlockHashOrNumber) -> ProviderResult<Option<Vec<Header>>> {
         Ok(None)
     }
 }
 
-impl BlockBodyIndicesProvider for MockEthProvider {
+impl<T: Transaction> BlockBodyIndicesProvider for MockEthProvider<T> {
     fn block_body_indices(&self, _num: u64) -> ProviderResult<Option<StoredBlockBodyIndices>> {
         Ok(None)
     }
@@ -789,7 +796,7 @@ impl BlockBodyIndicesProvider for MockEthProvider {
     }
 }
 
-impl ChangeSetReader for MockEthProvider {
+impl<T: Transaction> ChangeSetReader for MockEthProvider<T> {
     fn account_block_changeset(
         &self,
         _block_number: BlockNumber,
@@ -798,7 +805,7 @@ impl ChangeSetReader for MockEthProvider {
     }
 }
 
-impl StateReader for MockEthProvider {
+impl<T: Transaction> StateReader for MockEthProvider<T> {
     type Receipt = Receipt;
 
     fn get_state(&self, _block: BlockNumber) -> ProviderResult<Option<ExecutionOutcome>> {