all: Run 'cargo clippy --fix --all-targets'

Author: lutter

chain/ethereum/src/adapter.rs

@@ -1410,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]
@@ -1477,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]
@@ -1504,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"
         );
@@ -1673,7 +1660,7 @@ mod tests {
 
         base.extend(extension);
 
-        assert_eq!(true, base.trigger_every_block);
+        assert!(base.trigger_every_block);
     }
 
     #[test]
@@ -1693,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,
@@ -1717,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/codec.rs

@@ -499,6 +499,21 @@ impl BlockchainBlock for HeaderOnlyBlock {
     }
 }
 
+fn get_to_address(trace: &TransactionTrace) -> Result<Option<H160>, Error> {
+    // Try to detect contract creation transactions, which have no 'to' address
+    let is_contract_creation = trace.to.is_empty()
+        || trace
+            .calls
+            .first()
+            .is_some_and(|call| CallType::try_from(call.call_type) == Ok(CallType::Create));
+
+    if is_contract_creation {
+        Ok(None)
+    } else {
+        Ok(Some(trace.to.try_decode_proto("transaction to address")?))
+    }
+}
+
 #[cfg(test)]
 mod test {
     use graph::{blockchain::Block as _, prelude::chrono::Utc};
@@ -529,18 +544,3 @@ mod test {
         );
     }
 }
-
-fn get_to_address(trace: &TransactionTrace) -> Result<Option<H160>, Error> {
-    // Try to detect contract creation transactions, which have no 'to' address
-    let is_contract_creation = trace.to.is_empty()
-        || trace
-            .calls
-            .first()
-            .is_some_and(|call| CallType::try_from(call.call_type) == Ok(CallType::Create));
-
-    if is_contract_creation {
-        Ok(None)
-    } else {
-        Ok(Some(trace.to.try_decode_proto("transaction to address")?))
-    }
-}

chain/ethereum/src/network.rs

@@ -352,35 +352,35 @@ mod tests {
         };
 
         // Test all real combinations of capability comparisons
-        assert_eq!(false, &full >= &archive);
-        assert_eq!(false, &full >= &traces);
-        assert_eq!(false, &full >= &archive_traces);
-        assert_eq!(true, &full >= &full);
-        assert_eq!(false, &full >= &full_traces);
-
-        assert_eq!(true, &archive >= &archive);
-        assert_eq!(false, &archive >= &traces);
-        assert_eq!(false, &archive >= &archive_traces);
-        assert_eq!(true, &archive >= &full);
-        assert_eq!(false, &archive >= &full_traces);
-
-        assert_eq!(false, &traces >= &archive);
-        assert_eq!(true, &traces >= &traces);
-        assert_eq!(false, &traces >= &archive_traces);
-        assert_eq!(true, &traces >= &full);
-        assert_eq!(true, &traces >= &full_traces);
-
-        assert_eq!(true, &archive_traces >= &archive);
-        assert_eq!(true, &archive_traces >= &traces);
-        assert_eq!(true, &archive_traces >= &archive_traces);
-        assert_eq!(true, &archive_traces >= &full);
-        assert_eq!(true, &archive_traces >= &full_traces);
-
-        assert_eq!(false, &full_traces >= &archive);
-        assert_eq!(true, &full_traces >= &traces);
-        assert_eq!(false, &full_traces >= &archive_traces);
-        assert_eq!(true, &full_traces >= &full);
-        assert_eq!(true, &full_traces >= &full_traces);
+        assert!(!(full >= archive));
+        assert!(!(full >= traces));
+        assert!(!(full >= archive_traces));
+        assert!(full >= full);
+        assert!(!(full >= full_traces));
+
+        assert!(archive >= archive);
+        assert!(!(archive >= traces));
+        assert!(!(archive >= archive_traces));
+        assert!(archive >= full);
+        assert!(!(archive >= full_traces));
+
+        assert!(!(traces >= archive));
+        assert!(traces >= traces);
+        assert!(!(traces >= archive_traces));
+        assert!(traces >= full);
+        assert!(traces >= full_traces);
+
+        assert!(archive_traces >= archive);
+        assert!(archive_traces >= traces);
+        assert!(archive_traces >= archive_traces);
+        assert!(archive_traces >= full);
+        assert!(archive_traces >= full_traces);
+
+        assert!(!(full_traces >= archive));
+        assert!(full_traces >= traces);
+        assert!(!(full_traces >= archive_traces));
+        assert!(full_traces >= full);
+        assert!(full_traces >= full_traces);
     }
 
     #[graph::test]
@@ -463,16 +463,15 @@ mod tests {
                 })
                 .await
                 .unwrap();
-            assert_eq!(adapter.is_call_only(), false);
+            assert!(!adapter.is_call_only());
         }
 
         // Check limits
         {
             let adapter = adapters.call_or_cheapest(None).unwrap();
             assert!(adapter.is_call_only());
-            assert_eq!(
-                adapters.call_or_cheapest(None).unwrap().is_call_only(),
-                false
+            assert!(
+                !adapters.call_or_cheapest(None).unwrap().is_call_only()
             );
         }
 
@@ -485,7 +484,7 @@ mod tests {
                     traces: false,
                 }))
                 .unwrap();
-            assert_eq!(adapter.is_call_only(), false);
+            assert!(!adapter.is_call_only());
         }
     }
 
@@ -553,11 +552,11 @@ mod tests {
 
         // verify that after all call_only were exhausted, we can still
         // get normal adapters
-        let keep: Vec<Arc<EthereumAdapter>> = vec![0; 10]
+        let keep: Vec<Arc<EthereumAdapter>> = [0; 10]
             .iter()
             .map(|_| adapters.call_or_cheapest(None).unwrap())
             .collect();
-        assert_eq!(keep.iter().any(|a| !a.is_call_only()), false);
+        assert!(!keep.iter().any(|a| !a.is_call_only()));
     }
 
     #[graph::test]
@@ -621,9 +620,8 @@ mod tests {
         // one reference above and one inside adapters struct
         assert_eq!(Arc::strong_count(&eth_call_adapter), 2);
         assert_eq!(Arc::strong_count(&eth_adapter), 2);
-        assert_eq!(
-            adapters.call_or_cheapest(None).unwrap().is_call_only(),
-            false
+        assert!(
+            !adapters.call_or_cheapest(None).unwrap().is_call_only()
         );
     }
 
@@ -667,9 +665,8 @@ mod tests {
         .await;
         // one reference above and one inside adapters struct
         assert_eq!(Arc::strong_count(&eth_adapter), 2);
-        assert_eq!(
-            adapters.call_or_cheapest(None).unwrap().is_call_only(),
-            false
+        assert!(
+            !adapters.call_or_cheapest(None).unwrap().is_call_only()
         );
     }
 
@@ -690,25 +687,23 @@ mod tests {
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
         let chain_id: Word = "chain_id".into();
 
-        let adapters = vec![
-            fake_adapter(
+        let adapters = [fake_adapter(
                 &logger,
-                &unavailable_provider,
+                unavailable_provider,
                 &provider_metrics,
                 &metrics,
                 false,
             )
             .await,
-            fake_adapter(&logger, &error_provider, &provider_metrics, &metrics, false).await,
+            fake_adapter(&logger, error_provider, &provider_metrics, &metrics, false).await,
             fake_adapter(
                 &logger,
-                &no_error_provider,
+                no_error_provider,
                 &provider_metrics,
                 &metrics,
                 false,
             )
-            .await,
-        ];
+            .await];
 
         // Set errors
         metrics.report_for_test(&ProviderName::from(error_provider), false);
@@ -813,7 +808,7 @@ mod tests {
                 archive: true,
                 traces: false,
             },
-            adapter: fake_adapter(&logger, &error_provider, &provider_metrics, &metrics, false)
+            adapter: fake_adapter(&logger, error_provider, &provider_metrics, &metrics, false)
                 .await,
             limit: SubgraphLimit::Unlimited,
         });
@@ -827,7 +822,7 @@ mod tests {
             },
             adapter: fake_adapter(
                 &logger,
-                &no_error_provider,
+                no_error_provider,
                 &provider_metrics,
                 &metrics,
                 false,
@@ -891,7 +886,7 @@ mod tests {
             },
             adapter: fake_adapter(
                 &logger,
-                &no_error_provider,
+                no_error_provider,
                 &provider_metrics,
                 &metrics,
                 false,
@@ -903,7 +898,7 @@ mod tests {
             logger,
             vec![(
                 chain_id.clone(),
-                no_available_adapter.iter().cloned().collect(),
+                no_available_adapter.to_vec(),
             )]
             .into_iter(),
             ProviderCheckStrategy::MarkAsValid,
@@ -927,7 +922,7 @@ mod tests {
         call_only: bool,
     ) -> Arc<EthereumAdapter> {
         let transport = Transport::new_rpc(
-            Url::parse(&"http://127.0.0.1").unwrap(),
+            Url::parse("http://127.0.0.1").unwrap(),
             HeaderMap::new(),
             endpoint_metrics.clone(),
             "",