chain/ethereum: Migrate eth_call to use alloy

Author: incrypto32

chain/ethereum/src/adapter.rs

@@ -112,6 +112,8 @@ pub enum ContractCallError {
     EncodingError(anyhow::Error),
     #[error("call error: {0}")]
     Web3Error(web3::Error),
+    #[error("call error: {0}")]
+    AlloyError(RpcError<TransportErrorKind>),
     #[error("ethereum node took too long to perform call")]
     Timeout,
     #[error("internal error: {0}")]

chain/ethereum/src/call_helper.rs

@@ -2,7 +2,10 @@ use crate::{ContractCallError, ENV_VARS};
 use graph::{
     abi,
     data::store::ethereum::call,
-    prelude::{web3, Logger},
+    prelude::{
+        alloy::transports::{RpcError, TransportErrorKind},
+        Logger,
+    },
     slog::info,
 };
 
@@ -79,33 +82,33 @@ fn as_solidity_revert_reason(bytes: &[u8]) -> Option<String> {
 /// EVM reverts. Returns `Ok(Null)` for reverts or a proper error otherwise.
 pub fn interpret_eth_call_error(
     logger: &Logger,
-    err: web3::Error,
+    err: RpcError<TransportErrorKind>,
 ) -> Result<call::Retval, ContractCallError> {
     fn reverted(logger: &Logger, reason: &str) -> Result<call::Retval, ContractCallError> {
         info!(logger, "Contract call reverted"; "reason" => reason);
         Ok(call::Retval::Null)
     }
 
-    if let web3::Error::Rpc(rpc_error) = &err {
+    if let RpcError::ErrorResp(rpc_error) = &err {
         if is_geth_revert_message(&rpc_error.message) {
             return reverted(logger, &rpc_error.message);
         }
     }
 
-    if let web3::Error::Rpc(rpc_error) = &err {
-        let code = rpc_error.code.code();
-        let data = rpc_error.data.as_ref().and_then(|d| d.as_str());
+    if let RpcError::ErrorResp(rpc_error) = &err {
+        let code = rpc_error.code;
+        let data = rpc_error.data.as_ref().map(|d| d.to_string());
 
         if code == PARITY_VM_EXECUTION_ERROR {
             if let Some(data) = data {
-                if is_parity_revert(data) {
-                    return reverted(logger, &parity_revert_reason(data));
+                if is_parity_revert(&data) {
+                    return reverted(logger, &parity_revert_reason(&data));
                 }
             }
         }
     }
 
-    Err(ContractCallError::Web3Error(err))
+    Err(ContractCallError::AlloyError(err))
 }
 
 fn is_parity_revert(data: &str) -> bool {

chain/ethereum/src/ethereum_adapter.rs

@@ -20,6 +20,7 @@ use graph::futures03::{
     self, compat::Future01CompatExt, FutureExt, StreamExt, TryFutureExt, TryStreamExt,
 };
 use graph::prelude::alloy;
+use graph::prelude::alloy::rpc::types::{TransactionInput, TransactionRequest};
 use graph::prelude::tokio::try_join;
 use graph::slog::o;
 use graph::tokio::sync::RwLock;
@@ -31,10 +32,7 @@ use graph::{
         async_trait, debug, error, hex, info, retry, serde_json as json, trace, warn,
         web3::{
             self,
-            types::{
-                BlockId, Bytes, CallRequest, Filter, FilterBuilder, Log, Transaction,
-                TransactionReceipt, H256,
-            },
+            types::{BlockId, Filter, FilterBuilder, Log, Transaction, TransactionReceipt, H256},
         },
         BlockNumber, ChainStore, CheapClone, DynTryFuture, Error, EthereumCallCache, Logger,
         TimeoutError,
@@ -514,18 +512,7 @@ impl EthereumAdapter {
         .boxed()
     }
 
-    // Method to determine block_id based on support for EIP-1898
-    fn block_ptr_to_id(&self, block_ptr: &BlockPtr) -> BlockId {
-        // Ganache does not support calls by block hash.
-        // See https://github.com/trufflesuite/ganache-cli/issues/973
-        if !self.supports_eip_1898 {
-            BlockId::Number(block_ptr.number.into())
-        } else {
-            BlockId::Hash(block_ptr.hash_as_h256())
-        }
-    }
-
-    fn block_ptr_to_alloy_block_id(&self, block_ptr: &BlockPtr) -> alloy::rpc::types::BlockId {
+    fn block_ptr_to_id(&self, block_ptr: &BlockPtr) -> alloy::rpc::types::BlockId {
         if !self.supports_eip_1898 {
             alloy::rpc::types::BlockId::number(block_ptr.number as u64)
         } else {
@@ -544,7 +531,7 @@ impl EthereumAdapter {
         let alloy = self.alloy.clone();
         let logger = Logger::new(&logger, o!("provider" => self.provider.clone()));
 
-        let block_id = self.block_ptr_to_alloy_block_id(&block_ptr);
+        let block_id = self.block_ptr_to_id(&block_ptr);
         let retry_log_message = format!("eth_getCode RPC call for block {}", block_ptr);
 
         retry(retry_log_message, &logger)
@@ -578,7 +565,7 @@ impl EthereumAdapter {
         let alloy = self.alloy.clone();
         let logger = Logger::new(&logger, o!("provider" => self.provider.clone()));
 
-        let block_id = self.block_ptr_to_alloy_block_id(&block_ptr);
+        let block_id = self.block_ptr_to_id(&block_ptr);
         let retry_log_message = format!("eth_getBalance RPC call for block {}", block_ptr);
 
         retry(retry_log_message, &logger)
@@ -610,33 +597,33 @@ impl EthereumAdapter {
         block_ptr: BlockPtr,
         gas: Option<u32>,
     ) -> Result<call::Retval, ContractCallError> {
-        let web3 = self.web3.clone();
+        let alloy = self.alloy.clone();
         let logger = Logger::new(&logger, o!("provider" => self.provider.clone()));
 
-        let block_id = self.block_ptr_to_id(&block_ptr);
+        let alloy_block_id = self.block_ptr_to_id(&block_ptr);
         let retry_log_message = format!("eth_call RPC call for block {}", block_ptr);
         retry(retry_log_message, &logger)
             .redact_log_urls(true)
             .limit(ENV_VARS.request_retries)
             .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
             .run(move || {
                 let call_data = call_data.clone();
-                let web3 = web3.cheap_clone();
+                let alloy = alloy.cheap_clone();
                 let logger = logger.cheap_clone();
                 async move {
-                    let req = CallRequest {
-                        to: Some(call_data.address),
-                        gas: gas.map(|val| web3::types::U256::from(val)),
-                        data: Some(Bytes::from(call_data.encoded_call.to_vec())),
-                        from: None,
-                        gas_price: None,
-                        value: None,
-                        access_list: None,
-                        max_fee_per_gas: None,
-                        max_priority_fee_per_gas: None,
-                        transaction_type: None,
-                    };
-                    let result = web3.eth().call(req, Some(block_id)).boxed().await;
+                    let mut req = TransactionRequest::default()
+                        .input(TransactionInput::both(alloy::primitives::Bytes::from(
+                            call_data.encoded_call.to_vec(),
+                        )))
+                        .to(alloy::primitives::Address::from(
+                            call_data.address.as_fixed_bytes(),
+                        ));
+
+                    if let Some(gas) = gas {
+                        req = req.gas_limit(gas as u64);
+                    }
+
+                    let result = alloy.call(req).block(alloy_block_id).await;
 
                     match result {
                         Ok(bytes) => Ok(call::Retval::Value(scalar::Bytes::from(bytes))),

graph/src/data/store/scalar/bytes.rs

@@ -123,3 +123,9 @@ impl FromSql<diesel::sql_types::Binary, diesel::pg::Pg> for Bytes {
         <Vec<u8> as FromSql<diesel::sql_types::Binary, _>>::from_sql(value).map(Bytes::from)
     }
 }
+
+impl From<alloy::primitives::Bytes> for Bytes {
+    fn from(bytes: alloy::primitives::Bytes) -> Bytes {
+        Bytes::from(bytes.as_ref())
+    }
+}