refactor: move BlockHashOrNumber to primitives (#203)

crates/primitives/src/block.rs

@@ -1,4 +1,5 @@
 use crate::{Header, Receipt, SealedHeader, Transaction, TransactionSigned, H256};
+use reth_rlp::{Decodable, DecodeError, Encodable};
 use std::ops::Deref;
 
 /// Ethereum full block.
@@ -47,3 +48,62 @@ impl Deref for BlockLocked {
         self.header.as_ref()
     }
 }
+
+/// Either a block hash _or_ a block number
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum BlockHashOrNumber {
+    /// A block hash
+    Hash(H256),
+    /// A block number
+    Number(u64),
+}
+
+impl From<H256> for BlockHashOrNumber {
+    fn from(value: H256) -> Self {
+        BlockHashOrNumber::Hash(value)
+    }
+}
+
+impl From<u64> for BlockHashOrNumber {
+    fn from(value: u64) -> Self {
+        BlockHashOrNumber::Number(value)
+    }
+}
+
+/// Allows for RLP encoding of either a block hash or block number
+impl Encodable for BlockHashOrNumber {
+    fn length(&self) -> usize {
+        match self {
+            Self::Hash(block_hash) => block_hash.length(),
+            Self::Number(block_number) => block_number.length(),
+        }
+    }
+    fn encode(&self, out: &mut dyn bytes::BufMut) {
+        match self {
+            Self::Hash(block_hash) => block_hash.encode(out),
+            Self::Number(block_number) => block_number.encode(out),
+        }
+    }
+}
+
+/// Allows for RLP decoding of a block hash or block number
+impl Decodable for BlockHashOrNumber {
+    fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
+        let header: u8 = *buf.first().ok_or(DecodeError::InputTooShort)?;
+        // if the byte string is exactly 32 bytes, decode it into a Hash
+        // 0xa0 = 0x80 (start of string) + 0x20 (32, length of string)
+        if header == 0xa0 {
+            // strip the first byte, parsing the rest of the string.
+            // If the rest of the string fails to decode into 32 bytes, we'll bubble up the
+            // decoding error.
+            let hash = H256::decode(buf)?;
+            Ok(Self::Hash(hash))
+        } else {
+            // a block number when encoded as bytes ranges from 0 to any number of bytes - we're
+            // going to accept numbers which fit in less than 64 bytes.
+            // Any data larger than this which is not caught by the Hash decoding should error and
+            // is considered an invalid block number.
+            Ok(Self::Number(u64::decode(buf)?))
+        }
+    }
+}

crates/primitives/src/lib.rs

@@ -29,7 +29,7 @@ mod transaction;
 pub mod proofs;
 
 pub use account::Account;
-pub use block::{Block, BlockLocked};
+pub use block::{Block, BlockHashOrNumber, BlockLocked};
 pub use chain::Chain;
 pub use constants::MAINNET_GENESIS;
 pub use forkid::{ForkFilter, ForkHash, ForkId, ValidationError};