chain/ethereum: migrate load_block_ptrs_by_numbers_rpc call to use alloy

Author: incrypto32

chain/ethereum/src/ethereum_adapter.rs

@@ -837,10 +837,10 @@ impl EthereumAdapter {
         logger: Logger,
         numbers: Vec<BlockNumber>,
     ) -> impl futures03::Stream<Item = Result<Arc<ExtendedBlockPtr>, Error>> + Send {
-        let web3 = self.web3.clone();
+        let alloy = self.alloy.clone();
 
         futures03::stream::iter(numbers.into_iter().map(move |number| {
-            let web3 = web3.clone();
+            let alloy = alloy.clone();
             let logger = logger.clone();
 
             async move {
@@ -849,21 +849,22 @@ impl EthereumAdapter {
                     .limit(ENV_VARS.request_retries)
                     .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
                     .run(move || {
-                        let web3 = web3.clone();
+                        let alloy = alloy.cheap_clone();
 
                         async move {
-                            let block_result = web3
-                                .eth()
-                                .block(BlockId::Number(Web3BlockNumber::Number(number.into())))
+                            let block_result = alloy
+                                .get_block_by_number(alloy_rpc_types::BlockNumberOrTag::Number(
+                                    number as u64,
+                                ))
                                 .await;
 
                             match block_result {
                                 Ok(Some(block)) => {
                                     let ptr = ExtendedBlockPtr::try_from((
-                                        block.hash,
-                                        block.number,
-                                        block.parent_hash,
-                                        block.timestamp,
+                                        block.header.hash,
+                                        block.header.number as i32,
+                                        block.header.parent_hash,
+                                        block.header.timestamp,
                                     ))
                                     .map_err(|e| {
                                         anyhow::anyhow!("Failed to convert block: {}", e)

graph/src/blockchain/types.rs

@@ -95,6 +95,12 @@ impl From<Vec<u8>> for BlockHash {
     }
 }
 
+impl From<alloy::primitives::B256> for BlockHash {
+    fn from(hash: alloy::primitives::B256) -> Self {
+        BlockHash(hash.0.to_vec().into())
+    }
+}
+
 impl TryFrom<&str> for BlockHash {
     type Error = anyhow::Error;
 
@@ -510,6 +516,28 @@ impl TryFrom<(H256, i32, H256, U256)> for ExtendedBlockPtr {
         })
     }
 }
+
+impl TryFrom<(alloy::primitives::B256, i32, alloy::primitives::B256, u64)> for ExtendedBlockPtr {
+    type Error = anyhow::Error;
+
+    fn try_from(
+        tuple: (alloy::primitives::B256, i32, alloy::primitives::B256, u64),
+    ) -> Result<Self, Self::Error> {
+        let (hash, block_number, parent_hash, timestamp) = tuple;
+
+        // Convert timestamp to `BlockTime`
+        let secs =
+            i64::try_from(timestamp).map_err(|_| anyhow!("Timestamp out of range for i64"))?;
+        let block_time = BlockTime::since_epoch(secs, 0);
+
+        Ok(ExtendedBlockPtr {
+            hash: hash.into(),
+            number: block_number,
+            parent_hash: parent_hash.into(),
+            timestamp: block_time,
+        })
+    }
+}
 impl From<ExtendedBlockPtr> for H256 {
     fn from(ptr: ExtendedBlockPtr) -> Self {
         ptr.hash_as_h256()