lints

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -4857,7 +4857,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     )),
                 )?;
 
-                kzg_utils::compute_blob_kzg_proof::<T::EthSpec>(kzg, blob, kzg_commitment.clone())
+                kzg_utils::compute_blob_kzg_proof::<T::EthSpec>(kzg, blob, *kzg_commitment)
                     .map_err(BlockProductionError::KzgError)
             })
             .collect::<Result<Vec<KzgProof>, BlockProductionError>>()

beacon_node/beacon_chain/src/blob_verification.rs

@@ -3,7 +3,7 @@ use slot_clock::SlotClock;
 use std::sync::Arc;
 
 use crate::beacon_chain::{BeaconChain, BeaconChainTypes, MAXIMUM_GOSSIP_CLOCK_DISPARITY};
-use crate::{kzg_utils, BeaconChainError};
+use crate::BeaconChainError;
 use state_processing::per_block_processing::eip4844::eip4844::verify_kzg_commitments_against_transactions;
 use types::signed_beacon_block::BlobReconstructionError;
 use types::{
@@ -116,11 +116,11 @@ pub fn validate_blob_for_gossip<T: BeaconChainTypes>(
 }
 
 fn verify_data_availability<T: BeaconChainTypes>(
-    blob_sidecar: &BlobsSidecar<T::EthSpec>,
+    _blob_sidecar: &BlobsSidecar<T::EthSpec>,
     kzg_commitments: &[KzgCommitment],
     transactions: &Transactions<T::EthSpec>,
-    block_slot: Slot,
+    _block_slot: Slot,
-    block_root: Hash256,
+    _block_root: Hash256,
     chain: &BeaconChain<T>,
 ) -> Result<(), BlobError> {
     if verify_kzg_commitments_against_transactions::<T::EthSpec>(transactions, kzg_commitments)
@@ -130,7 +130,7 @@ fn verify_data_availability<T: BeaconChainTypes>(
     }
 
     // Validatate that the kzg proof is valid against the commitments and blobs
-    let kzg = chain
+    let _kzg = chain
         .kzg
         .as_ref()
         .ok_or(BlobError::TrustedSetupNotInitialized)?;

beacon_node/http_api/src/build_block_contents.rs

@@ -24,9 +24,9 @@ pub fn build_block_contents<T: BeaconChainTypes, Payload: AbstractExecPayload<T:
 
                 Ok(BlockContents::BlockAndBlobSidecars(block_and_blobs))
             } else {
-                return Err(warp_utils::reject::block_production_error(
+                Err(warp_utils::reject::block_production_error(
                     BlockProductionError::NoBlobsCached,
-                ));
+                ))
             }
         }
     }

beacon_node/network/src/beacon_processor/worker/gossip_methods.rs

@@ -652,12 +652,12 @@ impl<T: BeaconChainTypes> Worker<T> {
     #[allow(clippy::too_many_arguments)]
     pub async fn process_gossip_blob(
         self,
-        message_id: MessageId,
+        _message_id: MessageId,
         peer_id: PeerId,
         peer_client: Client,
         blob_index: u64,
         signed_blob: Arc<SignedBlobSidecar<T::EthSpec>>,
-        seen_duration: Duration,
+        _seen_duration: Duration,
     ) {
         // TODO: gossip verification
         crit!(self.log, "UNIMPLEMENTED gossip blob verification";

beacon_node/network/src/beacon_processor/worker/rpc_methods.rs

@@ -252,7 +252,7 @@ impl<T: BeaconChainTypes> Worker<T> {
                                         block_parent_root: block.parent_root,
                                         proposer_index: block.proposer_index,
                                         blob,
-                                        kzg_commitment: block.body.blob_kzg_commitments[known_index].clone(), // TODO: needs to be stored in a more logical way so that this won't panic.
+                                        kzg_commitment: block.body.blob_kzg_commitments[known_index], // TODO: needs to be stored in a more logical way so that this won't panic.
                                         kzg_proof: kzg_aggregated_proof // TODO: yeah
                                     };
                                     self.send_response(
@@ -843,7 +843,7 @@ impl<T: BeaconChainTypes> Worker<T> {
                         beacon_block_root,
                         beacon_block_slot,
                         blobs: blob_bundle,
-                        kzg_aggregated_proof,
+                        kzg_aggregated_proof: _,
                     }: types::BlobsSidecar<_> = blobs;
 
                     for (blob_index, blob) in blob_bundle.into_iter().enumerate() {

beacon_node/network/src/sync/block_sidecar_coupling.rs

@@ -32,7 +32,7 @@ impl<T: EthSpec> BlocksAndBlobsRequestInfo<T> {
     pub fn into_responses(self) -> Result<Vec<TempBlockWrapper<T>>, &'static str> {
         let BlocksAndBlobsRequestInfo {
             accumulated_blocks,
-            mut accumulated_sidecars,
+            accumulated_sidecars,
             ..
         } = self;
 

beacon_node/network/src/sync/manager.rs

@@ -875,8 +875,8 @@ impl<T: BeaconChainTypes> SyncManager<T> {
     fn rpc_blobs_received(
         &mut self,
         request_id: RequestId,
-        peer_id: PeerId,
+        _peer_id: PeerId,
-        maybe_blob: Option<Arc<BlobSidecar<<T>::EthSpec>>>,
+        _maybe_blob: Option<Arc<BlobSidecar<<T>::EthSpec>>>,
         _seen_timestamp: Duration,
     ) {
         match request_id {
@@ -892,7 +892,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             RequestId::RangeBlocks { .. } => {
                 unreachable!("Only-blocks range requests don't receive sidecars")
             }
-            RequestId::RangeBlobs { id } => {
+            RequestId::RangeBlobs { id: _ } => {
                 unimplemented!("Adjust range");
             }
         }

consensus/types/src/signed_block_contents.rs

@@ -4,6 +4,11 @@ use derivative::Derivative;
 use serde_derive::{Deserialize, Serialize};
 use ssz_types::VariableList;
 
+pub type BlockContentsTuple<T, Payload> = (
+    SignedBeaconBlock<T, Payload>,
+    Option<VariableList<SignedBlobSidecar<T>, <T as EthSpec>::MaxBlobsPerBlock>>,
+);
+
 /// A wrapper over a [`SignedBeaconBlock`] or a [`SignedBeaconBlockAndBlobSidecars`].
 #[derive(Clone, Debug, Derivative, Serialize, Deserialize)]
 #[derivative(PartialEq, Hash(bound = "T: EthSpec"))]
@@ -24,12 +29,7 @@ impl<T: EthSpec, Payload: AbstractExecPayload<T>> SignedBlockContents<T, Payload
         }
     }
 
-    pub fn deconstruct(
+    pub fn deconstruct(self) -> BlockContentsTuple<T, Payload> {
-        self,
-    ) -> (
-        SignedBeaconBlock<T, Payload>,
-        Option<VariableList<SignedBlobSidecar<T>, <T as EthSpec>::MaxBlobsPerBlock>>,
-    ) {
         match self {
             SignedBlockContents::BlockAndBlobSidecars(block_and_sidecars) => (
                 block_and_sidecars.signed_block,

validator_client/src/block_service.rs

@@ -388,7 +388,6 @@ impl<T: SlotClock + 'static, E: EthSpec> BlockService<T, E> {
                                     ))
                                 })?
                                 .data
-                                .into()
                         }
                     };
 
@@ -455,7 +454,7 @@ impl<T: SlotClock + 'static, E: EthSpec> BlockService<T, E> {
                             );
                             beacon_node
                                 // TODO: need to be adjusted for blobs
-                                .post_beacon_blinded_blocks(&signed_block_contents.signed_block())
+                                .post_beacon_blinded_blocks(signed_block_contents.signed_block())
                                 .await
                                 .map_err(|e| {
                                     BlockError::Irrecoverable(format!(