Revert blob changes

Author: eserilev

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -102,7 +102,6 @@ use safe_arith::SafeArith;
 use slasher::Slasher;
 use slot_clock::SlotClock;
 use ssz::Encode;
-use ssz_types::RuntimeVariableList;
 use state_processing::{
     BlockSignatureStrategy, ConsensusContext, SigVerifiedOp, VerifyBlockRoot, VerifyOperation,
     common::get_attesting_indices_from_state,
@@ -1267,19 +1266,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 Ok(None)
             }
         } else {
-            let max_blobs = self.spec.max_blobs_per_block(block.epoch());
-            let blobs = self.get_blobs(block_root)?.blobs();
-            match blobs {
-                Some(blobs) => {
-                    let list: Vec<_> = blobs
-                        .into_iter()
-                        .map(|blob| Arc::new(BlobSidecar::Deneb((*blob).clone())))
-                        .collect();
-                    let blob_sidecar_list = RuntimeVariableList::new(list, max_blobs as usize)?;
-                    Ok(Some(blob_sidecar_list))
-                }
-                None => Ok(None),
-            }
+            Ok(self.get_blobs(block_root)?.blobs())
         }
     }
 
@@ -3128,7 +3115,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
     fn emit_sse_blob_sidecar_events<'a, I>(self: &Arc<Self>, block_root: &Hash256, blobs_iter: I)
     where
-        I: Iterator<Item = &'a BlobSidecarDeneb<T::EthSpec>>,
+        I: Iterator<Item = &'a BlobSidecar<T::EthSpec>>,
     {
         if let Some(event_handler) = self.event_handler.as_ref()
             && event_handler.has_blob_sidecar_subscribers()
@@ -3528,7 +3515,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     fn check_blob_header_signature_and_slashability<'a>(
         self: &Arc<Self>,
         block_root: Hash256,
-        blobs: impl IntoIterator<Item = &'a BlobSidecarDeneb<T::EthSpec>>,
+        blobs: impl IntoIterator<Item = &'a BlobSidecar<T::EthSpec>>,
     ) -> Result<(), BlockError> {
         let mut slashable_cache = self.observed_slashable.write();
         for header in blobs

beacon_node/beacon_chain/src/blob_verification.rs

@@ -7,7 +7,7 @@ use std::sync::Arc;
 use std::time::Duration;
 use tracing::instrument;
 use tree_hash::TreeHash;
-use types::{BeaconStateError, BlobSidecar, BlobSidecarDeneb, EthSpec, Hash256, Slot};
+use types::{BeaconStateError, BlobSidecar, EthSpec, Hash256, Slot};
 
 /// An error occurred while validating a gossip blob.
 #[derive(Debug)]
@@ -151,7 +151,7 @@ impl From<BeaconStateError> for GossipBlobError {
 #[educe(PartialEq, Eq)]
 #[ssz(struct_behaviour = "transparent")]
 pub struct KzgVerifiedBlob<E: EthSpec> {
-    blob: Arc<BlobSidecarDeneb<E>>,
+    blob: Arc<BlobSidecar<E>>,
     #[ssz(skip_serializing, skip_deserializing)]
     seen_timestamp: Duration,
 }
@@ -170,23 +170,23 @@ impl<E: EthSpec> Ord for KzgVerifiedBlob<E> {
 
 impl<E: EthSpec> KzgVerifiedBlob<E> {
     pub fn new(
-        blob: Arc<BlobSidecarDeneb<E>>,
+        blob: Arc<BlobSidecar<E>>,
         kzg: &Kzg,
         seen_timestamp: Duration,
     ) -> Result<Self, KzgError> {
         verify_kzg_for_blob(blob, kzg, seen_timestamp)
     }
-    pub fn to_blob(self) -> Arc<BlobSidecarDeneb<E>> {
+    pub fn to_blob(self) -> Arc<BlobSidecar<E>> {
         self.blob
     }
-    pub fn as_blob(&self) -> &BlobSidecarDeneb<E> {
+    pub fn as_blob(&self) -> &BlobSidecar<E> {
         &self.blob
     }
     pub fn get_commitment(&self) -> &KzgCommitment {
         &self.blob.kzg_commitment
     }
     /// This is cheap as we're calling clone on an Arc
-    pub fn clone_blob(&self) -> Arc<BlobSidecarDeneb<E>> {
+    pub fn clone_blob(&self) -> Arc<BlobSidecar<E>> {
         self.blob.clone()
     }
     pub fn blob_index(&self) -> u64 {
@@ -199,18 +199,15 @@ impl<E: EthSpec> KzgVerifiedBlob<E> {
     ///
     /// This should ONLY be used for testing.
     #[cfg(test)]
-    pub fn __assumed_valid(blob: Arc<BlobSidecarDeneb<E>>) -> Self {
+    pub fn __assumed_valid(blob: Arc<BlobSidecar<E>>) -> Self {
         Self {
             blob,
             seen_timestamp: Duration::from_secs(0),
         }
     }
     /// Mark a blob as KZG verified. Caller must ONLY use this on blob sidecars constructed
     /// from EL blobs.
-    pub fn from_execution_verified(
-        blob: Arc<BlobSidecarDeneb<E>>,
-        seen_timestamp: Duration,
-    ) -> Self {
+    pub fn from_execution_verified(blob: Arc<BlobSidecar<E>>, seen_timestamp: Duration) -> Self {
         Self {
             blob,
             seen_timestamp,
@@ -222,7 +219,7 @@ impl<E: EthSpec> KzgVerifiedBlob<E> {
 ///
 /// Returns an error if the kzg verification check fails.
 pub fn verify_kzg_for_blob<E: EthSpec>(
-    blob: Arc<BlobSidecarDeneb<E>>,
+    blob: Arc<BlobSidecar<E>>,
     kzg: &Kzg,
     seen_timestamp: Duration,
 ) -> Result<KzgVerifiedBlob<E>, KzgError> {
@@ -238,7 +235,7 @@ pub struct KzgVerifiedBlobList<E: EthSpec> {
 }
 
 impl<E: EthSpec> KzgVerifiedBlobList<E> {
-    pub fn new<I: IntoIterator<Item = Arc<BlobSidecarDeneb<E>>>>(
+    pub fn new<I: IntoIterator<Item = Arc<BlobSidecar<E>>>>(
         blob_list: I,
         kzg: &Kzg,
         seen_timestamp: Duration,
@@ -284,7 +281,7 @@ pub fn verify_kzg_for_blob_list<'a, E: EthSpec, I>(
     kzg: &'a Kzg,
 ) -> Result<(), KzgError>
 where
-    I: Iterator<Item = &'a Arc<BlobSidecarDeneb<E>>>,
+    I: Iterator<Item = &'a Arc<BlobSidecar<E>>>,
 {
     let (blobs, (commitments, proofs)): (Vec<_>, (Vec<_>, Vec<_>)) = blob_iter
         .map(|blob| (&blob.blob, (blob.kzg_commitment, blob.kzg_proof)))

beacon_node/beacon_chain/src/block_verification_types.rs

@@ -9,7 +9,7 @@ use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 use types::data::BlobIdentifier;
 use types::{
-    BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarListDeneb, Epoch, EthSpec, Hash256,
+    BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarList, Epoch, EthSpec, Hash256,
     SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
 };
 
@@ -60,7 +60,7 @@ impl<E: EthSpec> RpcBlock<E> {
         }
     }
 
-    pub fn blobs(&self) -> Option<&BlobSidecarListDeneb<E>> {
+    pub fn blobs(&self) -> Option<&BlobSidecarList<E>> {
         match &self.block {
             RpcBlockInner::Block(_) => None,
             RpcBlockInner::BlockAndBlobs(_, blobs) => Some(blobs),
@@ -87,7 +87,7 @@ enum RpcBlockInner<E: EthSpec> {
     Block(Arc<SignedBeaconBlock<E>>),
     /// This variant is used with parent lookups and by-range responses. It should have all blobs
     /// ordered, all block roots matching, and the correct number of blobs for this block.
-    BlockAndBlobs(Arc<SignedBeaconBlock<E>>, BlobSidecarListDeneb<E>),
+    BlockAndBlobs(Arc<SignedBeaconBlock<E>>, BlobSidecarList<E>),
     /// This variant is used with parent lookups and by-range responses. It should have all
     /// requested data columns, all block roots matching for this block.
     BlockAndCustodyColumns(Arc<SignedBeaconBlock<E>>, CustodyDataColumnList<E>),
@@ -115,7 +115,7 @@ impl<E: EthSpec> RpcBlock<E> {
     pub fn new(
         block_root: Option<Hash256>,
         block: Arc<SignedBeaconBlock<E>>,
-        blobs: Option<BlobSidecarListDeneb<E>>,
+        blobs: Option<BlobSidecarList<E>>,
     ) -> Result<Self, AvailabilityCheckError> {
         let block_root = block_root.unwrap_or_else(|| get_block_root(&block));
         // Treat empty blob lists as if they are missing.
@@ -177,7 +177,7 @@ impl<E: EthSpec> RpcBlock<E> {
     ) -> (
         Hash256,
         Arc<SignedBeaconBlock<E>>,
-        Option<BlobSidecarListDeneb<E>>,
+        Option<BlobSidecarList<E>>,
         Option<CustodyDataColumnList<E>>,
     ) {
         let block_root = self.block_root();

beacon_node/beacon_chain/src/builder.rs

@@ -35,15 +35,13 @@ use rand::RngCore;
 use rayon::prelude::*;
 use slasher::Slasher;
 use slot_clock::{SlotClock, TestingSlotClock};
-use ssz_types::RuntimeVariableList;
 use state_processing::{AllCaches, per_slot_processing};
 use std::marker::PhantomData;
 use std::sync::Arc;
 use std::time::Duration;
 use store::{Error as StoreError, HotColdDB, ItemStore, KeyValueStoreOp};
 use task_executor::{ShutdownReason, TaskExecutor};
 use tracing::{debug, error, info};
-use types::BlobSidecar;
 use types::data::CustodyIndex;
 use types::{
     BeaconBlock, BeaconState, BlobSidecarList, ChainSpec, ColumnIndex, DataColumnSidecarList,
@@ -508,7 +506,7 @@ where
                 if commitments
                     .iter()
                     .zip(blobs.iter())
-                    .any(|(commitment, blob)| *commitment != *blob.kzg_commitment())
+                    .any(|(commitment, blob)| *commitment != blob.kzg_commitment)
                 {
                     return Err("Checkpoint blob does not match block commitment".into());
                 }
@@ -597,18 +595,6 @@ where
                     .put_data_columns(&weak_subj_block_root, data_columns)
                     .map_err(|e| format!("Failed to store weak subjectivity data_column: {e:?}"))?;
             } else {
-                let blobs = blobs
-                    .into_iter()
-                    .filter_map(|b| match b.as_ref() {
-                        BlobSidecar::Deneb(blob) => Some(Arc::new(blob.clone())),
-                        BlobSidecar::Gloas(_) => None,
-                    })
-                    .collect::<Vec<_>>();
-
-                let max_blobs = self.spec.max_blobs_per_block(weak_subj_block.epoch()) as usize;
-                let blobs = RuntimeVariableList::new(blobs, max_blobs)
-                    .map_err(|e| format!("failed to store weak subjectivity blobs: {e:?}"))?;
-
                 store
                     .put_blobs(&weak_subj_block_root, blobs)
                     .map_err(|e| format!("Failed to store weak subjectivity blobs: {e:?}"))?;
@@ -1209,7 +1195,7 @@ fn build_data_columns_from_blobs<E: EthSpec>(
         .into_par_iter()
         .map(|blob_sidecar| {
             let kzg_blob_ref = blob_sidecar
-                .blob()
+                .blob
                 .as_ref()
                 .try_into()
                 .map_err(|e| format!("Failed to convert blob to kzg blob: {e:?}"))?;

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -19,7 +19,7 @@ use task_executor::TaskExecutor;
 use tracing::{debug, error, instrument};
 use types::data::{BlobIdentifier, FixedBlobSidecarList};
 use types::{
-    BlobSidecarDeneb, BlobSidecarListDeneb, BlockImportSource, ChainSpec, DataColumnSidecar,
+    BlobSidecar, BlobSidecarList, BlockImportSource, ChainSpec, DataColumnSidecar,
     DataColumnSidecarList, Epoch, EthSpec, Hash256, SignedBeaconBlock, Slot,
 };
 
@@ -195,7 +195,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
     pub fn get_blob(
         &self,
         blob_id: &BlobIdentifier,
-    ) -> Result<Option<Arc<BlobSidecarDeneb<T::EthSpec>>>, AvailabilityCheckError> {
+    ) -> Result<Option<Arc<BlobSidecar<T::EthSpec>>>, AvailabilityCheckError> {
         self.availability_cache.peek_blob(blob_id)
     }
 
@@ -734,7 +734,7 @@ 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(BlobSidecarListDeneb<E>),
+    Blobs(BlobSidecarList<E>),
     /// Block is post-PeerDAS and has more than zero blobs
     DataColumns(DataColumnSidecarList<E>),
 }

beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

@@ -20,7 +20,7 @@ use tracing::{Span, debug, debug_span};
 use types::data::BlobIdentifier;
 use types::kzg_ext::KzgCommitments;
 use types::{
-    BlobSidecarDeneb, BlockImportSource, ChainSpec, ColumnIndex, DataColumnSidecar,
+    BlobSidecar, BlockImportSource, ChainSpec, ColumnIndex, DataColumnSidecar,
     DataColumnSidecarList, Epoch, EthSpec, Hash256, SignedBeaconBlock,
 };
 
@@ -452,7 +452,7 @@ impl<T: BeaconChainTypes> DataAvailabilityCheckerInner<T> {
     pub fn peek_blob(
         &self,
         blob_id: &BlobIdentifier,
-    ) -> Result<Option<Arc<BlobSidecarDeneb<T::EthSpec>>>, AvailabilityCheckError> {
+    ) -> Result<Option<Arc<BlobSidecar<T::EthSpec>>>, AvailabilityCheckError> {
         if let Some(pending_components) = self.critical.read().peek(&blob_id.block_root) {
             Ok(pending_components
                 .verified_blobs
@@ -1315,8 +1315,8 @@ mod pending_components_tests {
 
     type Setup<E> = (
         SignedBeaconBlock<E>,
-        RuntimeFixedVector<Option<Arc<BlobSidecarDeneb<E>>>>,
-        RuntimeFixedVector<Option<Arc<BlobSidecarDeneb<E>>>>,
+        RuntimeFixedVector<Option<Arc<BlobSidecar<E>>>>,
+        RuntimeFixedVector<Option<Arc<BlobSidecar<E>>>>,
         usize,
     );
 
@@ -1326,7 +1326,7 @@ mod pending_components_tests {
         let (block, blobs_vec) =
             generate_rand_block_and_blobs::<E>(ForkName::Deneb, NumBlobs::Random, &mut rng);
         let max_len = spec.max_blobs_per_block(block.epoch()) as usize;
-        let mut blobs: RuntimeFixedVector<Option<Arc<BlobSidecarDeneb<E>>>> =
+        let mut blobs: RuntimeFixedVector<Option<Arc<BlobSidecar<E>>>> =
             RuntimeFixedVector::default(max_len);
 
         for blob in blobs_vec {
@@ -1335,7 +1335,7 @@ mod pending_components_tests {
             }
         }
 
-        let mut invalid_blobs: RuntimeFixedVector<Option<Arc<BlobSidecarDeneb<E>>>> =
+        let mut invalid_blobs: RuntimeFixedVector<Option<Arc<BlobSidecar<E>>>> =
             RuntimeFixedVector::default(max_len);
         for (index, blob) in blobs.iter().enumerate() {
             if let Some(invalid_blob) = blob {
@@ -1356,8 +1356,8 @@ mod pending_components_tests {
 
     pub fn setup_pending_components(
         block: SignedBeaconBlock<E>,
-        valid_blobs: RuntimeFixedVector<Option<Arc<BlobSidecarDeneb<E>>>>,
-        invalid_blobs: RuntimeFixedVector<Option<Arc<BlobSidecarDeneb<E>>>>,
+        valid_blobs: RuntimeFixedVector<Option<Arc<BlobSidecar<E>>>>,
+        invalid_blobs: RuntimeFixedVector<Option<Arc<BlobSidecar<E>>>>,
     ) -> PendingComponentsSetup<E> {
         let blobs = RuntimeFixedVector::new(
             valid_blobs

beacon_node/beacon_chain/src/early_attester_cache.rs

@@ -87,7 +87,7 @@ pub struct CacheItem<E: EthSpec> {
      * Values used to make the block available.
      */
     block: Arc<SignedBeaconBlock<E>>,
-    blobs: Option<BlobSidecarListDeneb<E>>,
+    blobs: Option<BlobSidecarList<E>>,
     data_columns: Option<DataColumnSidecarList<E>>,
     proto_block: ProtoBlock,
 }
@@ -229,7 +229,7 @@ impl<E: EthSpec> EarlyAttesterCache<E> {
     }
 
     /// Returns the blobs, if `block_root` matches the cached item.
-    pub fn get_blobs(&self, block_root: Hash256) -> Option<BlobSidecarListDeneb<E>> {
+    pub fn get_blobs(&self, block_root: Hash256) -> Option<BlobSidecarList<E>> {
         self.item
             .read()
             .as_ref()