all: Reformat because of edition change

Author: lutter

chain/common/src/lib.rs

@@ -2,13 +2,13 @@ use std::collections::HashMap;
 use std::fmt::Debug;
 
 use anyhow::Error;
-use protobuf::descriptor::field_descriptor_proto::Label;
-use protobuf::descriptor::field_descriptor_proto::Type;
+use protobuf::Message;
+use protobuf::UnknownValueRef;
 use protobuf::descriptor::DescriptorProto;
 use protobuf::descriptor::FieldDescriptorProto;
 use protobuf::descriptor::OneofDescriptorProto;
-use protobuf::Message;
-use protobuf::UnknownValueRef;
+use protobuf::descriptor::field_descriptor_proto::Label;
+use protobuf::descriptor::field_descriptor_proto::Type;
 use std::convert::From;
 use std::path::Path;
 

chain/ethereum/examples/firehose.rs

@@ -4,7 +4,7 @@ use graph::{
     env::env_var,
     firehose::{self, FirehoseEndpoint, SubgraphLimit},
     log::logger,
-    prelude::{prost, tokio, tonic, MetricsRegistry},
+    prelude::{MetricsRegistry, prost, tokio, tonic},
 };
 use graph_chain_ethereum::codec;
 use hex::ToHex;

chain/ethereum/src/adapter.rs

@@ -35,7 +35,7 @@ const COMBINED_FILTER_TYPE_URL: &str =
 
 use crate::capabilities::NodeCapabilities;
 use crate::data_source::{BlockHandlerFilter, DataSource};
-use crate::{Chain, Mapping, ENV_VARS};
+use crate::{Chain, ENV_VARS, Mapping};
 
 pub type EventSignature = B256;
 pub type FunctionSelector = [u8; 4];
@@ -1186,7 +1186,7 @@ pub trait EthereumAdapter: Send + Sync + 'static {
 
 #[cfg(test)]
 mod tests {
-    use crate::adapter::{FunctionSelector, COMBINED_FILTER_TYPE_URL};
+    use crate::adapter::{COMBINED_FILTER_TYPE_URL, FunctionSelector};
 
     use super::{EthereumBlockFilter, LogFilterNode};
     use super::{EthereumCallFilter, EthereumLogFilter, TriggerFilter};
@@ -1195,8 +1195,8 @@ mod tests {
     use graph::blockchain::TriggerFilter as _;
     use graph::firehose::{CallToFilter, CombinedFilter, LogFilter, MultiLogFilter};
     use graph::petgraph::graphmap::GraphMap;
-    use graph::prelude::alloy::primitives::{Address, Bytes, B256, U256};
     use graph::prelude::EthereumCall;
+    use graph::prelude::alloy::primitives::{Address, B256, Bytes, U256};
     use hex::ToHex;
     use itertools::Itertools;
     use prost::Message;
@@ -1264,9 +1264,11 @@ mod tests {
         assert_eq!(sig, actual_sig);
 
         let filter = LogFilter {
-            addresses: vec![Address::from_str(hex_addr)
-                .expect("failed to parse address")
-                .to_vec()],
+            addresses: vec![
+                Address::from_str(hex_addr)
+                    .expect("failed to parse address")
+                    .to_vec(),
+            ],
             event_signatures: vec![fs.to_vec()],
         };
 
@@ -1651,8 +1653,8 @@ mod tests {
     }
 
     #[test]
-    fn extending_ethereum_block_filter_every_block_in_base_and_merge_contract_addresses_and_polling_intervals(
-    ) {
+    fn extending_ethereum_block_filter_every_block_in_base_and_merge_contract_addresses_and_polling_intervals()
+     {
         let mut base = EthereumBlockFilter {
             polling_intervals: HashSet::from_iter(vec![(10, 3)]),
             contract_addresses: HashSet::from_iter(vec![(10, address(2))]),

chain/ethereum/src/buffered_call_cache.rs

@@ -9,7 +9,7 @@ use graph::{
     components::store::EthereumCallCache,
     data::store::ethereum::call,
     prelude::{BlockPtr, CachedEthereumCall},
-    slog::{error, Logger},
+    slog::{Logger, error},
 };
 
 /// A wrapper around an Ethereum call cache that buffers call results in

chain/ethereum/src/call_helper.rs

@@ -3,8 +3,9 @@ use graph::{
     abi,
     data::store::ethereum::call,
     prelude::{
+        Logger,
         alloy::transports::{RpcError, TransportErrorKind},
-        serde_json, Logger,
+        serde_json,
     },
     slog::info,
 };
@@ -94,9 +95,10 @@ pub fn interpret_eth_call_error(
     }
 
     if let RpcError::ErrorResp(rpc_error) = &err
-        && is_rpc_revert_message(&rpc_error.message) {
-            return reverted(logger, &rpc_error.message);
-        }
+        && 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;
@@ -107,9 +109,10 @@ pub fn interpret_eth_call_error(
 
         if code == PARITY_VM_EXECUTION_ERROR
             && let Some(data) = data
-                && is_parity_revert(&data) {
-                    return reverted(logger, &parity_revert_reason(&data));
-                }
+            && is_parity_revert(&data)
+        {
+            return reverted(logger, &parity_revert_reason(&data));
+        }
     }
 
     Err(ContractCallError::AlloyError(err))

chain/ethereum/src/chain.rs

@@ -1,5 +1,5 @@
-use anyhow::{anyhow, bail, Result};
 use anyhow::{Context, Error};
+use anyhow::{Result, anyhow, bail};
 use async_trait::async_trait;
 use graph::blockchain::client::ChainClient;
 use graph::blockchain::firehose_block_ingestor::{FirehoseBlockIngestor, Transforms};
@@ -13,26 +13,27 @@ use graph::data::subgraph::UnifiedMappingApiVersion;
 use graph::firehose::{FirehoseEndpoint, FirehoseEndpoints, ForkStep};
 use graph::futures03::TryStreamExt;
 use graph::prelude::{
-    retry, BlockHash, ComponentLoggerConfig, ElasticComponentLoggerConfig, EthereumBlock,
+    BlockHash, ComponentLoggerConfig, ElasticComponentLoggerConfig, EthereumBlock,
     EthereumCallCache, LightEthereumBlock, LightEthereumBlockExt, MetricsRegistry, StoreError,
+    retry,
 };
 use graph::slog::{debug, error, trace, warn};
 use graph::{
     blockchain::{
+        Block, BlockPtr, Blockchain, ChainHeadUpdateListener, IngestorError,
+        RuntimeAdapter as RuntimeAdapterTrait, TriggerFilter as _,
         block_stream::{
             BlockRefetcher, BlockStreamEvent, BlockWithTriggers, FirehoseError,
             FirehoseMapper as FirehoseMapperTrait, TriggersAdapter as TriggersAdapterTrait,
         },
         firehose_block_stream::FirehoseBlockStream,
-        Block, BlockPtr, Blockchain, ChainHeadUpdateListener, IngestorError,
-        RuntimeAdapter as RuntimeAdapterTrait, TriggerFilter as _,
     },
     cheap_clone::CheapClone,
     components::store::DeploymentLocator,
     firehose,
     prelude::{
-        o, serde_json as json, BlockNumber, ChainStore, EthereumBlockWithCalls, Logger,
-        LoggerFactory,
+        BlockNumber, ChainStore, EthereumBlockWithCalls, Logger, LoggerFactory, o,
+        serde_json as json,
     },
 };
 use prost::Message;
@@ -49,17 +50,17 @@ use crate::ingestor::PollingBlockIngestor;
 use crate::network::EthereumNetworkAdapters;
 use crate::polling_block_stream::PollingBlockStream;
 use crate::runtime::runtime_adapter::eth_call_gas;
+use crate::{BufferedCallCache, NodeCapabilities};
 use crate::{
+    ENV_VARS, SubgraphEthRpcMetrics, TriggerFilter,
     adapter::EthereumAdapter as _,
     codec,
     data_source::{DataSource, UnresolvedDataSource},
     ethereum_adapter::{
         blocks_with_triggers, get_calls, parse_block_triggers, parse_call_triggers,
         parse_log_triggers,
     },
-    SubgraphEthRpcMetrics, TriggerFilter, ENV_VARS,
 };
-use crate::{BufferedCallCache, NodeCapabilities};
 use crate::{EthereumAdapter, RuntimeAdapter};
 use graph::blockchain::block_stream::{
     BlockStream, BlockStreamBuilder, BlockStreamError, BlockStreamMapper, FirehoseCursor,
@@ -397,9 +398,10 @@ where
         match parent_getter(current_ptr.clone()).await? {
             Some(parent) => {
                 if let Some(root_hash) = &root
-                    && parent.hash == *root_hash {
-                        break;
-                    }
+                    && parent.hash == *root_hash
+                {
+                    break;
+                }
                 current_ptr = parent;
             }
             None => return Ok(None),
@@ -813,7 +815,9 @@ 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_values().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 {
@@ -1369,7 +1373,9 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
             }
 
             StepFinal => {
-                unreachable!("irreversible step is not handled and should not be requested in the Firehose request")
+                unreachable!(
+                    "irreversible step is not handled and should not be requested in the Firehose request"
+                )
             }
 
             StepUnset => {

chain/ethereum/src/codec.rs

@@ -12,15 +12,15 @@ use graph::{
         AnyBlock, AnyHeader, AnyRpcHeader, AnyTransactionReceiptBare, AnyTxEnvelope,
     },
     prelude::{
+        BlockNumber, Error, EthereumBlock, EthereumBlockWithCalls, EthereumCall,
+        LightEthereumBlock,
         alloy::{
             self,
             consensus::{ReceiptWithBloom, TxEnvelope, TxType},
             network::AnyReceiptEnvelope,
-            primitives::{aliases::B2048, Address, Bloom, Bytes, LogData, B256, U256},
+            primitives::{Address, B256, Bloom, Bytes, LogData, U256, aliases::B2048},
             rpc::types::{self as alloy_rpc_types, AccessList, AccessListItem, Transaction},
         },
-        BlockNumber, Error, EthereumBlock, EthereumBlockWithCalls, EthereumCall,
-        LightEthereumBlock,
     },
 };
 use std::sync::Arc;
@@ -650,7 +650,7 @@ fn transaction_trace_to_alloy_txn_reciept(
         TransactionTraceStatus::Unknown => {
             return Err(format_err!(
                 "Transaction trace has UNKNOWN status; datasource is broken"
-            ))
+            ));
         }
         TransactionTraceStatus::Succeeded => true,
         TransactionTraceStatus::Failed | TransactionTraceStatus::Reverted => false,

chain/ethereum/src/data_source.rs

@@ -1,5 +1,5 @@
-use anyhow::{anyhow, Error};
-use anyhow::{ensure, Context};
+use anyhow::{Context, ensure};
+use anyhow::{Error, anyhow};
 use async_trait::async_trait;
 use graph::abi;
 use graph::abi::EventExt;
@@ -18,16 +18,16 @@ use graph::data_source::common::{
 };
 use graph::data_source::{CausalityRegion, MappingTrigger as MappingTriggerType};
 use graph::env::ENV_VARS;
+use graph::futures03::TryStreamExt;
 use graph::futures03::future::try_join;
 use graph::futures03::stream::FuturesOrdered;
-use graph::futures03::TryStreamExt;
 use graph::prelude::alloy::{
     consensus::{TxEnvelope, TxLegacy},
     network::TransactionResponse,
     primitives::{Address, B256, U256},
     rpc::types::Log,
 };
-use graph::prelude::{alloy, Link, SubgraphManifestValidationError};
+use graph::prelude::{Link, SubgraphManifestValidationError, alloy};
 use graph::slog::{debug, error, o, trace};
 use itertools::Itertools;
 use serde::de::Error as ErrorD;
@@ -37,26 +37,26 @@ use std::num::NonZeroU32;
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
-use tiny_keccak::{keccak256, Keccak};
+use tiny_keccak::{Keccak, keccak256};
 
 use graph::{
     blockchain::{self, Blockchain},
     prelude::{
-        serde_json, warn, BlockNumber, CheapClone, EthereumCall, LightEthereumBlock,
-        LightEthereumBlockExt, LinkResolver, Logger,
+        BlockNumber, CheapClone, EthereumCall, LightEthereumBlock, LightEthereumBlockExt,
+        LinkResolver, Logger, serde_json, warn,
     },
 };
 
 use graph::data::subgraph::{
-    calls_host_fn, DataSourceContext, Source, MIN_SPEC_VERSION, SPEC_VERSION_0_0_8,
-    SPEC_VERSION_1_2_0,
+    DataSourceContext, MIN_SPEC_VERSION, SPEC_VERSION_0_0_8, SPEC_VERSION_1_2_0, Source,
+    calls_host_fn,
 };
 
+use crate::NodeCapabilities;
 use crate::adapter::EthereumAdapter as _;
 use crate::chain::Chain;
 use crate::network::EthereumNetworkAdapters;
 use crate::trigger::{EthereumBlockTriggerType, EthereumTrigger, MappingTrigger};
-use crate::NodeCapabilities;
 
 // The recommended kind is `ethereum`, `ethereum/contract` is accepted for backwards compatibility.
 const ETHEREUM_KINDS: &[&str] = &["ethereum/contract", "ethereum"];
@@ -446,7 +446,7 @@ fn create_dummy_transaction(
 ) -> Result<AnyTransaction, anyhow::Error> {
     use graph::components::ethereum::AnyTxEnvelope;
     use graph::prelude::alloy::{
-        consensus::transaction::Recovered, consensus::Signed, primitives::Signature,
+        consensus::Signed, consensus::transaction::Recovered, primitives::Signature,
         rpc::types::Transaction,
     };
 

chain/ethereum/src/env.rs

@@ -1,6 +1,6 @@
 use envconfig::Envconfig;
 use graph::env::EnvVarBoolean;
-use graph::prelude::{envconfig, lazy_static, BlockNumber};
+use graph::prelude::{BlockNumber, envconfig, lazy_static};
 use std::fmt;
 use std::time::Duration;
 

chain/ethereum/src/ingestor.rs

@@ -1,9 +1,9 @@
-use crate::{chain::BlockFinality, ENV_VARS};
+use crate::{ENV_VARS, chain::BlockFinality};
 use crate::{EthereumAdapter, EthereumAdapterTrait as _};
 use async_trait::async_trait;
 use futures::future::select_ok;
-use graph::blockchain::client::ChainClient;
 use graph::blockchain::BlockchainKind;
+use graph::blockchain::client::ChainClient;
 use graph::components::network_provider::ChainName;
 use graph::prelude::alloy::primitives::B256;
 use graph::slog::o;
@@ -12,8 +12,8 @@ use graph::{
     blockchain::{BlockHash, BlockIngestor, BlockPtr, IngestorError},
     cheap_clone::CheapClone,
     prelude::{
-        debug, error, info, tokio, trace, warn, ChainStore, Error, EthereumBlockWithCalls, LogCode,
-        Logger,
+        ChainStore, Error, EthereumBlockWithCalls, LogCode, Logger, debug, error, info, tokio,
+        trace, warn,
     },
 };
 use std::{sync::Arc, time::Duration};
@@ -282,9 +282,10 @@ async fn on_poll_failure<A: crate::EthereumAdapterTrait>(
     // 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
-        && current.is_reachable().await {
-            return;
-        }
+        && current.is_reachable().await
+    {
+        return;
+    }
 
     // Probe all alternatives in parallel; switch to the first that responds.
     let futs = providers
@@ -377,7 +378,7 @@ mod tests {
     use graph::components::ethereum::LightEthereumBlock;
     use graph::data::store::ethereum::call;
     use graph::data_source::common::ContractCall;
-    use graph::prelude::alloy::primitives::{Address, Bytes, B256, U256};
+    use graph::prelude::alloy::primitives::{Address, B256, Bytes, U256};
     use graph::prelude::{BlockNumber, Error, EthereumCallCache, Logger};
     use graph::slog::Discard;
     use std::collections::HashSet;