feat: add NoopBlockchainTree (#4852)

crates/blockchain-tree/src/lib.rs

@@ -48,3 +48,6 @@ mod canonical_chain;
 pub mod metrics;
 
 pub use block_buffer::BlockBuffer;
+
+/// Implementation of Tree traits that does nothing.
+pub mod noop;

crates/blockchain-tree/src/noop.rs

@@ -0,0 +1,133 @@
+use reth_interfaces::{
+    blockchain_tree::{
+        error::{BlockchainTreeError, InsertBlockError},
+        BlockchainTreeEngine, BlockchainTreeViewer, CanonicalOutcome, InsertPayloadOk,
+    },
+    RethResult,
+};
+use reth_primitives::{
+    BlockHash, BlockNumHash, BlockNumber, Receipt, SealedBlock, SealedBlockWithSenders,
+    SealedHeader,
+};
+use reth_provider::{
+    BlockchainTreePendingStateProvider, BundleStateDataProvider, CanonStateNotificationSender,
+    CanonStateNotifications, CanonStateSubscriptions,
+};
+use std::collections::{BTreeMap, HashSet};
+
+/// A BlockchainTree that does nothing.
+///
+/// Caution: this is only intended for testing purposes, or for wiring components together.
+#[derive(Debug, Clone, Default)]
+#[non_exhaustive]
+pub struct NoopBlockchainTree {}
+
+impl BlockchainTreeEngine for NoopBlockchainTree {
+    fn buffer_block(&self, _block: SealedBlockWithSenders) -> Result<(), InsertBlockError> {
+        Ok(())
+    }
+
+    fn insert_block(
+        &self,
+        block: SealedBlockWithSenders,
+    ) -> Result<InsertPayloadOk, InsertBlockError> {
+        Err(InsertBlockError::tree_error(
+            BlockchainTreeError::BlockHashNotFoundInChain { block_hash: block.hash },
+            block.block,
+        ))
+    }
+
+    fn finalize_block(&self, _finalized_block: BlockNumber) {}
+
+    fn connect_buffered_blocks_to_canonical_hashes_and_finalize(
+        &self,
+        _last_finalized_block: BlockNumber,
+    ) -> RethResult<()> {
+        Ok(())
+    }
+
+    fn connect_buffered_blocks_to_canonical_hashes(&self) -> RethResult<()> {
+        Ok(())
+    }
+
+    fn make_canonical(&self, block_hash: &BlockHash) -> RethResult<CanonicalOutcome> {
+        Err(BlockchainTreeError::BlockHashNotFoundInChain { block_hash: *block_hash }.into())
+    }
+
+    fn unwind(&self, _unwind_to: BlockNumber) -> RethResult<()> {
+        Ok(())
+    }
+}
+
+impl BlockchainTreeViewer for NoopBlockchainTree {
+    fn blocks(&self) -> BTreeMap<BlockNumber, HashSet<BlockHash>> {
+        Default::default()
+    }
+
+    fn header_by_hash(&self, _hash: BlockHash) -> Option<SealedHeader> {
+        None
+    }
+
+    fn block_by_hash(&self, _hash: BlockHash) -> Option<SealedBlock> {
+        None
+    }
+
+    fn buffered_block_by_hash(&self, _block_hash: BlockHash) -> Option<SealedBlock> {
+        None
+    }
+
+    fn buffered_header_by_hash(&self, _block_hash: BlockHash) -> Option<SealedHeader> {
+        None
+    }
+
+    fn canonical_blocks(&self) -> BTreeMap<BlockNumber, BlockHash> {
+        Default::default()
+    }
+
+    fn find_canonical_ancestor(&self, _parent_hash: BlockHash) -> Option<BlockHash> {
+        None
+    }
+
+    fn is_canonical(&self, block_hash: BlockHash) -> RethResult<bool> {
+        Err(BlockchainTreeError::BlockHashNotFoundInChain { block_hash }.into())
+    }
+
+    fn lowest_buffered_ancestor(&self, _hash: BlockHash) -> Option<SealedBlockWithSenders> {
+        None
+    }
+
+    fn canonical_tip(&self) -> BlockNumHash {
+        Default::default()
+    }
+
+    fn pending_blocks(&self) -> (BlockNumber, Vec<BlockHash>) {
+        (0, vec![])
+    }
+
+    fn pending_block_num_hash(&self) -> Option<BlockNumHash> {
+        None
+    }
+
+    fn pending_block_and_receipts(&self) -> Option<(SealedBlock, Vec<Receipt>)> {
+        None
+    }
+
+    fn receipts_by_block_hash(&self, _block_hash: BlockHash) -> Option<Vec<Receipt>> {
+        None
+    }
+}
+
+impl BlockchainTreePendingStateProvider for NoopBlockchainTree {
+    fn find_pending_state_provider(
+        &self,
+        _block_hash: BlockHash,
+    ) -> Option<Box<dyn BundleStateDataProvider>> {
+        None
+    }
+}
+
+impl CanonStateSubscriptions for NoopBlockchainTree {
+    fn subscribe_to_canonical_state(&self) -> CanonStateNotifications {
+        CanonStateNotificationSender::new(1).subscribe()
+    }
+}

crates/blockchain-tree/src/shareable.rs

@@ -149,6 +149,11 @@ impl<DB: Database, C: Consensus, EF: ExecutorFactory> BlockchainTreeViewer
         None
     }
 
+    fn is_canonical(&self, hash: BlockHash) -> RethResult<bool> {
+        trace!(target: "blockchain_tree", ?hash, "Checking if block is canonical");
+        self.tree.read().is_block_hash_canonical(&hash)
+    }
+
     fn lowest_buffered_ancestor(&self, hash: BlockHash) -> Option<SealedBlockWithSenders> {
         trace!(target: "blockchain_tree", ?hash, "Returning lowest buffered ancestor");
         self.tree.read().lowest_buffered_ancestor(&hash).cloned()
@@ -159,11 +164,6 @@ impl<DB: Database, C: Consensus, EF: ExecutorFactory> BlockchainTreeViewer
         self.tree.read().block_indices().canonical_tip()
     }
 
-    fn is_canonical(&self, hash: BlockHash) -> RethResult<bool> {
-        trace!(target: "blockchain_tree", ?hash, "Checking if block is canonical");
-        self.tree.read().is_block_hash_canonical(&hash)
-    }
-
     fn pending_blocks(&self) -> (BlockNumber, Vec<BlockHash>) {
         trace!(target: "blockchain_tree", "Returning all pending blocks");
         self.tree.read().block_indices().pending_blocks()