chore: pass primiitves generic to EngineApiTreeHandler fields (#13256)

crates/blockchain-tree/Cargo.toml

@@ -31,6 +31,7 @@ reth-consensus.workspace = true
 reth-node-types.workspace = true
 
 # ethereum
+alloy-consensus.workspace = true
 alloy-primitives.workspace = true
 alloy-eips.workspace = true
 

crates/blockchain-tree/src/block_buffer.rs

@@ -1,6 +1,8 @@
 use crate::metrics::BlockBufferMetrics;
+use alloy_consensus::BlockHeader;
 use alloy_primitives::{BlockHash, BlockNumber};
 use reth_network::cache::LruCache;
+use reth_node_types::Block;
 use reth_primitives::SealedBlockWithSenders;
 use std::collections::{BTreeMap, HashMap, HashSet};
 
@@ -16,9 +18,9 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 /// Note: Buffer is limited by number of blocks that it can contain and eviction of the block
 /// is done by last recently used block.
 #[derive(Debug)]
-pub struct BlockBuffer {
+pub struct BlockBuffer<B: Block = reth_primitives::Block> {
     /// All blocks in the buffer stored by their block hash.
-    pub(crate) blocks: HashMap<BlockHash, SealedBlockWithSenders>,
+    pub(crate) blocks: HashMap<BlockHash, SealedBlockWithSenders<B>>,
     /// Map of any parent block hash (even the ones not currently in the buffer)
     /// to the buffered children.
     /// Allows connecting buffered blocks by parent.
@@ -35,7 +37,7 @@ pub struct BlockBuffer {
     pub(crate) metrics: BlockBufferMetrics,
 }
 
-impl BlockBuffer {
+impl<B: Block> BlockBuffer<B> {
     /// Create new buffer with max limit of blocks
     pub fn new(limit: u32) -> Self {
         Self {
@@ -48,37 +50,37 @@ impl BlockBuffer {
     }
 
     /// Return reference to buffered blocks
-    pub const fn blocks(&self) -> &HashMap<BlockHash, SealedBlockWithSenders> {
+    pub const fn blocks(&self) -> &HashMap<BlockHash, SealedBlockWithSenders<B>> {
         &self.blocks
     }
 
     /// Return reference to the requested block.
-    pub fn block(&self, hash: &BlockHash) -> Option<&SealedBlockWithSenders> {
+    pub fn block(&self, hash: &BlockHash) -> Option<&SealedBlockWithSenders<B>> {
         self.blocks.get(hash)
     }
 
     /// Return a reference to the lowest ancestor of the given block in the buffer.
-    pub fn lowest_ancestor(&self, hash: &BlockHash) -> Option<&SealedBlockWithSenders> {
+    pub fn lowest_ancestor(&self, hash: &BlockHash) -> Option<&SealedBlockWithSenders<B>> {
         let mut current_block = self.blocks.get(hash)?;
-        while let Some(parent) = self.blocks.get(&current_block.parent_hash) {
+        while let Some(parent) = self.blocks.get(&current_block.parent_hash()) {
             current_block = parent;
         }
         Some(current_block)
     }
 
     /// Insert a correct block inside the buffer.
-    pub fn insert_block(&mut self, block: SealedBlockWithSenders) {
+    pub fn insert_block(&mut self, block: SealedBlockWithSenders<B>) {
         let hash = block.hash();
 
-        self.parent_to_child.entry(block.parent_hash).or_default().insert(hash);
-        self.earliest_blocks.entry(block.number).or_default().insert(hash);
+        self.parent_to_child.entry(block.parent_hash()).or_default().insert(hash);
+        self.earliest_blocks.entry(block.number()).or_default().insert(hash);
         self.blocks.insert(hash, block);
 
         if let (_, Some(evicted_hash)) = self.lru.insert_and_get_evicted(hash) {
             // evict the block if limit is hit
             if let Some(evicted_block) = self.remove_block(&evicted_hash) {
                 // evict the block if limit is hit
-                self.remove_from_parent(evicted_block.parent_hash, &evicted_hash);
+                self.remove_from_parent(evicted_block.parent_hash(), &evicted_hash);
             }
         }
         self.metrics.blocks.set(self.blocks.len() as f64);
@@ -93,7 +95,7 @@ impl BlockBuffer {
     pub fn remove_block_with_children(
         &mut self,
         parent_hash: &BlockHash,
-    ) -> Vec<SealedBlockWithSenders> {
+    ) -> Vec<SealedBlockWithSenders<B>> {
         let removed = self
             .remove_block(parent_hash)
             .into_iter()
@@ -152,16 +154,16 @@ impl BlockBuffer {
     /// This method will only remove the block if it's present inside `self.blocks`.
     /// The block might be missing from other collections, the method will only ensure that it has
     /// been removed.
-    fn remove_block(&mut self, hash: &BlockHash) -> Option<SealedBlockWithSenders> {
+    fn remove_block(&mut self, hash: &BlockHash) -> Option<SealedBlockWithSenders<B>> {
         let block = self.blocks.remove(hash)?;
-        self.remove_from_earliest_blocks(block.number, hash);
-        self.remove_from_parent(block.parent_hash, hash);
+        self.remove_from_earliest_blocks(block.number(), hash);
+        self.remove_from_parent(block.parent_hash(), hash);
         self.lru.remove(hash);
         Some(block)
     }
 
     /// Remove all children and their descendants for the given blocks and return them.
-    fn remove_children(&mut self, parent_hashes: Vec<BlockHash>) -> Vec<SealedBlockWithSenders> {
+    fn remove_children(&mut self, parent_hashes: Vec<BlockHash>) -> Vec<SealedBlockWithSenders<B>> {
         // remove all parent child connection and all the child children blocks that are connected
         // to the discarded parent blocks.
         let mut remove_parent_children = parent_hashes;