lint fix

Author: kevaundray

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -4154,17 +4154,16 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         if let Some(proofs) = self
             .data_availability_checker
             .get_execution_proofs(&block_root)
+            && !proofs.is_empty()
         {
-            if !proofs.is_empty() {
-                let proofs_owned: Vec<_> = proofs.iter().map(|p| (**p).clone()).collect();
-                if let Err(e) = self.store.put_execution_proofs(&block_root, &proofs_owned) {
-                    // Log but don't fail block import - proofs can still be served from cache
-                    warn!(
-                        %block_root,
-                        error = ?e,
-                        "Failed to persist execution proofs to database"
-                    );
-                }
+            let proofs_owned: Vec<_> = proofs.iter().map(|p| (**p).clone()).collect();
+            if let Err(e) = self.store.put_execution_proofs(&block_root, &proofs_owned) {
+                // Log but don't fail block import - proofs can still be served from cache
+                warn!(
+                    %block_root,
+                    error = ?e,
+                    "Failed to persist execution proofs to database"
+                );
             }
         }
 

beacon_node/lighthouse_network/src/rpc/codec.rs

@@ -1307,6 +1307,9 @@ mod tests {
             RequestType::ExecutionProofsByRoot(exec_proofs) => {
                 assert_eq!(decoded, RequestType::ExecutionProofsByRoot(exec_proofs))
             }
+            RequestType::ExecutionProofsByRange(exec_proofs_range) => {
+                assert_eq!(decoded, RequestType::ExecutionProofsByRange(exec_proofs_range))
+            }
             RequestType::Ping(ping) => {
                 assert_eq!(decoded, RequestType::Ping(ping))
             }

beacon_node/store/src/hot_cold_store.rs

@@ -3730,11 +3730,12 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
             self.blobs_db.do_atomically(db_ops)?;
         }
 
-        if !removed_block_roots.is_empty() {
-            if let Some(mut block_cache) = self.block_cache.as_ref().map(|cache| cache.lock()) {
-                for block_root in removed_block_roots {
-                    block_cache.delete_execution_proofs(&block_root);
-                }
+        // TODO(zkproofs): Fix this to make it more readable
+        if !removed_block_roots.is_empty()
+            && let Some(mut block_cache) = self.block_cache.as_ref().map(|cache| cache.lock())
+        {
+            for block_root in removed_block_roots {
+                block_cache.delete_execution_proofs(&block_root);
             }
         }