graph, chain/ethereum: Use AnyNetwork with concrete AlloyProvider type

Author: incrypto32

chain/ethereum/src/adapter.rs

@@ -1,14 +1,14 @@
 use anyhow::Error;
 use graph::abi;
 use graph::blockchain::ChainIdentifier;
+use graph::components::ethereum::AnyBlock;
 use graph::components::subgraph::MappingError;
 use graph::data::store::ethereum::call;
 use graph::data_source::common::ContractCall;
 use graph::firehose::CallToFilter;
 use graph::firehose::CombinedFilter;
 use graph::firehose::LogFilter;
 use graph::prelude::alloy::primitives::{Address, B256};
-use graph::prelude::alloy::rpc::types::Block as AlloyBlock;
 use graph::prelude::alloy::rpc::types::Log;
 use graph::prelude::alloy::transports::{RpcError, TransportErrorKind};
 use itertools::Itertools;
@@ -1118,19 +1118,19 @@ pub trait EthereumAdapter: Send + Sync + 'static {
         &self,
         logger: &Logger,
         block_hash: B256,
-    ) -> Result<Option<AlloyBlock>, Error>;
+    ) -> Result<Option<AnyBlock>, Error>;
 
     async fn block_by_number(
         &self,
         logger: &Logger,
         block_number: BlockNumber,
-    ) -> Result<Option<AlloyBlock>, Error>;
+    ) -> Result<Option<AnyBlock>, Error>;
 
     /// Load full information for the specified `block` (in particular, transaction receipts).
     async fn load_full_block(
         &self,
         logger: &Logger,
-        block: AlloyBlock,
+        block: AnyBlock,
     ) -> Result<EthereumBlock, bc::IngestorError>;
 
     /// Finds the hash and number of the lowest non-null block with height greater than or equal to

chain/ethereum/src/codec.rs

@@ -7,15 +7,15 @@ use graph::{
     blockchain::{
         self, Block as BlockchainBlock, BlockPtr, BlockTime, ChainStoreBlock, ChainStoreData,
     },
+    components::ethereum::{AnyBlock, AnyHeader, AnyRpcHeader, AnyRpcTransaction, AnyTxEnvelope},
     prelude::{
         alloy::{
             self,
-            consensus::{ReceiptEnvelope, ReceiptWithBloom, TxEnvelope, TxType},
+            consensus::{ReceiptWithBloom, TxEnvelope, TxType},
+            network::AnyReceiptEnvelope,
             primitives::{aliases::B2048, Address, Bloom, Bytes, LogData, B256, U256},
-            rpc::types::{
-                AccessList, AccessListItem, Block as AlloyBlock, Transaction,
-                TransactionReceipt as AlloyTransactionReceipt,
-            },
+            rpc::types::{self as alloy_rpc_types, AccessList, AccessListItem, Transaction},
+            serde::WithOtherFields,
         },
         BlockNumber, Error, EthereumBlock, EthereumBlockWithCalls, EthereumCall,
         LightEthereumBlock,
@@ -378,10 +378,10 @@ impl TryInto<BlockFinality> for &Block {
     }
 }
 
-impl TryInto<AlloyBlock> for &Block {
+impl TryInto<AnyBlock> for &Block {
     type Error = Error;
 
-    fn try_into(self) -> Result<AlloyBlock, Self::Error> {
+    fn try_into(self) -> Result<AnyBlock, Self::Error> {
         let header = self.header();
 
         let block_hash = self.hash.try_decode_proto("block hash")?;
@@ -466,19 +466,31 @@ impl TryInto<AlloyBlock> for &Block {
             .map(|u| u.hash.try_decode_proto("uncle hash"))
             .collect::<Result<Vec<B256>, _>>()?;
 
-        Ok(AlloyBlock::new(
-            rpc_header,
-            alloy::rpc::types::BlockTransactions::Full(transactions),
-        )
-        .with_uncles(uncles))
+        use alloy::rpc::types::Block;
+
+        let any_header: AnyRpcHeader = rpc_header.map(AnyHeader::from);
+
+        let any_transactions: Vec<AnyRpcTransaction> = transactions
+            .into_iter()
+            .map(|tx| AnyRpcTransaction::new(WithOtherFields::new(tx.map(AnyTxEnvelope::Ethereum))))
+            .collect();
+
+        let any_block = Block {
+            header: any_header,
+            transactions: alloy::rpc::types::BlockTransactions::Full(any_transactions),
+            uncles,
+            withdrawals: None,
+        };
+
+        Ok(AnyBlock::new(WithOtherFields::new(any_block)))
     }
 }
 
 impl TryInto<EthereumBlockWithCalls> for &Block {
     type Error = Error;
 
     fn try_into(self) -> Result<EthereumBlockWithCalls, Self::Error> {
-        let alloy_block: AlloyBlock = self.try_into()?;
+        let alloy_block: AnyBlock = self.try_into()?;
 
         let transaction_receipts = self
             .transaction_traces
@@ -494,7 +506,7 @@ impl TryInto<EthereumBlockWithCalls> for &Block {
         #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(LightEthereumBlock::new(alloy_block.into())),
+                block: Arc::new(LightEthereumBlock::new(alloy_block)),
                 transaction_receipts,
             },
             // Comment (437a9f17-67cc-478f-80a3-804fe554b227): This Some() will avoid calls in the triggers_in_block
@@ -521,7 +533,7 @@ impl TryInto<EthereumBlockWithCalls> for &Block {
 fn transaction_trace_to_alloy_txn_reciept(
     t: &TransactionTrace,
     block: &Block,
-) -> Result<Option<AlloyTransactionReceipt<ReceiptEnvelope<alloy::rpc::types::Log>>>, Error> {
+) -> Result<Option<alloy::network::AnyTransactionReceipt>, Error> {
     use alloy::consensus::{Eip658Value, Receipt};
     let r = t.receipt.as_ref();
 
@@ -600,15 +612,20 @@ fn transaction_trace_to_alloy_txn_reciept(
         )
     })?;
 
-    let envelope = match tx_type {
-        TxType::Legacy => ReceiptEnvelope::Legacy(receipt_with_bloom),
-        TxType::Eip2930 => ReceiptEnvelope::Eip2930(receipt_with_bloom),
-        TxType::Eip1559 => ReceiptEnvelope::Eip1559(receipt_with_bloom),
-        TxType::Eip4844 => ReceiptEnvelope::Eip4844(receipt_with_bloom),
-        TxType::Eip7702 => ReceiptEnvelope::Eip7702(receipt_with_bloom),
+    let ty = match tx_type {
+        TxType::Legacy => 0,
+        TxType::Eip2930 => 1,
+        TxType::Eip1559 => 2,
+        TxType::Eip4844 => 3,
+        TxType::Eip7702 => 4,
+    };
+
+    let any_envelope = AnyReceiptEnvelope {
+        inner: receipt_with_bloom,
+        r#type: ty,
     };
 
-    Ok(Some(AlloyTransactionReceipt {
+    let receipt = alloy_rpc_types::TransactionReceipt {
         transaction_hash: t.hash.try_decode_proto("transaction hash")?,
         transaction_index: Some(t.index as u64),
         block_hash: Some(block.hash.try_decode_proto("transaction block hash")?),
@@ -626,8 +643,10 @@ fn transaction_trace_to_alloy_txn_reciept(
             let val: U256 = x.into();
             val.to::<u128>()
         }),
-        inner: envelope,
-    }))
+        inner: any_envelope,
+    };
+
+    Ok(Some(WithOtherFields::new(receipt)))
 }
 
 impl BlockHeader {