Fix all clippy warnings

Cargo.toml

@@ -115,6 +115,10 @@ parking_lot = "0.12.4"
 sqlparser-latest = { version = "0.57.0", package = "sqlparser", features = ["visitor"] }
 tokio-util = "0.7.15"
 
+[workspace.lints.clippy]
+too_many_arguments = "allow"
+type_complexity = "allow"
+
 # Incremental compilation on Rust 1.58 causes an ICE on build. As soon as graph node builds again, these can be removed.
 [profile.test]
 incremental = false

chain/common/Cargo.toml

@@ -10,3 +10,6 @@ protobuf = "3.0.2"
 protobuf-parse = "3.7.2"
 anyhow = "1"
 heck = "0.5"
+
+[lints]
+workspace = true

chain/common/tests/test-acme.rs

@@ -63,7 +63,7 @@ fn required_ok() {
                 !f.required,
                 "Transaction.events field should NOT be required!"
             ),
-            _ => assert!(false, "Unexpected message field [{}]!", f.name),
+            _ => panic!("Unexpected message field [{}]!", f.name),
         };
     });
 }

chain/ethereum/Cargo.toml

@@ -29,3 +29,6 @@ base64 = "0"
 
 [build-dependencies]
 tonic-build = { workspace = true }
+
+[lints]
+workspace = true

chain/ethereum/examples/firehose.rs

@@ -9,6 +9,7 @@ use graph::{
 use graph_chain_ethereum::codec;
 use hex::ToHex;
 use prost::Message;
+use std::slice;
 use std::sync::Arc;
 use tonic::Streaming;
 
@@ -25,7 +26,7 @@ async fn main() -> Result<(), Error> {
     let host = "https://api.streamingfast.io:443".to_string();
     let metrics = Arc::new(EndpointMetrics::new(
         logger,
-        &[host.clone()],
+        slice::from_ref(&host),
         Arc::new(MetricsRegistry::mock()),
     ));
 

chain/ethereum/src/adapter.rs

@@ -71,7 +71,7 @@ impl EventSignatureWithTopics {
     /// If self.address is None, it's considered a wildcard match.
     /// Otherwise, it must match the provided address.
     /// It must also match the topics if they are Some
-    pub fn matches(&self, address: Option<&H160>, sig: H256, topics: &Vec<H256>) -> bool {
+    pub fn matches(&self, address: Option<&H160>, sig: H256, topics: &[H256]) -> bool {
         // If self.address is None, it's considered a wildcard match. Otherwise, it must match the provided address.
         let address_matches = match self.address {
             Some(ref self_addr) => address == Some(self_addr),
@@ -80,15 +80,18 @@ impl EventSignatureWithTopics {
 
         address_matches
             && self.signature == sig
-            && self.topic1.as_ref().map_or(true, |t1| {
-                topics.get(1).map_or(false, |topic| t1.contains(topic))
-            })
-            && self.topic2.as_ref().map_or(true, |t2| {
-                topics.get(2).map_or(false, |topic| t2.contains(topic))
-            })
-            && self.topic3.as_ref().map_or(true, |t3| {
-                topics.get(3).map_or(false, |topic| t3.contains(topic))
-            })
+            && self
+                .topic1
+                .as_ref()
+                .is_none_or(|t1| topics.get(1).is_some_and(|topic| t1.contains(topic)))
+            && self
+                .topic2
+                .as_ref()
+                .is_none_or(|t2| topics.get(2).is_some_and(|topic| t2.contains(topic)))
+            && self
+                .topic3
+                .as_ref()
+                .is_none_or(|t3| topics.get(3).is_some_and(|topic| t3.contains(topic)))
     }
 }
 
@@ -390,7 +393,7 @@ impl EthereumLogFilter {
         &self,
         event_signature: &H256,
         contract_address: Option<&Address>,
-        topics: &Vec<H256>,
+        topics: &[H256],
     ) -> bool {
         // Check for wildcard events first.
         if self.wildcard_events.get(event_signature) == Some(&true) {
@@ -536,10 +539,8 @@ impl EthereumLogFilter {
         // Handle events with topic filters.
         filters.extend(
             self.events_with_topic_filters
-                .into_iter()
-                .map(|(event_with_topics, _)| {
-                    EthGetLogsFilter::from_event_with_topics(event_with_topics)
-                }),
+                .into_keys()
+                .map(EthGetLogsFilter::from_event_with_topics),
         );
 
         // The current algorithm is to repeatedly find the maximum cardinality vertex and turn all
@@ -614,16 +615,16 @@ pub struct EthereumCallFilter {
     pub wildcard_signatures: HashSet<FunctionSelector>,
 }
 
-impl Into<Vec<CallToFilter>> for EthereumCallFilter {
-    fn into(self) -> Vec<CallToFilter> {
-        if self.is_empty() {
+impl From<EthereumCallFilter> for Vec<CallToFilter> {
+    fn from(val: EthereumCallFilter) -> Self {
+        if val.is_empty() {
             return Vec::new();
         }
 
         let EthereumCallFilter {
             contract_addresses_function_signatures,
             wildcard_signatures,
-        } = self;
+        } = val;
 
         let mut filters: Vec<CallToFilter> = contract_addresses_function_signatures
             .into_iter()
@@ -771,14 +772,13 @@ impl FromIterator<(BlockNumber, Address, FunctionSelector)> for EthereumCallFilt
             .for_each(|(start_block, address, function_signature)| {
                 lookup
                     .entry(address)
+                    .and_modify(|set| {
+                        if set.0 > start_block {
+                            set.0 = start_block
+                        }
+                        set.1.insert(function_signature);
+                    })
                     .or_insert((start_block, HashSet::default()));
-                lookup.get_mut(&address).map(|set| {
-                    if set.0 > start_block {
-                        set.0 = start_block
-                    }
-                    set.1.insert(function_signature);
-                    set
-                });
             });
         EthereumCallFilter {
             contract_addresses_function_signatures: lookup,
@@ -810,9 +810,9 @@ pub struct EthereumBlockFilter {
     pub trigger_every_block: bool,
 }
 
-impl Into<Vec<CallToFilter>> for EthereumBlockFilter {
-    fn into(self) -> Vec<CallToFilter> {
-        self.contract_addresses
+impl From<EthereumBlockFilter> for Vec<CallToFilter> {
+    fn from(val: EthereumBlockFilter) -> Self {
+        val.contract_addresses
             .into_iter()
             .map(|(_, addr)| addr)
             .sorted()
@@ -847,9 +847,8 @@ impl EthereumBlockFilter {
                     .block_handlers
                     .clone()
                     .into_iter()
-                    .any(|block_handler| match block_handler.filter {
-                        Some(BlockHandlerFilter::Call) => true,
-                        _ => false,
+                    .any(|block_handler| {
+                        matches!(block_handler.filter, Some(BlockHandlerFilter::Call))
                     });
 
                 let has_block_handler_without_filter = data_source
@@ -1411,7 +1410,7 @@ mod tests {
             filter.event_signatures.sort();
         }
         assert_eq!(expected_log_filters, actual_log_filters);
-        assert_eq!(true, actual_send_all_block_headers);
+        assert!(actual_send_all_block_headers);
     }
 
     #[test]
@@ -1478,7 +1477,7 @@ mod tests {
         }
         assert_eq!(expected_log_filters, actual_log_filters);
 
-        assert_eq!(true, actual_send_all_block_headers);
+        assert!(actual_send_all_block_headers);
     }
 
     #[test]
@@ -1505,76 +1504,63 @@ mod tests {
             wildcard_signatures: HashSet::from_iter(vec![[11u8; 4]]),
         };
 
-        assert_eq!(
-            false,
-            filter.matches(&call(address(2), vec![])),
+        assert!(
+            !filter.matches(&call(address(2), vec![])),
             "call with empty bytes are always ignore, whatever the condition"
         );
 
-        assert_eq!(
-            false,
-            filter.matches(&call(address(4), vec![1; 36])),
+        assert!(
+            !filter.matches(&call(address(4), vec![1; 36])),
             "call with incorrect address should be ignored"
         );
 
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(1), vec![1; 36])),
             "call with correct address & signature should match"
         );
 
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(1), vec![1; 32])),
             "call with correct address & signature, but with incorrect input size should match"
         );
 
-        assert_eq!(
-            false,
-            filter.matches(&call(address(1), vec![4u8; 36])),
+        assert!(
+            !filter.matches(&call(address(1), vec![4u8; 36])),
             "call with correct address but incorrect signature for a specific contract filter (i.e. matches some signatures) should be ignored"
         );
 
-        assert_eq!(
-            false,
-            filter.matches(&call(address(0), vec![11u8; 36])),
+        assert!(
+            !filter.matches(&call(address(0), vec![11u8; 36])),
             "this signature should not match filter1, this avoid false passes if someone changes the code"
         );
-        assert_eq!(
-            false,
-            filter2.matches(&call(address(1), vec![10u8; 36])),
+        assert!(
+            !filter2.matches(&call(address(1), vec![10u8; 36])),
             "this signature should not match filter2 because the address is not the expected one"
         );
-        assert_eq!(
-            true,
+        assert!(
             filter2.matches(&call(address(0), vec![10u8; 36])),
             "this signature should match filter2 on the non wildcard clause"
         );
-        assert_eq!(
-            true,
+        assert!(
             filter2.matches(&call(address(0), vec![11u8; 36])),
             "this signature should match filter2 on the wildcard clause"
         );
 
         // extend filter1 and test the filter 2 stuff again
         filter.extend(filter2);
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(0), vec![11u8; 36])),
             "this signature should not match filter1, this avoid false passes if someone changes the code"
         );
-        assert_eq!(
-            false,
-            filter.matches(&call(address(1), vec![10u8; 36])),
+        assert!(
+            !filter.matches(&call(address(1), vec![10u8; 36])),
             "this signature should not match filter2 because the address is not the expected one"
         );
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(0), vec![10u8; 36])),
             "this signature should match filter2 on the non wildcard clause"
         );
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(0), vec![11u8; 36])),
             "this signature should match filter2 on the wildcard clause"
         );
@@ -1674,7 +1660,7 @@ mod tests {
 
         base.extend(extension);
 
-        assert_eq!(true, base.trigger_every_block);
+        assert!(base.trigger_every_block);
     }
 
     #[test]
@@ -1694,7 +1680,7 @@ mod tests {
 
         base.extend(extension);
 
-        assert_eq!(true, base.trigger_every_block);
+        assert!(base.trigger_every_block);
         assert_eq!(
             HashSet::from_iter(vec![(10, address(2))]),
             base.contract_addresses,
@@ -1718,7 +1704,7 @@ mod tests {
 
         base.extend(extension);
 
-        assert_eq!(true, base.trigger_every_block);
+        assert!(base.trigger_every_block);
         assert_eq!(
             HashSet::from_iter(vec![(10, address(2)), (10, address(1))]),
             base.contract_addresses,

chain/ethereum/src/buffered_call_cache.rs

@@ -61,7 +61,7 @@ impl EthereumCallCache for BufferedCallCache {
             return Ok(Some(value));
         }
 
-        let result = self.call_cache.get_call(&call, block).await?;
+        let result = self.call_cache.get_call(call, block).await?;
 
         let mut buffer = self.buffer.lock().unwrap();
         if let Some(call::Response {

chain/ethereum/src/chain.rs

@@ -746,7 +746,7 @@ async fn fetch_unique_blocks_from_cache(
     // Load blocks from the cache
     let blocks_map = chain_store
         .cheap_clone()
-        .block_ptrs_by_numbers(block_numbers.iter().map(|&b| b.into()).collect::<Vec<_>>())
+        .block_ptrs_by_numbers(block_numbers.iter().copied().collect::<Vec<_>>())
         .await
         .map_err(|e| {
             error!(logger, "Error accessing block cache {}", e);