fix lints

beacon_node/beacon_chain/src/blob_verification.rs

@@ -1,6 +1,5 @@
 use derivative::Derivative;
 use slot_clock::SlotClock;
-use ssz_types::FixedVector;
 use state_processing::state_advance::partial_state_advance;
 use std::sync::Arc;
 
@@ -15,7 +14,7 @@ use crate::kzg_utils::{validate_blob, validate_blobs};
 use crate::BeaconChainError;
 use kzg::Kzg;
 use std::borrow::Cow;
-use types::blob_sidecar::BlobIdentifier;
+use types::blob_sidecar::{BlobIdentifier, FixedBlobSidecarList};
 use types::{
     BeaconBlockRef, BeaconState, BeaconStateError, BlobSidecar, ChainSpec, CloneConfig, Epoch,
     EthSpec, Hash256, KzgCommitment, RelativeEpoch, SignedBeaconBlock, SignedBeaconBlockHeader,
@@ -588,19 +587,11 @@ impl<E: EthSpec> AsBlock<E> for &MaybeAvailableBlock<E> {
 #[derivative(Hash(bound = "E: EthSpec"))]
 pub enum BlockWrapper<E: EthSpec> {
     Block(Arc<SignedBeaconBlock<E>>),
-    BlockAndBlobs(
+    BlockAndBlobs(Arc<SignedBeaconBlock<E>>, FixedBlobSidecarList<E>),
-        Arc<SignedBeaconBlock<E>>,
-        FixedVector<Option<Arc<BlobSidecar<E>>>, E::MaxBlobsPerBlock>,
-    ),
 }
 
 impl<E: EthSpec> BlockWrapper<E> {
-    pub fn deconstruct(
+    pub fn deconstruct(self) -> (Arc<SignedBeaconBlock<E>>, Option<FixedBlobSidecarList<E>>) {
-        self,
-    ) -> (
-        Arc<SignedBeaconBlock<E>>,
-        Option<FixedVector<Option<Arc<BlobSidecar<E>>>, E::MaxBlobsPerBlock>>,
-    ) {
         match self {
             BlockWrapper::Block(block) => (block, None),
             BlockWrapper::BlockAndBlobs(block, blobs) => (block, Some(blobs)),

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -14,7 +14,7 @@ use std::collections::hash_map::{Entry, OccupiedEntry};
 use std::collections::HashMap;
 use std::sync::Arc;
 use types::beacon_block_body::KzgCommitments;
-use types::blob_sidecar::{BlobIdentifier, BlobSidecar};
+use types::blob_sidecar::{BlobIdentifier, BlobSidecar, FixedBlobSidecarList};
 use types::consts::deneb::MIN_EPOCHS_FOR_BLOBS_SIDECARS_REQUESTS;
 use types::{
     BeaconBlockRef, BlobSidecarList, ChainSpec, Epoch, EthSpec, ExecPayload, FullPayload, Hash256,
@@ -170,7 +170,7 @@ impl<T: EthSpec, S: SlotClock> DataAvailabilityChecker<T, S> {
         &self,
         block_root: Hash256,
         block: Arc<SignedBeaconBlock<T>>,
-        blobs: FixedVector<Option<Arc<BlobSidecar<T>>>, T::MaxBlobsPerBlock>,
+        blobs: FixedBlobSidecarList<T>,
     ) -> Result<BlockWrapper<T>, AvailabilityCheckError> {
         Ok(match self.get_blob_requirements(&block)? {
             BlobRequirements::EmptyBlobs => BlockWrapper::Block(block),
@@ -226,17 +226,15 @@ impl<T: EthSpec, S: SlotClock> DataAvailabilityChecker<T, S> {
     pub fn put_rpc_blobs(
         &self,
         block_root: Hash256,
-        blobs: FixedVector<Option<Arc<BlobSidecar<T>>>, T::MaxBlobsPerBlock>,
+        blobs: FixedBlobSidecarList<T>,
     ) -> Result<Availability<T>, AvailabilityCheckError> {
         // TODO(sean) we may duplicated kzg verification on some blobs we already have cached so we could optimize this
 
         let mut verified_blobs = vec![];
         if let Some(kzg) = self.kzg.as_ref() {
-            for blob_opt in blobs.into_iter() {
+            for blob in blobs.iter().flatten() {
-                if let Some(blob) = blob_opt {
                 verified_blobs.push(verify_kzg_for_blob(blob.clone(), kzg)?)
             }
-            }
         } else {
             return Err(AvailabilityCheckError::KzgNotInitialized);
         };
@@ -396,11 +394,7 @@ impl<T: EthSpec, S: SlotClock> DataAvailabilityChecker<T, S> {
                     .kzg
                     .as_ref()
                     .ok_or(AvailabilityCheckError::KzgNotInitialized)?;
-                let filtered_blobs = blob_list
+                let filtered_blobs = blob_list.iter().flatten().cloned().collect();
-                    .to_vec()
-                    .into_iter()
-                    .filter_map(|blob| blob)
-                    .collect();
                 let verified_blobs = verify_kzg_for_blob_list(filtered_blobs, kzg)?;
 
                 Ok(MaybeAvailableBlock::Available(
@@ -695,11 +689,7 @@ impl<E: EthSpec> AsBlock<E> for AvailableBlock<E> {
     fn into_block_wrapper(self) -> BlockWrapper<E> {
         let (block, blobs_opt) = self.deconstruct();
         if let Some(blobs) = blobs_opt {
-            let blobs_vec = blobs
+            let blobs_vec = blobs.iter().cloned().map(Option::Some).collect::<Vec<_>>();
-                .to_vec()
-                .into_iter()
-                .map(Option::Some)
-                .collect::<Vec<_>>();
             BlockWrapper::BlockAndBlobs(block, FixedVector::from(blobs_vec))
         } else {
             BlockWrapper::Block(block)

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

@@ -12,6 +12,7 @@ use beacon_chain::{
     test_utils::{build_log, BeaconChainHarness, EphemeralHarnessType},
 };
 pub use genesis::{interop_genesis_state, DEFAULT_ETH1_BLOCK_HASH};
+use lighthouse_network::rpc::RPCResponseErrorCode;
 use lighthouse_network::{NetworkGlobals, Request};
 use slot_clock::TestingSlotClock;
 use std::time::Duration;

consensus/types/src/blob_sidecar.rs

@@ -5,7 +5,7 @@ use kzg::{KzgCommitment, KzgProof};
 use serde_derive::{Deserialize, Serialize};
 use ssz::Encode;
 use ssz_derive::{Decode, Encode};
-use ssz_types::VariableList;
+use ssz_types::{FixedVector, VariableList};
 use std::sync::Arc;
 use test_random_derive::TestRandom;
 use tree_hash_derive::TreeHash;
@@ -74,6 +74,8 @@ impl<T: EthSpec> Ord for BlobSidecar<T> {
 }
 
 pub type BlobSidecarList<T> = VariableList<Arc<BlobSidecar<T>>, <T as EthSpec>::MaxBlobsPerBlock>;
+pub type FixedBlobSidecarList<T> =
+    FixedVector<Option<Arc<BlobSidecar<T>>>, <T as EthSpec>::MaxBlobsPerBlock>;
 pub type Blobs<T> = VariableList<Blob<T>, <T as EthSpec>::MaxExtraDataBytes>;
 
 impl<T: EthSpec> SignedRoot for BlobSidecar<T> {}