refactor: replace tuple with BlockNumHash (#254)

Resolves #239

---------

Co-authored-by: Einar Rasmussen <[email protected]>

Author: einar-oplabs

Cargo.lock

@@ -28,6 +28,7 @@ reth-metrics = { workspace = true, features = ["common"] }
 
 # ethereum
 alloy-primitives.workspace = true
+alloy-eips.workspace = true
 
 # async
 tokio = { workspace = true, features = ["sync"] }
@@ -59,4 +60,5 @@ reth-trie = { workspace = true, features = ["test-utils"] }
 serde-bincode-compat = [
     "reth-primitives-traits/serde-bincode-compat",
     "reth-trie/serde-bincode-compat",
+    "alloy-eips/serde-bincode-compat",
 ]

crates/optimism/trie/Cargo.toml

@@ -1,6 +1,7 @@
+use alloy_eips::BlockNumHash;
 use alloy_primitives::B256;
 use bytes::BufMut;
-use derive_more::{Constructor, From, Into};
+use derive_more::{From, Into};
 use reth_db::{
     table::{Compress, Decompress},
     DatabaseError,
@@ -10,16 +11,16 @@ use serde::{Deserialize, Serialize};
 /// Wrapper for block number and block hash tuple to implement [`Compress`]/[`Decompress`].
 ///
 /// Used for storing block metadata (number + hash).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, From, Into, Constructor)]
-pub struct BlockNumberHash(pub u64, pub B256);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, From, Into)]
+pub struct BlockNumberHash(BlockNumHash);
 
 impl Compress for BlockNumberHash {
     type Compressed = Vec<u8>;
 
     fn compress_to_buf<B: BufMut + AsMut<[u8]>>(&self, buf: &mut B) {
         // Encode block number (8 bytes, big-endian) + hash (32 bytes) = 40 bytes total
-        buf.put_u64(self.0);
-        buf.put_slice(self.1.as_slice());
+        buf.put_u64(self.0.number);
+        buf.put_slice(self.0.hash.as_slice());
     }
 }
 
@@ -29,11 +30,27 @@ impl Decompress for BlockNumberHash {
             return Err(DatabaseError::Decode);
         }
 
-        let block_number =
-            u64::from_be_bytes(value[..8].try_into().map_err(|_| DatabaseError::Decode)?);
+        let number = u64::from_be_bytes(value[..8].try_into().map_err(|_| DatabaseError::Decode)?);
         let hash = B256::from_slice(&value[8..40]);
 
-        Ok(Self(block_number, hash))
+        Ok(Self(BlockNumHash { number, hash }))
+    }
+}
+
+impl BlockNumberHash {
+    /// Create new instance.
+    pub const fn new(number: u64, hash: B256) -> Self {
+        Self(BlockNumHash { number, hash })
+    }
+
+    /// Get the block number.
+    pub const fn number(&self) -> u64 {
+        self.0.number
+    }
+
+    /// Get the block hash.
+    pub const fn hash(&self) -> B256 {
+        self.0.hash
     }
 }
 
@@ -45,9 +62,9 @@ mod tests {
     #[test]
     fn test_block_number_hash_roundtrip() {
         let test_cases = vec![
-            BlockNumberHash(0, B256::ZERO),
-            BlockNumberHash(42, B256::repeat_byte(0xaa)),
-            BlockNumberHash(u64::MAX, B256::repeat_byte(0xff)),
+            BlockNumberHash::new(0, B256::ZERO),
+            BlockNumberHash::new(42, B256::repeat_byte(0xaa)),
+            BlockNumberHash::new(u64::MAX, B256::repeat_byte(0xff)),
         ];
 
         for original in test_cases {

crates/optimism/trie/src/db/models/block.rs

@@ -44,7 +44,7 @@ impl MdbxProofsStorage {
         let result = self.env.view(|tx| {
             let mut cursor = tx.cursor_read::<ProofWindow>().ok()?;
             let value = cursor.seek_exact(key).ok()?;
-            value.map(|(_, val)| (val.0, val.1))
+            value.map(|(_, val)| (val.number(), val.hash()))
         });
         Ok(result?)
     }
@@ -56,7 +56,8 @@ impl MdbxProofsStorage {
     ) -> OpProofsStorageResult<()> {
         self.env.update(|tx| {
             let mut cursor = tx.new_cursor::<ProofWindow>()?;
-            cursor.append(ProofWindowKey::EarliestBlock, &BlockNumberHash(block_number, hash))?;
+            cursor
+                .append(ProofWindowKey::EarliestBlock, &BlockNumberHash::new(block_number, hash))?;
             Ok(())
         })?
     }