Block availability data enum

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -3170,7 +3170,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
 
         // process_engine_blobs is called for both pre and post PeerDAS. However, post PeerDAS
-        // consumers don't expect the blobs event to fire erraticly.
+        // consumers don't expect the blobs event to fire erratically.
         if !self
             .spec
             .is_peer_das_enabled_for_epoch(slot.epoch(T::EthSpec::slots_per_epoch()))
@@ -7240,7 +7240,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             }
             AvailableBlockData::DataColumns(data_columns) => {
                 debug!(
-                    self.log, "Writing data_columns to store";
+                    self.log, "Writing data columns to store";
                     "block_root" => %block_root,
                     "count" => data_columns.len(),
                 );
@@ -7257,10 +7257,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     .blocking_recv()
                     .map_err(|e| format!("Did not receive data columns from sender: {e:?}"))?;
                 debug!(
-                    self.log, "Writing data_columns to store";
+                    self.log, "Writing data columns to store";
                     "block_root" => %block_root,
                     "count" => computed_data_columns.len(),
                 );
+                // TODO(das): Store only this node's custody columns
                 Ok(Some(StoreOp::PutDataColumns(
                     block_root,
                     computed_data_columns,

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -348,7 +348,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                 Ok(MaybeAvailableBlock::Available(AvailableBlock {
                     block_root,
                     block,
-                    data: AvailableBlockData::Blobs(blob_list),
+                    blob_data: AvailableBlockData::Blobs(blob_list),
                     blobs_available_timestamp: None,
                     spec: self.spec.clone(),
                 }))
@@ -368,7 +368,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                 Ok(MaybeAvailableBlock::Available(AvailableBlock {
                     block_root,
                     block,
-                    data: AvailableBlockData::DataColumns(
+                    blob_data: AvailableBlockData::DataColumns(
                         data_column_list
                             .into_iter()
                             .map(|d| d.clone_arc())
@@ -385,8 +385,8 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         Ok(MaybeAvailableBlock::Available(AvailableBlock {
             block_root,
             block,
+            blob_data: AvailableBlockData::NoData,
             blobs_available_timestamp: None,
-            data: AvailableBlockData::NoData,
             spec: self.spec.clone(),
         }))
     }
@@ -442,7 +442,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                     MaybeAvailableBlock::Available(AvailableBlock {
                         block_root,
                         block,
-                        data: AvailableBlockData::Blobs(blobs),
+                        blob_data: AvailableBlockData::Blobs(blobs),
                         blobs_available_timestamp: None,
                         spec: self.spec.clone(),
                     })
@@ -454,7 +454,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                     MaybeAvailableBlock::Available(AvailableBlock {
                         block_root,
                         block,
-                        data: AvailableBlockData::DataColumns(
+                        blob_data: AvailableBlockData::DataColumns(
                             data_columns.into_iter().map(|d| d.into_inner()).collect(),
                         ),
                         blobs_available_timestamp: None,
@@ -467,7 +467,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                 MaybeAvailableBlock::Available(AvailableBlock {
                     block_root,
                     block,
-                    data: AvailableBlockData::NoData,
+                    blob_data: AvailableBlockData::NoData,
                     blobs_available_timestamp: None,
                     spec: self.spec.clone(),
                 })
@@ -543,11 +543,11 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         &self,
         block_root: &Hash256,
     ) -> Result<DataColumnReconstructionResult<T::EthSpec>, AvailabilityCheckError> {
-        let pending_components = match self
+        let verified_data_columns = match self
             .availability_cache
             .check_and_set_reconstruction_started(block_root)
         {
-            ReconstructColumnsDecision::Yes(pending_components) => pending_components,
+            ReconstructColumnsDecision::Yes(verified_data_columns) => verified_data_columns,
             ReconstructColumnsDecision::No(reason) => {
                 return Ok(DataColumnReconstructionResult::NotStarted(reason));
             }
@@ -558,7 +558,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
 
         let all_data_columns = KzgVerifiedCustodyDataColumn::reconstruct_columns(
             &self.kzg,
-            &pending_components.verified_data_columns,
+            &verified_data_columns,
             &self.spec,
         )
         .map_err(|e| {
@@ -711,41 +711,16 @@ async fn availability_cache_maintenance_service<T: BeaconChainTypes>(
     }
 }
 
-fn verify_kzg_for_data_column_list_with_scoring<'a, E: EthSpec, I>(
-    data_column_iter: I,
-    kzg: &'a Kzg,
-) -> Result<(), AvailabilityCheckError>
-where
-    I: Iterator<Item = &'a Arc<DataColumnSidecar<E>>> + Clone,
-{
-    let Err(batch_err) = verify_kzg_for_data_column_list(data_column_iter.clone(), kzg) else {
-        return Ok(());
-    };
-
-    let data_columns = data_column_iter.collect::<Vec<_>>();
-    // Find which column is invalid. If len is 1 or 0 continue to default case below.
-    // If len > 1 at least one column MUST fail.
-    if data_columns.len() > 1 {
-        for data_column in data_columns {
-            if let Err(e) = verify_kzg_for_data_column(data_column.clone(), kzg) {
-                return Err(AvailabilityCheckError::InvalidColumn(data_column.index, e));
-            }
-        }
-    }
-
-    // len 0 should never happen
-    Err(AvailabilityCheckError::InvalidColumn(0, batch_err))
-}
-
 #[derive(Debug)]
 pub enum AvailableBlockData<E: EthSpec> {
+    /// Block is pre-Deneb or has zero blobs
     NoData,
+    /// Block is post-Deneb, pre-PeerDAS and has more than zero blobs
     Blobs(BlobSidecarList<E>),
+    /// Block is post-PeerDAS and has more than zero blobs
     DataColumns(DataColumnSidecarList<E>),
-    /// An optional receiver for `DataColumnSidecarList`.
-    ///
-    /// This field is `Some` when data columns are being computed asynchronously.
-    /// The resulting `DataColumnSidecarList` will be sent through this receiver.
+    /// Block is post-PeerDAS, has more than zero blobs and we recomputed the columns from the EL's
+    /// mempool blobs
     DataColumnsRecv(oneshot::Receiver<DataColumnSidecarList<E>>),
 }
 
@@ -754,7 +729,7 @@ pub enum AvailableBlockData<E: EthSpec> {
 pub struct AvailableBlock<E: EthSpec> {
     block_root: Hash256,
     block: Arc<SignedBeaconBlock<E>>,
-    data: AvailableBlockData<E>,
+    blob_data: AvailableBlockData<E>,
     /// Timestamp at which this block first became available (UNIX timestamp, time since 1970).
     blobs_available_timestamp: Option<Duration>,
     pub spec: Arc<ChainSpec>,
@@ -770,7 +745,7 @@ impl<E: EthSpec> AvailableBlock<E> {
         Self {
             block_root,
             block,
-            data,
+            blob_data: data,
             blobs_available_timestamp: None,
             spec,
         }
@@ -788,13 +763,13 @@ impl<E: EthSpec> AvailableBlock<E> {
     }
 
     pub fn data(&self) -> &AvailableBlockData<E> {
-        &self.data
+        &self.blob_data
     }
 
     pub fn has_blobs(&self) -> bool {
-        match self.data {
+        match self.blob_data {
             AvailableBlockData::NoData => false,
-            AvailableBlockData::Blobs(_) => true,
+            AvailableBlockData::Blobs(..) => true,
             AvailableBlockData::DataColumns(_) => false,
             AvailableBlockData::DataColumnsRecv(_) => false,
         }
@@ -805,18 +780,18 @@ impl<E: EthSpec> AvailableBlock<E> {
         let AvailableBlock {
             block_root,
             block,
-            data,
+            blob_data,
             ..
         } = self;
-        (block_root, block, data)
+        (block_root, block, blob_data)
     }
 
     /// Only used for testing
     pub fn __clone_without_recv(&self) -> Result<Self, String> {
         Ok(Self {
             block_root: self.block_root,
             block: self.block.clone(),
-            data: match &self.data {
+            blob_data: match &self.blob_data {
                 AvailableBlockData::NoData => AvailableBlockData::NoData,
                 AvailableBlockData::Blobs(blobs) => AvailableBlockData::Blobs(blobs.clone()),
                 AvailableBlockData::DataColumns(data_columns) => {

beacon_node/beacon_chain/src/data_availability_checker/error.rs

@@ -10,7 +10,7 @@ pub enum Error {
         blob_commitment: KzgCommitment,
         block_commitment: KzgCommitment,
     },
-    Unexpected,
+    Unexpected(&'static str),
     SszTypes(ssz_types::Error),
     MissingBlobs,
     MissingCustodyColumns,
@@ -40,7 +40,7 @@ impl Error {
             | Error::MissingCustodyColumns
             | Error::StoreError(_)
             | Error::DecodeError(_)
-            | Error::Unexpected
+            | Error::Unexpected(_)
             | Error::ParentStateMissing(_)
             | Error::BlockReplayError(_)
             | Error::RebuildingStateCaches(_)