all: Update Rust edition to 2024

Author: lutter

Cargo.toml

@@ -27,7 +27,7 @@ members = [
 
 [workspace.package]
 version = "0.42.1"
-edition = "2021"
+edition = "2024"
 authors = ["The Graph core developers & contributors"]
 readme = "README.md"
 homepage = "https://thegraph.com"

chain/common/tests/test-acme.rs

@@ -7,8 +7,8 @@ fn check_repeated_type_ok() {
     let types = parse_proto_file(PROTO_FILE).expect("Unable to read proto file!");
 
     let array_types = types
-        .iter()
-        .flat_map(|(_, t)| t.fields.iter())
+        .values()
+        .flat_map(|t| t.fields.iter())
         .filter(|t| t.is_array)
         .map(|t| t.type_name.clone())
         .collect::<std::collections::HashSet<_>>();

chain/ethereum/src/call_helper.rs

@@ -93,11 +93,10 @@ pub fn interpret_eth_call_error(
         Ok(call::Retval::Null)
     }
 
-    if let RpcError::ErrorResp(rpc_error) = &err {
-        if is_rpc_revert_message(&rpc_error.message) {
+    if let RpcError::ErrorResp(rpc_error) = &err
+        && is_rpc_revert_message(&rpc_error.message) {
             return reverted(logger, &rpc_error.message);
         }
-    }
 
     if let RpcError::ErrorResp(rpc_error) = &err {
         let code = rpc_error.code;
@@ -106,13 +105,11 @@ pub fn interpret_eth_call_error(
             .as_ref()
             .and_then(|d| serde_json::from_str(d.get()).ok());
 
-        if code == PARITY_VM_EXECUTION_ERROR {
-            if let Some(data) = data {
-                if is_parity_revert(&data) {
+        if code == PARITY_VM_EXECUTION_ERROR
+            && let Some(data) = data
+                && is_parity_revert(&data) {
                     return reverted(logger, &parity_revert_reason(&data));
                 }
-            }
-        }
     }
 
     Err(ContractCallError::AlloyError(err))

chain/ethereum/src/chain.rs

@@ -396,11 +396,10 @@ where
     for _ in 0..offset {
         match parent_getter(current_ptr.clone()).await? {
             Some(parent) => {
-                if let Some(root_hash) = &root {
-                    if parent.hash == *root_hash {
+                if let Some(root_hash) = &root
+                    && parent.hash == *root_hash {
                         break;
                     }
-                }
                 current_ptr = parent;
             }
             None => return Ok(None),
@@ -814,9 +813,7 @@ async fn fetch_unique_blocks_from_cache(
         .unwrap_or_default();
 
     // Collect blocks and filter out ones with multiple entries
-    let blocks: Vec<Arc<ExtendedBlockPtr>> = blocks_map
-        .into_iter()
-        .filter_map(|(_, values)| {
+    let blocks: Vec<Arc<ExtendedBlockPtr>> = blocks_map.into_values().filter_map(|values| {
             if values.len() == 1 {
                 Some(Arc::new(values[0].clone()))
             } else {

chain/ethereum/src/ethereum_adapter.rs

@@ -3,52 +3,53 @@ use futures03::{future::BoxFuture, stream::FuturesUnordered};
 use graph::abi;
 use graph::abi::DynSolValueExt;
 use graph::abi::FunctionExt;
-use graph::blockchain::client::ChainClient;
 use graph::blockchain::BlockHash;
 use graph::blockchain::ChainIdentifier;
 use graph::blockchain::ExtendedBlockPtr;
+use graph::blockchain::client::ChainClient;
 use graph::components::ethereum::*;
 use graph::components::transaction_receipt::LightTransactionReceipt;
 use graph::data::store::ethereum::call;
 use graph::data::store::scalar;
-use graph::data::subgraph::UnifiedMappingApiVersion;
 use graph::data::subgraph::API_VERSION_0_0_7;
+use graph::data::subgraph::UnifiedMappingApiVersion;
 use graph::data_source::common::ContractCall;
 use graph::derive::CheapClone;
-use graph::futures01::stream;
 use graph::futures01::Future;
 use graph::futures01::Stream;
+use graph::futures01::stream;
 use graph::futures03::future::try_join_all;
 use graph::futures03::{
-    self, compat::Future01CompatExt, FutureExt, StreamExt, TryFutureExt, TryStreamExt,
+    self, FutureExt, StreamExt, TryFutureExt, TryStreamExt, compat::Future01CompatExt,
 };
 use graph::prelude::{
     alloy::{
         self,
         network::TransactionResponse,
         primitives::{Address, B256},
         providers::{
+            Identity, Provider, RootProvider,
             ext::TraceApi,
             fillers::{
                 BlobGasFiller, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller,
             },
-            Identity, Provider, RootProvider,
         },
         rpc::types::{
-            trace::{filter::TraceFilter as AlloyTraceFilter, parity::LocalizedTransactionTrace},
             TransactionInput, TransactionRequest,
+            trace::{filter::TraceFilter as AlloyTraceFilter, parity::LocalizedTransactionTrace},
         },
         transports::{RpcError, TransportErrorKind},
     },
     tokio::try_join,
 };
 use graph::slog::o;
 use graph::{
-    blockchain::{block_stream::BlockWithTriggers, BlockPtr, IngestorError},
+    blockchain::{BlockPtr, IngestorError, block_stream::BlockWithTriggers},
     prelude::{
-        anyhow::{self, anyhow, bail, ensure, Context},
-        debug, error, hex, info, retry, trace, warn, BlockNumber, ChainStore, CheapClone,
-        DynTryFuture, Error, EthereumCallCache, Logger, TimeoutError,
+        BlockNumber, ChainStore, CheapClone, DynTryFuture, Error, EthereumCallCache, Logger,
+        TimeoutError,
+        anyhow::{self, Context, anyhow, bail, ensure},
+        debug, error, hex, info, retry, trace, warn,
     },
 };
 use itertools::Itertools;
@@ -61,24 +62,24 @@ use std::time::{Duration, Instant};
 use tokio::sync::RwLock;
 use tokio::time::timeout;
 
+use crate::Chain;
+use crate::NodeCapabilities;
+use crate::TriggerFilter;
 use crate::adapter::EthGetLogsFilter;
 use crate::adapter::EthereumRpcError;
 use crate::adapter::ProviderStatus;
 use crate::call_helper::interpret_eth_call_error;
 use crate::chain::BlockFinality;
 use crate::chain::ChainSettings;
 use crate::trigger::{LogPosition, LogRef};
-use crate::Chain;
-use crate::NodeCapabilities;
-use crate::TriggerFilter;
 use crate::{
+    ENV_VARS,
     adapter::{
         ContractCallError, EthereumAdapter as EthereumAdapterTrait, EthereumBlockFilter,
         EthereumCallFilter, EthereumLogFilter, ProviderEthRpcMetrics, SubgraphEthRpcMetrics,
     },
     transport::Transport,
     trigger::{EthereumBlockTriggerType, EthereumTrigger},
-    ENV_VARS,
 };
 
 type AlloyProvider = FillProvider<
@@ -1014,7 +1015,8 @@ impl EthereumAdapter {
     ) -> Pin<
         Box<
             dyn std::future::Future<Output = Result<Vec<EthereumTrigger>, anyhow::Error>>
-                + std::marker::Send,
+                + std::marker::Send
+                + '_,
         >,
     > {
         // Create a HashMap of block numbers to Vec<EthereumBlockTriggerType>
@@ -1053,15 +1055,13 @@ impl EthereumAdapter {
         let block_futures = blocks_matching_polling_filter.map(move |ptrs| {
             ptrs.into_iter()
                 .flat_map(|ptr| {
-                    let triggers = matching_blocks
+                    matching_blocks
                         .get(&ptr.number)
                         // Safe to unwrap since we are iterating over ptrs which was created from
                         // the keys of matching_blocks
                         .unwrap()
                         .iter()
-                        .map(move |trigger| EthereumTrigger::Block(ptr.clone(), trigger.clone()));
-
-                    triggers
+                        .map(move |trigger| EthereumTrigger::Block(ptr.clone(), trigger.clone()))
                 })
                 .collect::<Vec<_>>()
         });
@@ -1126,7 +1126,7 @@ impl EthereumAdapter {
         logger: Logger,
         from: BlockNumber,
         to: BlockNumber,
-    ) -> Box<dyn Future<Item = Vec<BlockPtr>, Error = Error> + Send> {
+    ) -> Box<dyn Future<Item = Vec<BlockPtr>, Error = Error> + Send + '_> {
         // Currently we can't go to the DB for this because there might be duplicate entries for
         // the same block number.
         debug!(&logger, "Requesting hashes for blocks [{}, {}]", from, to);
@@ -1140,7 +1140,7 @@ impl EthereumAdapter {
         &self,
         logger: Logger,
         blocks: Vec<BlockNumber>,
-    ) -> Box<dyn Future<Item = Vec<BlockPtr>, Error = Error> + Send> {
+    ) -> Box<dyn Future<Item = Vec<BlockPtr>, Error = Error> + Send + '_> {
         // Currently we can't go to the DB for this because there might be duplicate entries for
         // the same block number.
         debug!(&logger, "Requesting hashes for blocks {:?}", blocks);
@@ -1587,15 +1587,26 @@ impl EthereumAdapterTrait for EthereumAdapter {
 
         fn log_call_error(logger: &ProviderLogger, e: &ContractCallError, call: &ContractCall) {
             match e {
-                ContractCallError::AlloyError(e) => error!(logger,
+                ContractCallError::AlloyError(e) => error!(
+                    logger,
                     "Ethereum node returned an error when calling function \"{}\" of contract \"{}\": {}",
-                    call.function.name, call.contract_name, e),
-                ContractCallError::Timeout => error!(logger,
+                    call.function.name,
+                    call.contract_name,
+                    e
+                ),
+                ContractCallError::Timeout => error!(
+                    logger,
                     "Ethereum node did not respond when calling function \"{}\" of contract \"{}\"",
-                    call.function.name, call.contract_name),
-                _ => error!(logger,
+                    call.function.name,
+                    call.contract_name
+                ),
+                _ => error!(
+                    logger,
                     "Failed to call function \"{}\" of contract \"{}\": {}",
-                    call.function.name, call.contract_name, e),
+                    call.function.name,
+                    call.contract_name,
+                    e
+                ),
             }
         }
 
@@ -2125,7 +2136,7 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
     // And obtain all Transaction values for the calls in this block.
     let transactions: Vec<&AnyTransaction> = {
         match &block.block {
-            BlockFinality::Final(ref block) => block
+            BlockFinality::Final(block) => block
                 .transactions()
                 .ok_or_else(|| anyhow!("Block transactions not available"))?
                 .iter()
@@ -2696,15 +2707,15 @@ mod tests {
     use crate::trigger::{EthereumBlockTriggerType, EthereumTrigger};
 
     use super::{
-        check_block_receipt_support, parse_block_triggers, EthereumBlock, EthereumBlockFilter,
-        EthereumBlockWithCalls,
+        EthereumBlock, EthereumBlockFilter, EthereumBlockWithCalls, check_block_receipt_support,
+        parse_block_triggers,
     };
     use graph::blockchain::BlockPtr;
     use graph::components::ethereum::AnyNetworkBare;
-    use graph::prelude::alloy::primitives::{Address, Bytes, B256};
-    use graph::prelude::alloy::providers::mock::Asserter;
+    use graph::prelude::alloy::primitives::{Address, B256, Bytes};
     use graph::prelude::alloy::providers::ProviderBuilder;
-    use graph::prelude::{create_minimal_block_for_test, EthereumCall, LightEthereumBlock};
+    use graph::prelude::alloy::providers::mock::Asserter;
+    use graph::prelude::{EthereumCall, LightEthereumBlock, create_minimal_block_for_test};
     use jsonrpc_core::serde_json::{self, Value};
     use std::collections::HashSet;
     use std::iter::FromIterator;

chain/ethereum/src/ingestor.rs

@@ -281,11 +281,10 @@ async fn on_poll_failure<A: crate::EthereumAdapterTrait>(
     // at the match level. If the current provider responds to eth_blockNumber, the
     // failure was not caused by provider unavailability — switching cannot help.
     let current = providers.iter().find(|p| p.provider() == current_name);
-    if let Some(current) = current {
-        if current.is_reachable().await {
+    if let Some(current) = current
+        && current.is_reachable().await {
             return;
         }
-    }
 
     // Probe all alternatives in parallel; switch to the first that responds.
     let futs = providers

chain/ethereum/src/network.rs

@@ -118,7 +118,7 @@ impl EthereumNetworkAdapters {
 
         let provider = ProviderManager::new(
             Logger::root(Discard, o!()),
-            vec![(chain_id.clone(), adapters)].into_iter(),
+            vec![(chain_id.clone(), adapters)],
             ProviderCheckStrategy::MarkAsValid,
         );
 

chain/ethereum/src/polling_block_stream.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Error};
+use anyhow::{Error, anyhow};
 use std::cmp;
 use std::collections::VecDeque;
 use std::pin::Pin;
@@ -7,13 +7,13 @@ use std::task::{Context, Poll};
 use std::time::Duration;
 
 use graph::blockchain::block_stream::{
-    BlockStream, BlockStreamError, BlockStreamEvent, BlockWithTriggers, ChainHeadUpdateStream,
-    FirehoseCursor, TriggersAdapterWrapper, BUFFERED_BLOCK_STREAM_SIZE,
+    BUFFERED_BLOCK_STREAM_SIZE, BlockStream, BlockStreamError, BlockStreamEvent, BlockWithTriggers,
+    ChainHeadUpdateStream, FirehoseCursor, TriggersAdapterWrapper,
 };
 use graph::blockchain::{Block, BlockPtr, TriggerFilterWrapper};
-use graph::futures03::{stream::Stream, Future, FutureExt};
-use graph::prelude::{DeploymentHash, BLOCK_NUMBER_MAX};
-use graph::slog::{info, trace, warn, Logger};
+use graph::futures03::{Future, FutureExt, stream::Stream};
+use graph::prelude::{BLOCK_NUMBER_MAX, DeploymentHash};
+use graph::slog::{Logger, info, trace, warn};
 
 use graph::components::store::BlockNumber;
 use graph::data::subgraph::UnifiedMappingApiVersion;
@@ -182,7 +182,7 @@ impl PollingBlockStreamContext {
                     return Ok(NextBlocks::Done);
                 }
                 ReconciliationStep::Revert(parent_ptr) => {
-                    return Ok(NextBlocks::Revert(parent_ptr))
+                    return Ok(NextBlocks::Revert(parent_ptr));
                 }
             }
         }
@@ -224,11 +224,10 @@ impl PollingBlockStreamContext {
 
         // Only continue if the subgraph block ptr is behind the head block ptr.
         // subgraph_ptr > head_ptr shouldn't happen, but if it does, it's safest to just stop.
-        if let Some(ptr) = &subgraph_ptr {
-            if ptr.number >= head_ptr.number {
+        if let Some(ptr) = &subgraph_ptr
+            && ptr.number >= head_ptr.number {
                 return Ok(ReconciliationStep::Done);
             }
-        }
 
         // Subgraph ptr is behind head ptr.
         // Let's try to move the subgraph ptr one step in the right direction.
@@ -569,7 +568,7 @@ impl Stream for PollingBlockStream {
                 }
 
                 // Yielding blocks from reconciliation process
-                BlockStreamState::YieldingBlocks(ref mut next_blocks) => {
+                BlockStreamState::YieldingBlocks(next_blocks) => {
                     match next_blocks.pop_front() {
                         // Yield one block
                         Some(next_block) => {
@@ -589,7 +588,7 @@ impl Stream for PollingBlockStream {
                 }
 
                 // Pausing after an error, before looking for more blocks
-                BlockStreamState::RetryAfterDelay(ref mut delay) => match delay.as_mut().poll(cx) {
+                BlockStreamState::RetryAfterDelay(delay) => match delay.as_mut().poll(cx) {
                     Poll::Ready(Ok(..)) | Poll::Ready(Err(_)) => {
                         self.state = BlockStreamState::BeginReconciliation;
                     }

chain/ethereum/src/transport.rs

@@ -265,13 +265,12 @@ impl Service<RequestPacket> for PatchingHttp {
                 ));
             }
 
-            if should_patch {
-                if let Some(patched) = Self::patch_response(&body) {
+            if should_patch
+                && let Some(patched) = Self::patch_response(&body) {
                     return serde_json::from_slice(&patched).map_err(|err| {
                         TransportError::deser_err(err, String::from_utf8_lossy(&patched))
                     });
                 }
-            }
             serde_json::from_slice(&body)
                 .map_err(|err| TransportError::deser_err(err, String::from_utf8_lossy(&body)))
         })