clippy

Author: kevaundray

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -3671,7 +3671,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let availability = self
             .data_availability_checker
             .put_verified_execution_proofs(block_root, std::iter::once(proof))
-            .map_err(|e| BlockError::AvailabilityCheck(e))?;
+            .map_err(BlockError::AvailabilityCheck)?;
 
         self.process_availability(slot, availability, publish_fn)
             .await

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -121,6 +121,7 @@ impl<E: EthSpec> Debug for Availability<E> {
 }
 
 impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         complete_blob_backfill: bool,
         slot_clock: T::SlotClock,
@@ -464,7 +465,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                         "Proof verification failed: proof is invalid"
                     );
                     return Err(AvailabilityCheckError::InvalidProof {
-                        proof_id: proof_id,
+                        proof_id,
                         reason: "Proof verification returns false".to_string(),
                     });
                 }

beacon_node/beacon_chain/src/observed_execution_proofs.rs

@@ -85,7 +85,7 @@ impl ObservedExecutionProofs {
         }
 
         let key = ProofKey::new(slot, block_root);
-        let proof_ids = self.items.entry(key).or_insert_with(HashSet::new);
+        let proof_ids = self.items.entry(key).or_default();
 
         let was_duplicate = !proof_ids.insert(proof_id);
 

beacon_node/lighthouse_network/tests/rpc_tests.rs

@@ -1894,7 +1894,7 @@ fn test_tcp_execution_proofs_by_root_chunked() {
 
         let block_root = Hash256::random();
         let block_hash = ExecutionBlockHash::from_root(Hash256::random());
-        let proof_ids = vec![
+        let proof_ids = [
             ExecutionProofId::new(0).unwrap(),
             ExecutionProofId::new(1).unwrap(),
             ExecutionProofId::new(2).unwrap(),

beacon_node/network/src/network_beacon_processor/rpc_methods.rs

@@ -437,21 +437,18 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         let count_needed = request.count_needed as usize;
 
         // Get all execution proofs we have for this block from the DA checker
-        let available_proofs = match self
+        let Some(available_proofs) = self
             .chain
             .data_availability_checker
             .get_execution_proofs(&block_root)
-        {
-            Some(proofs) => proofs,
-            None => {
-                // No proofs available for this block
-                debug!(
-                    %peer_id,
-                    %block_root,
-                    "No execution proofs available for peer"
-                );
-                return Ok(());
-            }
+        else {
+            // No proofs available for this block
+            debug!(
+                %peer_id,
+                %block_root,
+                "No execution proofs available for peer"
+            );
+            return Ok(());
         };
 
         // Filter out proofs the peer already has and send up to count_needed

beacon_node/network/src/network_beacon_processor/sync_methods.rs

@@ -1006,7 +1006,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         self: Arc<NetworkBeaconProcessor<T>>,
         block_root: Hash256,
         proofs: Vec<Arc<types::ExecutionProof>>,
-        seen_timestamp: Duration,
+        _seen_timestamp: Duration,
         process_type: BlockProcessType,
     ) {
         // Get slot directly from the first proof. All proofs should be for the same block.

beacon_node/network/src/sync/block_lookups/single_block_lookup.rs

@@ -262,10 +262,8 @@ impl<T: BeaconChainTypes> SingleBlockLookup<T> {
                 }
 
                 if cx.chain.should_fetch_execution_proofs(block_epoch) {
-                    if let Some(min_proofs) = cx.chain.min_execution_proofs_required() {
-                        self.proof_request =
-                            Some(ProofRequestState::new(self.block_root, min_proofs));
-                    }
+                    self.proof_request = cx.chain.min_execution_proofs_required()
+                        .map(|min_proofs| ProofRequestState::new(self.block_root, min_proofs));
                 }
             } else {
                 // Wait to download the block before downloading blobs. Then we can be sure that the

beacon_node/network/src/sync/tests/lookups.rs

@@ -577,19 +577,10 @@ impl TestRig {
     pub(super) fn expect_proof_lookup_request(&mut self, block_root: Hash256) -> SingleLookupReqId {
         self.pop_received_network_event(|ev| match ev {
             NetworkMessage::SendRequest {
-                request,
+                request: RequestType::ExecutionProofsByRoot(req),
                 app_request_id: AppRequestId::Sync(SyncRequestId::SingleExecutionProof { id }),
                 ..
-            } => match request {
-                RequestType::ExecutionProofsByRoot(req) => {
-                    if req.block_root == block_root {
-                        Some(*id)
-                    } else {
-                        None
-                    }
-                }
-                _ => None,
-            },
+            } if req.block_root == block_root => Some(*id),
             _ => None,
         })
         .unwrap_or_else(|_| panic!("Expected proof request for {block_root}"))

beacon_node/proof_generation_service/src/lib.rs

@@ -162,16 +162,13 @@ impl<T: BeaconChainTypes> ProofGenerationService<T> {
         let chain = self.chain.clone();
 
         // Get the generator for this proof type
-        let generator = match registry.get_generator(proof_id) {
-            Some(gen) => gen,
-            None => {
-                debug!(
-                    slot = ?slot,
-                    proof_id = ?proof_id,
-                    "No generator found for proof type"
-                );
-                return;
-            }
+        let Some(generator) = registry.get_generator(proof_id) else {
+            debug!(
+                slot = ?slot,
+                proof_id = ?proof_id,
+                "No generator found for proof type"
+            );
+            return;
         };
 
         // Spawn the generation task (async because generator.generate() is async)
@@ -293,12 +290,11 @@ mod tests {
 
     /// Create a test harness with minimal setup
     fn build_test_harness(validator_count: usize) -> TestHarness {
-        let harness = BeaconChainHarness::builder(E::default())
+        BeaconChainHarness::builder(E)
             .default_spec()
             .deterministic_keypairs(validator_count)
             .fresh_ephemeral_store()
-            .build();
-        harness
+            .build()
     }
 
     #[tokio::test]
@@ -316,9 +312,8 @@ mod tests {
         let proof_id = ExecutionProofId::new(0).unwrap();
 
         // Should return false for a proof that hasn't been observed
-        assert_eq!(
-            service.check_if_proof_exists(slot, block_root, proof_id),
-            false
+        assert!(
+            !service.check_if_proof_exists(slot, block_root, proof_id)
         );
     }
 
@@ -344,9 +339,8 @@ mod tests {
             .unwrap();
 
         // Should return true for an observed proof
-        assert_eq!(
-            service.check_if_proof_exists(slot, block_root, proof_id),
-            true
+        assert!(
+            service.check_if_proof_exists(slot, block_root, proof_id)
         );
     }
 

beacon_node/src/config.rs

@@ -354,7 +354,7 @@ pub fn get_config<E: EthSpec>(
                     )
                 })?
                 .into_iter()
-                .map(|id| ExecutionProofId::new(id))
+                .map(ExecutionProofId::new)
                 .collect::<Result<HashSet<_>, _>>()
                 .map_err(|e| format!("Invalid subnet ID: {}", e))?
         } else {