feat(etherscan): Add get_block_by_timestamp to ethers-etherscan

ethers-etherscan/src/blocks.rs

@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+use std::str::FromStr;
+
+use ethers_core::types::BlockNumber;
+use serde::{Deserialize, Serialize};
+
+use crate::{Client, EtherscanError, Response, Result};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct BlockNumberByTimestamp {
+    pub timestamp: u64,
+    pub block_number: BlockNumber,
+}
+
+
+impl Client {
+    /// Returns either (1) the oldest block since a particular timestamp occurred or (2) the newest
+    /// block that occurred prior to that timestamp
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # async fn foo(client: ethers_etherscan::Client) -> Result<(), Box<dyn std::error::Error>> {
+    /// // The newest block that occurred prior to 1 January 2020
+    /// let block_number_before = client.get_block_by_timestamp(1577836800, "before");
+    /// // The oldest block that occurred after 1 January 2020
+    /// let block_number_after = client.get_block_by_timestamp(1577836800, "after");
+    /// # Ok(()) }
+    /// ```
+    pub async fn get_block_by_timestamp(&self, timestamp: u64, closest: &str) -> Result<BlockNumberByTimestamp> {
+        let query = self.create_query(
+            "block",
+            "getblocknobytime",
+            HashMap::from([("timestamp", timestamp.to_string()), ("closest", closest.to_string())]),
+        );
+        let response: Response<String> = self.get_json(&query).await?;
+
+        match response.status.as_str() {
+            "0" => Err(EtherscanError::BlockNumberByTimestampFailed),
+            "1" => Ok(
+                BlockNumberByTimestamp{
+                    timestamp: timestamp,
+                    block_number: response.result.parse::<BlockNumber>().unwrap()
+                }
+            ),
+            err => Err(EtherscanError::BadStatusCode(err.to_string())),
+        }
+    }
+}

ethers-etherscan/src/errors.rs

@@ -9,6 +9,8 @@ pub enum EtherscanError {
     ExecutionFailed(String),
     #[error("Balance failed")]
     BalanceFailed,
+    #[error("Block by timestamp failed")]
+    BlockNumberByTimestampFailed,
     #[error("Transaction receipt failed")]
     TransactionReceiptFailed,
     #[error("Gas estimation failed")]

ethers-etherscan/src/lib.rs

@@ -20,6 +20,7 @@ use std::{
 use tracing::{error, trace};
 
 pub mod account;
+pub mod blocks;
 pub mod contract;
 pub mod errors;
 pub mod gas;

ethers-etherscan/tests/it/blocks.rs

@@ -0,0 +1,41 @@
+use ethers_core::types::BlockNumber;
+use serial_test::serial;
+
+use crate::*;
+
+#[tokio::test]
+#[serial]
+async fn check_get_block_by_timestamp_before() {
+    run_with_client(Chain::Mainnet, |client| async move {
+        let block_no = client
+            .get_block_by_timestamp(
+                1577836800,
+                "before"
+            )
+            .await;
+        assert!(block_no.is_ok());
+
+        // let block_no = block_no.result;
+        let block_no = block_no.unwrap().block_number;
+        assert_eq!(block_no, "9193265".parse::<BlockNumber>().unwrap());
+    })
+    .await
+}
+
+#[tokio::test]
+#[serial]
+async fn check_get_block_by_timestamp_after() {
+    run_with_client(Chain::Mainnet, |client| async move {
+        let block_no = client
+            .get_block_by_timestamp(
+                1577836800,
+                "after"
+            )
+            .await;
+        // assert!(block_no.is_ok());
+
+        let block_no = block_no.unwrap().block_number;
+        assert_eq!(block_no, "9193266".parse::<BlockNumber>().unwrap());
+    })
+    .await
+}

ethers-etherscan/tests/it/main.rs

@@ -10,6 +10,7 @@ use std::{
 };
 
 mod account;
+mod blocks;
 mod contract;
 mod gas;
 mod transaction;