Remove unneccessary conversion functions

incrypto32 · incrypto32 · commit 71b59f07dea9 · 2025-07-02T17:27:59.000+05:30
diff --git a/chain/ethereum/src/adapter.rs b/chain/ethereum/src/adapter.rs
@@ -1159,7 +1159,7 @@ pub trait EthereumAdapter: Send + Sync + 'static {
         logger: Logger,
         chain_store: Arc<dyn ChainStore>,
         block_hashes: HashSet<B256>,
-    ) -> Result<Vec<Arc<AlloyBlock>>, Error>;
+    ) -> Result<Vec<Arc<LightEthereumBlock>>, Error>;
 
     /// Find a block by its hash.
     async fn block_by_hash(
diff --git a/chain/ethereum/src/ethereum_adapter.rs b/chain/ethereum/src/ethereum_adapter.rs
@@ -20,7 +20,6 @@ use graph::futures03::future::try_join_all;
 use graph::futures03::{
     self, compat::Future01CompatExt, FutureExt, StreamExt, TryFutureExt, TryStreamExt,
 };
-use graph::prelude::alloy::consensus::BlockHeader;
 use graph::prelude::alloy::primitives::Address;
 use graph::prelude::alloy::rpc::types::Transaction;
 use graph::prelude::{
@@ -45,8 +44,6 @@ use graph::prelude::{
 use graph::slog::o;
 use graph::tokio::sync::RwLock;
 use graph::tokio::time::timeout;
-use graph::util::conversions::alloy_block_to_block;
-use graph::util::conversions::alloy_block_to_block_arc;
 use graph::{
     blockchain::{block_stream::BlockWithTriggers, BlockPtr, IngestorError},
     prelude::{
@@ -718,7 +715,7 @@ impl EthereumAdapter {
         &self,
         logger: Logger,
         ids: Vec<B256>,
-    ) -> impl futures03::Stream<Item = Result<Arc<AlloyBlock>, Error>> + Send {
+    ) -> impl futures03::Stream<Item = Result<Arc<LightEthereumBlock>, Error>> + Send {
         let alloy = self.alloy.clone();
 
         futures03::stream::iter(ids.into_iter().map(move |hash| {
@@ -739,12 +736,14 @@ impl EthereumAdapter {
                                 .await
                                 .map_err(Error::from)
                                 .and_then(|block| {
-                                    block.map(Arc::new).ok_or_else(|| {
-                                        anyhow::anyhow!(
-                                            "Ethereum node did not find block {:?}",
-                                            hash
-                                        )
-                                    })
+                                    block
+                                        .map(|b| Arc::new(LightEthereumBlock::new(b)))
+                                        .ok_or_else(|| {
+                                            anyhow::anyhow!(
+                                                "Ethereum node did not find block {:?}",
+                                                hash
+                                            )
+                                        })
                                 })
                         }
                     })
@@ -1340,7 +1339,7 @@ impl EthereumAdapterTrait for EthereumAdapter {
         if block.transactions.is_empty() {
             trace!(logger, "Block {} contains no transactions", block_hash);
             return Ok(EthereumBlock {
-                block: Arc::new(alloy_block_to_block(block)),
+                block: Arc::new(LightEthereumBlock::new(block)),
                 transaction_receipts: Vec::new(),
             });
         }
@@ -1359,7 +1358,7 @@ impl EthereumAdapterTrait for EthereumAdapter {
         fetch_receipts_with_retry(alloy, hashes, block_hash, logger, supports_block_receipts)
             .await
             .map(|transaction_receipts| EthereumBlock {
-                block: Arc::new(alloy_block_to_block(block)),
+                block: Arc::new(LightEthereumBlock::new(block)),
                 transaction_receipts: transaction_receipts
                     .into_iter()
                     .map(|receipt| receipt)
@@ -1611,35 +1610,35 @@ impl EthereumAdapterTrait for EthereumAdapter {
         logger: Logger,
         chain_store: Arc<dyn ChainStore>,
         block_hashes: HashSet<B256>,
-    ) -> Result<Vec<Arc<AlloyBlock>>, Error> {
+    ) -> Result<Vec<Arc<LightEthereumBlock>>, Error> {
         let block_hashes: Vec<_> = block_hashes.iter().cloned().collect();
         // Search for the block in the store first then use json-rpc as a backup.
-        let mut blocks: Vec<Arc<AlloyBlock>> = chain_store
+        let mut blocks: Vec<_> = chain_store
             .cheap_clone()
             .blocks(block_hashes.iter().map(|&b| b.into()).collect::<Vec<_>>())
             .await
             .map_err(|e| error!(&logger, "Error accessing block cache {}", e))
             .unwrap_or_default()
             .into_iter()
             .filter_map(|value| json::from_value(value).ok())
-            .map(Arc::new)
+            .map(|b| Arc::new(LightEthereumBlock::new(b)))
             .collect();
 
         let missing_blocks = Vec::from_iter(
             block_hashes
                 .into_iter()
-                .filter(|hash| !blocks.iter().any(|b| b.header.hash == *hash)),
+                .filter(|hash| !blocks.iter().any(|b| b.hash() == *hash)),
         );
 
         // Return a stream that lazily loads batches of blocks.
         debug!(logger, "Requesting {} block(s)", missing_blocks.len());
-        let new_blocks: Vec<Arc<AlloyBlock>> = self
+        let new_blocks: Vec<_> = self
             .load_blocks_rpc(logger.clone(), missing_blocks)
             .try_collect()
             .await?;
         let upsert_blocks: Vec<_> = new_blocks
             .iter()
-            .map(|block| BlockFinality::Final(alloy_block_to_block_arc(block.clone())))
+            .map(|block| BlockFinality::Final(block.clone()))
             .collect();
         let block_refs: Vec<_> = upsert_blocks
             .iter()
@@ -1649,7 +1648,7 @@ impl EthereumAdapterTrait for EthereumAdapter {
             error!(logger, "Error writing to block cache {}", e);
         }
         blocks.extend(new_blocks);
-        blocks.sort_by_key(|block| block.header.number);
+        blocks.sort_by_key(|block| block.number());
         Ok(blocks)
     }
 }
@@ -1792,15 +1791,15 @@ pub(crate) async fn blocks_with_triggers(
         .await?
         .into_iter()
         .map(
-            move |block| match triggers_by_block.remove(&(block.header.number() as BlockNumber)) {
+            move |block| match triggers_by_block.remove(&(block.number())) {
                 Some(triggers) => Ok(BlockWithTriggers::new(
-                    BlockFinality::Final(alloy_block_to_block_arc(block)),
+                    BlockFinality::Final(block),
                     triggers,
                     &logger2,
                 )),
                 None => Err(anyhow!(
                     "block {} not found in `triggers_by_block`",
-                    BlockPtr::new(block.header.hash.into(), block.header.number as i32)
+                    block.block_ptr()
                 )),
             },
         )
@@ -2612,12 +2611,11 @@ mod tests {
         EthereumBlockWithCalls,
     };
     use graph::blockchain::BlockPtr;
-    use graph::components::ethereum::BlockWrapper;
     use graph::prelude::alloy::primitives::{Address, Bytes, B256};
     use graph::prelude::alloy::providers::mock::Asserter;
     use graph::prelude::alloy::providers::ProviderBuilder;
     use graph::prelude::tokio::{self};
-    use graph::prelude::{create_minimal_block_for_test, EthereumCall};
+    use graph::prelude::{create_minimal_block_for_test, EthereumCall, LightEthereumBlock};
     use jsonrpc_core::serde_json::{self, Value};
     use std::collections::HashSet;
     use std::iter::FromIterator;
@@ -2627,10 +2625,9 @@ mod tests {
     fn parse_block_triggers_every_block() {
         let block = create_minimal_block_for_test(2, hash(2));
 
-        #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(BlockWrapper::new(block)),
+                block: Arc::new(LightEthereumBlock::new(block)),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {
@@ -2772,7 +2769,7 @@ mod tests {
         #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(BlockWrapper::new(block)),
+                block: Arc::new(LightEthereumBlock::new(block)),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {
@@ -2803,7 +2800,7 @@ mod tests {
         #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(BlockWrapper::new(block)),
+                block: Arc::new(LightEthereumBlock::new(block)),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {
diff --git a/chain/ethereum/src/tests.rs b/chain/ethereum/src/tests.rs
@@ -124,7 +124,7 @@ fn test_trigger_ordering() {
 
     let b = Block::default();
 
-    let b = BlockWrapper::new(b);
+    let b = LightEthereumBlock::new(b);
 
     // Test that `BlockWithTriggers` sorts the triggers.
     let block_with_triggers = BlockWithTriggers::<crate::Chain>::new(
@@ -204,7 +204,7 @@ fn test_trigger_dedup() {
     let b = Block::default();
 
     #[allow(unreachable_code)]
-    let b = BlockWrapper::new(b);
+    let b = LightEthereumBlock::new(b);
 
     // Test that `BlockWithTriggers` sorts the triggers.
     let block_with_triggers = BlockWithTriggers::<crate::Chain>::new(
diff --git a/graph/src/util/conversions.rs b/graph/src/util/conversions.rs
@@ -1,127 +1,14 @@
-use std::sync::Arc;
-
-use web3::types::Bytes;
-
-use crate::components::ethereum::BlockWrapper;
-use crate::prelude::alloy::primitives::{Address as AlloyAddress, B256};
-use crate::prelude::alloy::rpc::types::{
-    Block as AlloyBlock, Log as AlloyLog, TransactionReceipt as AlloyTransactionReceipt,
-};
 /// Type conversion utilities between web3 and alloy types
-use crate::prelude::web3::types::{
-    Address as Web3Address, Block as Web3Block, Log as Web3Log, Transaction as Web3Transaction,
-    TransactionReceipt as Web3TransactionReceipt, H160, H256, U256, U64,
-};
-
-/// Converts H256 to alloy B256
-pub fn h256_to_b256(h: H256) -> B256 {
-    B256::from_slice(h.as_bytes())
-}
-
-/// Converts alloy B256 to H256
-pub fn b256_to_h256(b: B256) -> H256 {
-    H256::from_slice(b.as_slice())
-}
-
-pub fn web3_u64_from_option(opt: Option<u64>) -> U64 {
-    U64::from(opt.unwrap_or(0))
-}
-
-pub fn u64_to_web3_u256(u: u64) -> U256 {
-    U256::from(u)
-}
-
-pub fn bool_to_web3_u64(b: bool) -> U64 {
-    U64::from(if b { 1 } else { 0 })
-}
-
-pub fn u64_to_web3_u64(u: u64) -> U64 {
-    U64::from(u)
-}
-/// Converts web3 H160 to alloy Address
-pub fn h160_to_alloy_address(h: H160) -> AlloyAddress {
-    AlloyAddress::from_slice(h.as_bytes())
-}
-
-/// Converts alloy Address to web3 H160
-pub fn alloy_address_to_h160(addr: AlloyAddress) -> H160 {
-    H160::from_slice(addr.as_slice())
-}
-
-/// Converts web3 Address to alloy Address
-pub fn web3_address_to_alloy_address(addr: Web3Address) -> AlloyAddress {
-    h160_to_alloy_address(addr)
-}
-
-/// Converts alloy Address to web3 Address
-pub fn alloy_address_to_web3_address(addr: AlloyAddress) -> Web3Address {
-    alloy_address_to_h160(addr)
-}
+use crate::prelude::web3::types::U256;
 
 // u256 to web3 U256
 pub fn alloy_u256_to_web3_u256(_u: alloy::primitives::U256) -> U256 {
     unimplemented!();
 }
 
-pub fn alloy_bytes_to_web3_bytes(_b: alloy::primitives::Bytes) -> Bytes {
-    unimplemented!();
-}
-
-// u256 to alloy U256
-pub fn web3_u256_to_alloy_u256(u: U256) -> U256 {
-    U256::from(u)
-}
-
-/// Converts alloy Log to web3 Log
-pub fn alloy_log_to_web3_log(log: AlloyLog) -> Web3Log {
-    Web3Log {
-        address: alloy_address_to_h160(log.address()),
-        topics: log.topics().iter().map(|t| b256_to_h256(*t)).collect(),
-        data: log.data().data.clone().into(),
-        block_hash: log.block_hash.map(b256_to_h256),
-        block_number: log.block_number.map(|n| U64::from(n)),
-        transaction_hash: log.transaction_hash.map(b256_to_h256),
-        transaction_index: log.transaction_index.map(|i| U64::from(i)),
-        log_index: log.log_index.map(|i| U256::from(i)),
-        transaction_log_index: None, // alloy Log doesn't have transaction_log_index
-        log_type: None,              // alloy Log doesn't have log_type
-        removed: Some(log.removed),
-    }
-}
-
-pub fn alloy_log_ref_to_web3_log_ref(_log: &AlloyLog) -> &Web3Log {
-    unimplemented!()
-}
-
 #[macro_export]
 macro_rules! alloy_todo {
     () => {
         todo!()
     };
 }
-
-pub fn alloy_transaction_receipt_to_web3_transaction_receipt(
-    _receipt: Arc<AlloyTransactionReceipt>,
-) -> Arc<Web3TransactionReceipt> {
-    unimplemented!("TransactionReceipt conversion not yet implemented - will be done when needed")
-}
-
-/// Converts alloy Block to web3 Block
-pub fn alloy_block_to_block_arc(_block: Arc<AlloyBlock>) -> Arc<BlockWrapper> {
-    unimplemented!(
-        "Block conversion from alloy to web3 not yet implemented - will be done when needed"
-    )
-}
-
-pub fn alloy_block_to_block(_block: AlloyBlock) -> BlockWrapper {
-    unimplemented!(
-        "Block conversion from alloy to web3 not yet implemented - will be done when needed"
-    )
-}
-
-/// Converts web3 Block to alloy Block
-pub fn web3_block_to_alloy_block(_block: Web3Block<Web3Transaction>) -> AlloyBlock {
-    unimplemented!(
-        "Block conversion from web3 to alloy not yet implemented - will be done when needed"
-    )
-}
diff --git a/node/src/manager/commands/chain.rs b/node/src/manager/commands/chain.rs
@@ -12,9 +12,9 @@ use graph::components::store::ChainIdStore;
 use graph::components::store::StoreError;
 use graph::prelude::BlockNumber;
 use graph::prelude::ChainStore as _;
+use graph::prelude::LightEthereumBlock;
 use graph::prelude::{anyhow, anyhow::bail};
 use graph::slog::Logger;
-use graph::util::conversions::alloy_block_to_block;
 use graph::{
     components::store::BlockStore as _, components::store::ChainHeadStore as _,
     prelude::anyhow::Error,
@@ -279,7 +279,9 @@ pub async fn ingest(
     let hash = block.header.hash;
     let number = block.header.number;
     // For inserting the block, it doesn't matter whether the block is final or not.
-    let block = Arc::new(BlockFinality::Final(Arc::new(alloy_block_to_block(block))));
+    let block = Arc::new(BlockFinality::Final(Arc::new(LightEthereumBlock::new(
+        block,
+    ))));
     chain_store.upsert_block(block).await?;
 
     let hash = hash.into();
diff --git a/store/test-store/src/block_store.rs b/store/test-store/src/block_store.rs
@@ -1,10 +1,10 @@
 use std::{convert::TryFrom, str::FromStr, sync::Arc};
 
 use graph::blockchain::{BlockTime, ChainIdentifier};
-use graph::components::ethereum::BlockWrapper;
 use graph::prelude::alloy::consensus::Header as ConsensusHeader;
 use graph::prelude::alloy::primitives::{Bloom, B256, U256};
 use graph::prelude::alloy::rpc::types::{Block, Header};
+use graph::prelude::LightEthereumBlock;
 use lazy_static::lazy_static;
 
 use graph::components::store::BlockStore;
@@ -125,7 +125,7 @@ impl FakeBlock {
         let block = Block::empty(rpc_header);
 
         EthereumBlock {
-            block: Arc::new(BlockWrapper::new(block)),
+            block: Arc::new(LightEthereumBlock::new(block)),
             transaction_receipts: Vec::new(),
         }
     }
diff --git a/tests/src/fixture/ethereum.rs b/tests/src/fixture/ethereum.rs
diff --git a/tests/tests/integration_tests.rs b/tests/tests/integration_tests.rs
