feat: add support for eth_getBlockByNumber to client

Cargo.toml

@@ -50,6 +50,7 @@ zeroize = { version = "1.8", features = ["zeroize_derive"] }
 regex = "1.11"
 
 [dev-dependencies]
+alloy-consensus = { workspace = true }
 alloy-primitives = { workspace = true }
 alloy-rpc-types = { workspace = true }
 assert_matches = { workspace = true }
@@ -67,6 +68,7 @@ rand = "0.8"
 tokio = "1.44.1"
 
 [workspace.dependencies]
+alloy-consensus = "1.0.26"
 alloy-primitives = "1.3.0"
 alloy-rpc-types = "1.0.23"
 assert_matches = "1.5.0"

evm_rpc_client/Cargo.toml

@@ -22,4 +22,4 @@ serde = { workspace = true }
 strum = { workspace = true }
 
 [dev-dependencies]
-tokio = { workspace = true, features = ["full"] }
+tokio = { workspace = true, features = ["full"] }

evm_rpc_client/src/lib.rs

@@ -183,9 +183,11 @@ pub mod fixtures;
 mod request;
 mod runtime;
 
-use crate::request::{Request, RequestBuilder};
+use crate::request::{
+    GetBlockByNumberRequest, GetBlockByNumberRequestBuilder, Request, RequestBuilder,
+};
 use candid::{CandidType, Principal};
-use evm_rpc_types::{ConsensusStrategy, GetLogsArgs, RpcConfig, RpcServices};
+use evm_rpc_types::{BlockTag, ConsensusStrategy, GetLogsArgs, RpcConfig, RpcServices};
 use ic_error_types::RejectCode;
 use request::{GetLogsRequest, GetLogsRequestBuilder};
 pub use runtime::{IcRuntime, Runtime};
@@ -319,6 +321,67 @@ impl<R> ClientBuilder<R> {
 }
 
 impl<R> EvmRpcClient<R> {
+    /// Call `eth_getBlockByNumber` on the EVM RPC canister.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use alloy_primitives::{address, b256, bytes};
+    /// use alloy_rpc_types::BlockNumberOrTag;
+    /// use evm_rpc_client::EvmRpcClient;
+    ///
+    /// # use evm_rpc_types::{Block, Hex, Hex20, Hex32, Hex256, MultiRpcResult, Nat256};
+    /// # use std::str::FromStr;
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let client = EvmRpcClient::builder_for_ic()
+    /// #   .with_default_stub_response(MultiRpcResult::Consistent(Ok(Block {
+    /// #       base_fee_per_gas: None,
+    /// #       number: Nat256::ZERO,
+    /// #       difficulty: Some(Nat256::ZERO),
+    /// #       extra_data: Hex::from(vec![]),
+    /// #       gas_limit: Nat256::ZERO,
+    /// #       gas_used: Nat256::ZERO,
+    /// #       hash: Hex32::from(b256!("0x47302c2ebfb29611c74f917a380f3cf45c9dfe9de3554e18bff9a9ca7c8454e2")),
+    /// #       logs_bloom: Hex256::from([0; 256]),
+    /// #       miner: Hex20::from([0; 20]),
+    /// #       mix_hash: Hex32::from([0; 32]),
+    /// #       nonce: Nat256::ZERO,
+    /// #       parent_hash: Hex32::from([0; 32]),
+    /// #       receipts_root: Hex32::from([0; 32]),
+    /// #       sha3_uncles: Hex32::from([0; 32]),
+    /// #       size: Nat256::ZERO,
+    /// #       state_root: Hex32::from([0; 32]),
+    /// #       timestamp: Nat256::ZERO,
+    /// #       total_difficulty: Some(Nat256::ZERO),
+    /// #       transactions: vec![],
+    /// #       transactions_root: Some(Hex32::from([0; 32])),
+    /// #       uncles: vec![],
+    /// #   })))
+    ///     .build();
+    ///
+    /// let result = client
+    ///     .get_block_by_number(BlockNumberOrTag::Number(23225439))
+    ///     .send()
+    ///     .await
+    ///     .expect_consistent()
+    ///     .unwrap();
+    ///
+    /// assert_eq!(result.hash(), b256!("0x47302c2ebfb29611c74f917a380f3cf45c9dfe9de3554e18bff9a9ca7c8454e2"));
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn get_block_by_number(
+        &self,
+        params: impl Into<BlockTag>,
+    ) -> GetBlockByNumberRequestBuilder<R> {
+        RequestBuilder::new(
+            self.clone(),
+            GetBlockByNumberRequest::new(params.into()),
+            10_000_000_000,
+        )
+    }
+
     /// Call `eth_getLogs` on the EVM RPC canister.
     ///
     /// # Examples
@@ -353,7 +416,6 @@ impl<R> EvmRpcClient<R> {
     ///
     /// let result = client
     ///     .get_logs(vec![address!("0xdac17f958d2ee523a2206206994597c13d831ec7")])
-    ///     .with_cycles(10_000_000_000)
     ///     .send()
     ///     .await
     ///     .expect_consistent();

evm_rpc_client/src/request/mod.rs

@@ -8,6 +8,38 @@ use serde::de::DeserializeOwned;
 use std::fmt::{Debug, Formatter};
 use strum::EnumIter;
 
+#[derive(Debug, Clone)]
+pub struct GetBlockByNumberRequest(BlockTag);
+
+impl GetBlockByNumberRequest {
+    pub fn new(params: BlockTag) -> Self {
+        Self(params)
+    }
+}
+
+impl EvmRpcRequest for GetBlockByNumberRequest {
+    type Config = RpcConfig;
+    type Params = BlockTag;
+    type CandidOutput = MultiRpcResult<evm_rpc_types::Block>;
+    type Output = MultiRpcResult<alloy_rpc_types::Block>;
+
+    fn endpoint(&self) -> EvmRpcEndpoint {
+        EvmRpcEndpoint::GetBlockByNumber
+    }
+
+    fn params(self) -> Self::Params {
+        self.0
+    }
+}
+
+pub type GetBlockByNumberRequestBuilder<R> = RequestBuilder<
+    R,
+    RpcConfig,
+    BlockTag,
+    MultiRpcResult<evm_rpc_types::Block>,
+    MultiRpcResult<alloy_rpc_types::Block>,
+>;
+
 #[derive(Debug, Clone)]
 pub struct GetLogsRequest(GetLogsArgs);
 
@@ -92,6 +124,8 @@ pub trait EvmRpcRequest {
 /// Endpoint on the EVM RPC canister triggering a call to EVM providers.
 #[derive(Clone, Debug, Ord, PartialOrd, Eq, PartialEq, EnumIter)]
 pub enum EvmRpcEndpoint {
+    /// `eth_getBlockByNumber` endpoint.
+    GetBlockByNumber,
     /// `eth_getLogs` endpoint.
     GetLogs,
 }
@@ -100,6 +134,7 @@ impl EvmRpcEndpoint {
     /// Method name on the EVM RPC canister
     pub fn rpc_method(&self) -> &'static str {
         match &self {
+            Self::GetBlockByNumber => "eth_getBlockByNumber",
             Self::GetLogs => "eth_getLogs",
         }
     }

evm_rpc_types/Cargo.toml

@@ -11,6 +11,7 @@ repository = "https://github.com/dfinity/evm-rpc-canister"
 documentation = "https://docs.rs/evm_rpc_types"
 
 [dependencies]
+alloy-consensus = { workspace = true, optional = true }
 alloy-primitives = { workspace = true, optional = true }
 alloy-rpc-types = { workspace = true, optional = true }
 candid = { workspace = true }
@@ -29,5 +30,8 @@ proptest = { workspace = true }
 serde_json = { workspace = true }
 
 [features]
-default = ["alloy"]
-alloy = ["dep:alloy-primitives", "dep:alloy-rpc-types"]
+alloy = [
+    "dep:alloy-consensus",
+    "dep:alloy-primitives",
+    "dep:alloy-rpc-types"
+]

evm_rpc_types/src/alloy.rs

@@ -1,4 +1,5 @@
-use crate::{Hex, Hex20, Hex32};
+use crate::{Hex, Hex20, Hex256, Hex32, Nat256, RpcError};
+use alloy_primitives::ruint::{ToUintError, UintTryFrom};
 
 impl From<Hex20> for alloy_primitives::Address {
     fn from(value: Hex20) -> Self {
@@ -35,3 +36,41 @@ impl From<alloy_primitives::Bytes> for Hex {
         Hex(value.to_vec())
     }
 }
+
+impl From<alloy_primitives::U256> for Nat256 {
+    fn from(value: alloy_primitives::U256) -> Self {
+        Nat256::from_be_bytes(value.to_be_bytes())
+    }
+}
+
+impl UintTryFrom<Nat256> for alloy_primitives::U256 {
+    fn uint_try_from(value: Nat256) -> Result<Self, ToUintError<Self>> {
+        Ok(alloy_primitives::U256::from_be_bytes(value.into_be_bytes()))
+    }
+}
+
+impl From<Hex256> for alloy_primitives::Bloom {
+    fn from(value: Hex256) -> Self {
+        alloy_primitives::Bloom::from(value.0)
+    }
+}
+
+impl From<alloy_primitives::Bloom> for Hex256 {
+    fn from(value: alloy_primitives::Bloom) -> Self {
+        Hex256::from(value.into_array())
+    }
+}
+
+impl TryFrom<Nat256> for alloy_primitives::B64 {
+    type Error = RpcError;
+
+    fn try_from(value: Nat256) -> Result<Self, Self::Error> {
+        Ok(alloy_primitives::B64::from(u64::try_from(value)?))
+    }
+}
+
+impl From<alloy_primitives::B64> for Nat256 {
+    fn from(value: alloy_primitives::B64) -> Self {
+        Nat256::from(u64::from(value))
+    }
+}