graph, chain/ethereum: Use AnyRpcBlock instead of Ethereum Specific Block

Author: incrypto32

chain/ethereum/src/codec.rs

@@ -298,11 +298,8 @@ impl<'a> TryInto<Transaction> for TransactionTraceAt<'a> {
                     .map(|hash| B256::from_slice(hash))
                     .collect();
 
-                let max_fee_per_blob_gas_u128 = self
-                    .trace
-                    .blob_gas_fee_cap
-                    .as_ref()
-                    .map_or(0u128, |x| {
+                let max_fee_per_blob_gas_u128 =
+                    self.trace.blob_gas_fee_cap.as_ref().map_or(0u128, |x| {
                         let val: U256 = x.into();
                         val.to::<u128>()
                     });
@@ -422,20 +419,28 @@ impl TryInto<AlloyBlock> for &Block {
             withdrawals_root: if header.withdrawals_root.is_empty() {
                 None
             } else {
-                Some(header.withdrawals_root.try_decode_proto("withdrawals root")?)
+                Some(
+                    header
+                        .withdrawals_root
+                        .try_decode_proto("withdrawals root")?,
+                )
             },
             blob_gas_used: header.blob_gas_used,
             excess_blob_gas: header.excess_blob_gas,
             parent_beacon_block_root: if header.parent_beacon_root.is_empty() {
                 None
             } else {
-                Some(header.parent_beacon_root.try_decode_proto("parent beacon root")?)
+                Some(
+                    header
+                        .parent_beacon_root
+                        .try_decode_proto("parent beacon root")?,
+                )
             },
             requests_hash: if header.requests_hash.is_empty() {
                 None
             } else {
                 Some(header.requests_hash.try_decode_proto("requests hash")?)
-            }
+            },
         };
 
         let rpc_header = alloy::rpc::types::Header {
@@ -489,7 +494,7 @@ impl TryInto<EthereumBlockWithCalls> for &Block {
         #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(LightEthereumBlock::new(alloy_block)),
+                block: Arc::new(LightEthereumBlock::new(alloy_block.into())),
                 transaction_receipts,
             },
             // Comment (437a9f17-67cc-478f-80a3-804fe554b227): This Some() will avoid calls in the triggers_in_block

chain/ethereum/src/data_source.rs

@@ -4,6 +4,7 @@ use graph::abi;
 use graph::abi::EventExt;
 use graph::abi::FunctionExt;
 use graph::blockchain::{BlockPtr, TriggerWithHandler};
+use graph::components::ethereum::AnyTransaction;
 use graph::components::link_resolver::LinkResolverContext;
 use graph::components::metrics::subgraph::SubgraphInstanceMetrics;
 use graph::components::store::{EthereumCallCache, StoredDynamicDataSource};
@@ -21,8 +22,9 @@ use graph::futures03::stream::FuturesOrdered;
 use graph::futures03::TryStreamExt;
 use graph::prelude::alloy::{
     consensus::{TxEnvelope, TxLegacy},
-    primitives::{Address, B256},
-    rpc::types::{Log, Transaction},
+    network::TransactionResponse,
+    primitives::{Address, B256, U256},
+    rpc::types::Log,
 };
 use graph::prelude::{alloy, Link, SubgraphManifestValidationError};
 use graph::slog::{debug, error, o, trace};
@@ -440,11 +442,12 @@ fn create_dummy_transaction(
     block_hash: B256,
     transaction_index: Option<u64>,
     transaction_hash: Option<B256>,
-) -> Result<Transaction<TxEnvelope>, anyhow::Error> {
+) -> Result<AnyTransaction, anyhow::Error> {
+    use alloy::serde::WithOtherFields;
+    use graph::components::ethereum::AnyTxEnvelope;
     use graph::prelude::alloy::{
-        consensus::transaction::Recovered,
-        consensus::Signed,
-        primitives::{Signature, U256},
+        consensus::transaction::Recovered, consensus::Signed, primitives::Signature,
+        rpc::types::Transaction,
     };
 
     let tx = TxLegacy::default();
@@ -454,17 +457,22 @@ fn create_dummy_transaction(
 
     let tx_hash = transaction_hash.ok_or(anyhow!("Log has no transaction hash"))?;
     let signed_tx = Signed::new_unchecked(tx, signature, tx_hash);
-    let envelope = TxEnvelope::Legacy(signed_tx);
+    let eth_envelope = TxEnvelope::Legacy(signed_tx);
 
-    let recovered = Recovered::new_unchecked(envelope, Address::ZERO);
+    // Wrap in AnyTxEnvelope
+    let any_envelope = AnyTxEnvelope::Ethereum(eth_envelope);
 
-    Ok(Transaction {
+    let recovered = Recovered::new_unchecked(any_envelope, Address::ZERO);
+
+    let inner_tx = Transaction {
         inner: recovered,
         block_hash: Some(block_hash),
         block_number: Some(block_number),
-        transaction_index: transaction_index,
+        transaction_index,
         effective_gas_price: None,
-    })
+    };
+
+    Ok(AnyTransaction::new(WithOtherFields::new(inner_tx)))
 }
 
 impl DataSource {

chain/ethereum/src/ethereum_adapter.rs

@@ -21,10 +21,10 @@ use graph::futures03::{
     self, compat::Future01CompatExt, FutureExt, StreamExt, TryFutureExt, TryStreamExt,
 };
 use graph::prelude::alloy::primitives::Address;
-use graph::prelude::alloy::rpc::types::Transaction;
 use graph::prelude::{
     alloy::{
         self,
+        network::TransactionResponse,
         primitives::B256,
         providers::{
             ext::TraceApi,
@@ -732,7 +732,7 @@ impl EthereumAdapter {
                                 .map_err(Error::from)
                                 .and_then(|block| {
                                     block
-                                        .map(|b| Arc::new(LightEthereumBlock::new(b)))
+                                        .map(|b| Arc::new(LightEthereumBlock::new(b.into())))
                                         .ok_or_else(|| {
                                             anyhow::anyhow!(
                                                 "Ethereum node did not find block {:?}",
@@ -1334,7 +1334,7 @@ impl EthereumAdapterTrait for EthereumAdapter {
         if block.transactions.is_empty() {
             trace!(logger, "Block {} contains no transactions", block_hash);
             return Ok(EthereumBlock {
-                block: Arc::new(LightEthereumBlock::new(block)),
+                block: Arc::new(LightEthereumBlock::new(block.into())),
                 transaction_receipts: Vec::new(),
             });
         }
@@ -1353,7 +1353,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(LightEthereumBlock::new(block)),
+                block: Arc::new(LightEthereumBlock::new(block.into())),
                 transaction_receipts: transaction_receipts
                     .into_iter()
                     .map(|receipt| receipt)
@@ -2043,13 +2043,13 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
     }
 
     // And obtain all Transaction values for the calls in this block.
-    let transactions: Vec<&Transaction> = {
+    let transactions: Vec<&AnyTransaction> = {
         match &block.block {
             BlockFinality::Final(ref block) => block
                 .transactions()
                 .ok_or_else(|| anyhow!("Block transactions not available"))?
                 .iter()
-                .filter(|transaction| transaction_hashes.contains(transaction.inner.tx_hash()))
+                .filter(|transaction| transaction_hashes.contains(&transaction.tx_hash()))
                 .collect(),
             BlockFinality::NonFinal(_block_with_calls) => {
                 unreachable!(
@@ -2079,21 +2079,21 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
         .collect::<BTreeMap<B256, LightTransactionReceipt>>();
 
     // Do we have a receipt for each transaction under analysis?
-    let mut receipts_and_transactions: Vec<(&Transaction, LightTransactionReceipt)> = Vec::new();
-    let mut transactions_without_receipt: Vec<&Transaction> = Vec::new();
+    let mut receipts_and_transactions: Vec<(&AnyTransaction, LightTransactionReceipt)> = Vec::new();
+    let mut transactions_without_receipt: Vec<&AnyTransaction> = Vec::new();
     for transaction in transactions.iter() {
-        if let Some(receipt) = receipts.remove(transaction.inner.tx_hash()) {
-            receipts_and_transactions.push((transaction, receipt));
+        if let Some(receipt) = receipts.remove(&transaction.tx_hash()) {
+            receipts_and_transactions.push((*transaction, receipt));
         } else {
-            transactions_without_receipt.push(transaction);
+            transactions_without_receipt.push(*transaction);
         }
     }
 
     // When some receipts are missing, we then try to fetch them from our client.
     let futures = transactions_without_receipt
         .iter()
         .map(|transaction| async move {
-            fetch_receipt_from_ethereum_client(eth, *transaction.inner.tx_hash())
+            fetch_receipt_from_ethereum_client(eth, transaction.tx_hash())
                 .await
                 .map(|receipt| (transaction, receipt))
         });
@@ -2108,9 +2108,9 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
     // additional Ethereum API calls for future scans on this block.
 
     // With all transactions and receipts in hand, we can evaluate the success of each transaction
-    let mut transaction_success: BTreeMap<&B256, bool> = BTreeMap::new();
+    let mut transaction_success: BTreeMap<B256, bool> = BTreeMap::new();
     for (transaction, receipt) in receipts_and_transactions.into_iter() {
-        transaction_success.insert(&transaction.inner.tx_hash(), receipt.status);
+        transaction_success.insert(transaction.tx_hash(), receipt.status);
     }
 
     // Confidence check: Did we inspect the status of all transactions?
@@ -2623,7 +2623,7 @@ mod tests {
 
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(LightEthereumBlock::new(block)),
+                block: Arc::new(LightEthereumBlock::new(block.into())),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {
@@ -2765,7 +2765,7 @@ mod tests {
         #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(LightEthereumBlock::new(block)),
+                block: Arc::new(LightEthereumBlock::new(block.into())),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {
@@ -2796,7 +2796,7 @@ mod tests {
         #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(LightEthereumBlock::new(block)),
+                block: Arc::new(LightEthereumBlock::new(block.into())),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {

chain/ethereum/src/runtime/abi.rs

@@ -510,9 +510,9 @@ impl<'a> ToAscObj<AscEthereumTransaction_0_0_1> for EthereumTransactionData<'a>
         gas: &GasCounter,
     ) -> Result<AscEthereumTransaction_0_0_1, HostExportError> {
         Ok(AscEthereumTransaction_0_0_1 {
-            hash: asc_new(heap, self.hash(), gas)?,
+            hash: asc_new(heap, &self.hash(), gas)?,
             index: asc_new(heap, &BigInt::from(self.index()), gas)?,
-            from: asc_new(heap, self.from(), gas)?,
+            from: asc_new(heap, &self.from(), gas)?,
             to: self
                 .to()
                 .map(|to| asc_new(heap, &to, gas))
@@ -531,9 +531,9 @@ impl<'a> ToAscObj<AscEthereumTransaction_0_0_2> for EthereumTransactionData<'a>
         gas: &GasCounter,
     ) -> Result<AscEthereumTransaction_0_0_2, HostExportError> {
         Ok(AscEthereumTransaction_0_0_2 {
-            hash: asc_new(heap, self.hash(), gas)?,
+            hash: asc_new(heap, &self.hash(), gas)?,
             index: asc_new(heap, &BigInt::from(self.index()), gas)?,
-            from: asc_new(heap, self.from(), gas)?,
+            from: asc_new(heap, &self.from(), gas)?,
             to: self
                 .to()
                 .map(|to| asc_new(heap, &to, gas))
@@ -553,9 +553,9 @@ impl<'a> ToAscObj<AscEthereumTransaction_0_0_6> for EthereumTransactionData<'a>
         gas: &GasCounter,
     ) -> Result<AscEthereumTransaction_0_0_6, HostExportError> {
         Ok(AscEthereumTransaction_0_0_6 {
-            hash: asc_new(heap, self.hash(), gas)?,
+            hash: asc_new(heap, &self.hash(), gas)?,
             index: asc_new(heap, &BigInt::from(self.index()), gas)?,
-            from: asc_new(heap, self.from(), gas)?,
+            from: asc_new(heap, &self.from(), gas)?,
             to: self
                 .to()
                 .map(|to| asc_new(heap, &to, gas))

chain/ethereum/src/tests.rs

@@ -123,7 +123,7 @@ fn test_trigger_ordering() {
 
     let b = Block::default();
 
-    let b = LightEthereumBlock::new(b);
+    let b = LightEthereumBlock::new(b.into());
 
     // Test that `BlockWithTriggers` sorts the triggers.
     let block_with_triggers = BlockWithTriggers::<crate::Chain>::new(
@@ -203,7 +203,7 @@ fn test_trigger_dedup() {
     let b = Block::default();
 
     #[allow(unreachable_code)]
-    let b = LightEthereumBlock::new(b);
+    let b = LightEthereumBlock::new(b.into());
 
     // Test that `BlockWithTriggers` sorts the triggers.
     let block_with_triggers = BlockWithTriggers::<crate::Chain>::new(