I just yeeted a bunch of code

Author: eserilev

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -102,6 +102,7 @@ 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,
@@ -1130,19 +1131,16 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         if let Some(mut all_cached_columns) = all_cached_columns_opt {
             all_cached_columns.retain(|col| indices.contains(col.index()));
             Ok(all_cached_columns)
-        } else {
-            if let Some(block) = self.get_blinded_block(&block_root)? {
-                indices
+        } else if let Some(block) = self.get_blinded_block(&block_root)? {
+            indices
                 .iter()
                 .filter_map(|index| {
                     self.get_data_column(&block_root, index, block.fork_name_unchecked())
                         .transpose()
                 })
                 .collect::<Result<_, _>>()
-            } else {
-                Ok(vec![])
-            }
-           
+        } else {
+            Ok(vec![])
         }
     }
 
@@ -1269,7 +1267,19 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 Ok(None)
             }
         } else {
-            self.get_blobs(block_root).map(|b| b.blobs())
+            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),
+            }
         }
     }
 
@@ -3064,24 +3074,18 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
 
         for blob in &blobs {
-            if let Some(blob) = blob {
-                match blob.as_ref() {
-                    // Reject RPC blobs referencing unknown parents. Otherwise we allow potentially invalid data
-                    // into the da_checker, where invalid = descendant of invalid blocks.
-                    // Note: blobs should have at least one item and all items have the same parent root.
-                    BlobSidecar::Deneb(blob) => {
-                        if !self
-                            .canonical_head
-                            .fork_choice_read_lock()
-                            .contains_block(&blob.block_parent_root())
-                        {
-                            return Err(BlockError::ParentUnknown {
-                                parent_root: blob.block_parent_root(),
-                            });
-                        }
-                    }
-                    // Dont need to handle the Gloas variant, since blobs wont be served over RPC post-Fulu
-                    _ => {}
+            if let Some(blob) = blob.as_ref() {
+                // Reject RPC blobs referencing unknown parents. Otherwise we allow potentially invalid data
+                // into the da_checker, where invalid = descendant of invalid blocks.
+                // Note: blobs should have at least one item and all items have the same parent root.
+                if !self
+                    .canonical_head
+                    .fork_choice_read_lock()
+                    .contains_block(&blob.block_parent_root())
+                {
+                    return Err(BlockError::ParentUnknown {
+                        parent_root: blob.block_parent_root(),
+                    });
                 }
             }
         }
@@ -3124,7 +3128,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 BlobSidecar<T::EthSpec>>,
+        I: Iterator<Item = &'a BlobSidecarDeneb<T::EthSpec>>,
     {
         if let Some(event_handler) = self.event_handler.as_ref()
             && event_handler.has_blob_sidecar_subscribers()
@@ -3133,7 +3137,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 .data_availability_checker
                 .cached_blob_indexes(block_root)
                 .unwrap_or_default();
-            let new_blobs = blobs_iter.filter(|b| !imported_blobs.contains(b.index()));
+            let new_blobs = blobs_iter.filter(|b| !imported_blobs.contains(&b.index));
 
             for blob in new_blobs {
                 event_handler.register(EventKind::BlobSidecar(SseBlobSidecar::from_blob_sidecar(
@@ -3561,10 +3565,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     ) -> Result<AvailabilityProcessingStatus, BlockError> {
         self.check_blob_header_signature_and_slashability(
             block_root,
-            blobs.iter().flatten().filter_map(|b| match b.as_ref() {
-                BlobSidecar::Deneb(blob) => Some(blob),
-                _ => None,
-            }),
+            blobs.iter().flatten().map(|b| b.as_ref()),
         )?;
         let availability = self
             .data_availability_checker
@@ -7347,7 +7348,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     }
 
     /// Retrieves block roots (in ascending slot order) within some slot range from fork choice.
-    pub fn block_roots_from_fork_choice(&self, start_slot: u64, count: u64) -> Vec<Hash256> {
+    pub fn block_roots_from_fork_choice(
+        &self,
+        start_slot: u64,
+        count: u64,
+    ) -> Vec<(Hash256, Slot)> {
         let head_block_root = self.canonical_head.cached_head().head_block_root();
         let fork_choice_read_lock = self.canonical_head.fork_choice_read_lock();
         let block_roots_iter = fork_choice_read_lock
@@ -7358,7 +7363,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         for (root, slot) in block_roots_iter {
             if slot < end_slot && slot >= start_slot {
-                roots.push(root);
+                roots.push((root, slot));
             }
             if slot < start_slot {
                 break;

beacon_node/beacon_chain/src/blob_verification.rs

@@ -1,24 +1,13 @@
-use educe::Educe;
-use slot_clock::SlotClock;
-use std::marker::PhantomData;
-use std::sync::Arc;
-
-use crate::beacon_chain::{BeaconChain, BeaconChainTypes};
-use crate::block_verification::{
-    BlockSlashInfo, get_validator_pubkey_cache, process_block_slash_info,
-};
 use crate::kzg_utils::{validate_blob, validate_blobs};
-use crate::observed_data_sidecars::{ObservationStrategy, Observe};
 use crate::{BeaconChainError, metrics};
+use educe::Educe;
 use kzg::{Error as KzgError, Kzg, KzgCommitment};
 use ssz_derive::{Decode, Encode};
+use std::sync::Arc;
 use std::time::Duration;
-use tracing::{debug, instrument};
+use tracing::instrument;
 use tree_hash::TreeHash;
-use types::data::BlobIdentifier;
-use types::{
-    BeaconStateError, BlobSidecar, Epoch, EthSpec, Hash256, SignedBeaconBlockHeader, Slot,
-};
+use types::{BeaconStateError, BlobSidecar, BlobSidecarDeneb, EthSpec, Hash256, Slot};
 
 /// An error occurred while validating a gossip blob.
 #[derive(Debug)]
@@ -162,7 +151,7 @@ impl From<BeaconStateError> for GossipBlobError {
 #[educe(PartialEq, Eq)]
 #[ssz(struct_behaviour = "transparent")]
 pub struct KzgVerifiedBlob<E: EthSpec> {
-    blob: Arc<BlobSidecar<E>>,
+    blob: Arc<BlobSidecarDeneb<E>>,
     #[ssz(skip_serializing, skip_deserializing)]
     seen_timestamp: Duration,
 }
@@ -181,27 +170,27 @@ impl<E: EthSpec> Ord for KzgVerifiedBlob<E> {
 
 impl<E: EthSpec> KzgVerifiedBlob<E> {
     pub fn new(
-        blob: Arc<BlobSidecar<E>>,
+        blob: Arc<BlobSidecarDeneb<E>>,
         kzg: &Kzg,
         seen_timestamp: Duration,
     ) -> Result<Self, KzgError> {
         verify_kzg_for_blob(blob, kzg, seen_timestamp)
     }
-    pub fn to_blob(self) -> Arc<BlobSidecar<E>> {
+    pub fn to_blob(self) -> Arc<BlobSidecarDeneb<E>> {
         self.blob
     }
-    pub fn as_blob(&self) -> &BlobSidecar<E> {
+    pub fn as_blob(&self) -> &BlobSidecarDeneb<E> {
         &self.blob
     }
     pub fn get_commitment(&self) -> &KzgCommitment {
-        &self.blob.kzg_commitment()
+        &self.blob.kzg_commitment
     }
     /// This is cheap as we're calling clone on an Arc
-    pub fn clone_blob(&self) -> Arc<BlobSidecar<E>> {
+    pub fn clone_blob(&self) -> Arc<BlobSidecarDeneb<E>> {
         self.blob.clone()
     }
     pub fn blob_index(&self) -> u64 {
-        *self.blob.index()
+        self.blob.index
     }
     pub fn seen_timestamp(&self) -> Duration {
         self.seen_timestamp
@@ -210,15 +199,18 @@ impl<E: EthSpec> KzgVerifiedBlob<E> {
     ///
     /// This should ONLY be used for testing.
     #[cfg(test)]
-    pub fn __assumed_valid(blob: Arc<BlobSidecar<E>>) -> Self {
+    pub fn __assumed_valid(blob: Arc<BlobSidecarDeneb<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<BlobSidecar<E>>, seen_timestamp: Duration) -> Self {
+    pub fn from_execution_verified(
+        blob: Arc<BlobSidecarDeneb<E>>,
+        seen_timestamp: Duration,
+    ) -> Self {
         Self {
             blob,
             seen_timestamp,
@@ -230,11 +222,11 @@ impl<E: EthSpec> KzgVerifiedBlob<E> {
 ///
 /// Returns an error if the kzg verification check fails.
 pub fn verify_kzg_for_blob<E: EthSpec>(
-    blob: Arc<BlobSidecar<E>>,
+    blob: Arc<BlobSidecarDeneb<E>>,
     kzg: &Kzg,
     seen_timestamp: Duration,
 ) -> Result<KzgVerifiedBlob<E>, KzgError> {
-    validate_blob::<E>(kzg, blob.blob(), *blob.kzg_commitment(), *blob.kzg_proof())?;
+    validate_blob::<E>(kzg, &blob.blob, blob.kzg_commitment, blob.kzg_proof)?;
     Ok(KzgVerifiedBlob {
         blob,
         seen_timestamp,
@@ -246,7 +238,7 @@ pub struct KzgVerifiedBlobList<E: EthSpec> {
 }
 
 impl<E: EthSpec> KzgVerifiedBlobList<E> {
-    pub fn new<I: IntoIterator<Item = Arc<BlobSidecar<E>>>>(
+    pub fn new<I: IntoIterator<Item = Arc<BlobSidecarDeneb<E>>>>(
         blob_list: I,
         kzg: &Kzg,
         seen_timestamp: Duration,
@@ -292,10 +284,10 @@ pub fn verify_kzg_for_blob_list<'a, E: EthSpec, I>(
     kzg: &'a Kzg,
 ) -> Result<(), KzgError>
 where
-    I: Iterator<Item = &'a Arc<BlobSidecar<E>>>,
+    I: Iterator<Item = &'a Arc<BlobSidecarDeneb<E>>>,
 {
     let (blobs, (commitments, proofs)): (Vec<_>, (Vec<_>, Vec<_>)) = blob_iter
-        .map(|blob| (blob.blob(), (*blob.kzg_commitment(), *blob.kzg_proof())))
+        .map(|blob| (&blob.blob, (blob.kzg_commitment, blob.kzg_proof)))
         .unzip();
     validate_blobs::<E>(kzg, commitments.as_slice(), blobs, proofs.as_slice())
 }

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, BlobSidecarList, Epoch, EthSpec, Hash256,
+    BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarListDeneb, Epoch, EthSpec, Hash256,
     SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
 };
 
@@ -60,7 +60,7 @@ impl<E: EthSpec> RpcBlock<E> {
         }
     }
 
-    pub fn blobs(&self) -> Option<&BlobSidecarList<E>> {
+    pub fn blobs(&self) -> Option<&BlobSidecarListDeneb<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>>, BlobSidecarList<E>),
+    BlockAndBlobs(Arc<SignedBeaconBlock<E>>, BlobSidecarListDeneb<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<BlobSidecarList<E>>,
+        blobs: Option<BlobSidecarListDeneb<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.
@@ -129,7 +129,7 @@ impl<E: EthSpec> RpcBlock<E> {
                 return Err(AvailabilityCheckError::MissingBlobs);
             }
             for (blob, &block_commitment) in blobs.iter().zip(block_commitments.iter()) {
-                let blob_commitment = *blob.kzg_commitment();
+                let blob_commitment = blob.kzg_commitment;
                 if blob_commitment != block_commitment {
                     return Err(AvailabilityCheckError::KzgCommitmentMismatch {
                         block_commitment,
@@ -177,7 +177,7 @@ impl<E: EthSpec> RpcBlock<E> {
     ) -> (
         Hash256,
         Arc<SignedBeaconBlock<E>>,
-        Option<BlobSidecarList<E>>,
+        Option<BlobSidecarListDeneb<E>>,
         Option<CustodyDataColumnList<E>>,
     ) {
         let block_root = self.block_root();

beacon_node/beacon_chain/src/builder.rs

@@ -35,13 +35,15 @@ 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,
@@ -595,6 +597,18 @@ 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:?}"))?;

beacon_node/beacon_chain/src/data_availability_checker.rs

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