Fulu update to spec v1.6.0-alpha.4 (#7890)

Fulu update to spec [v1.6.0-alpha.4](https://github.com/ethereum/consensus-specs/releases/tag/v1.6.0-alpha.4).
- Make `number_of_columns` a preset
- Optimise `get_custody_groups` to avoid computing if cgc = 128
- Add support for additional typenum values in type_dispatch macro

Author: jimmygchen

beacon_node/beacon_chain/benches/benches.rs

@@ -7,15 +7,15 @@ use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use bls::Signature;
 use kzg::{KzgCommitment, KzgProof};
 use types::{
-    BeaconBlock, BeaconBlockDeneb, Blob, BlobsList, ChainSpec, EmptyBlock, EthSpec, KzgProofs,
+    BeaconBlock, BeaconBlockFulu, Blob, BlobsList, ChainSpec, EmptyBlock, EthSpec, KzgProofs,
     MainnetEthSpec, SignedBeaconBlock, beacon_block_body::KzgCommitments,
 };
 
 fn create_test_block_and_blobs<E: EthSpec>(
     num_of_blobs: usize,
     spec: &ChainSpec,
 ) -> (SignedBeaconBlock<E>, BlobsList<E>, KzgProofs<E>) {
-    let mut block = BeaconBlock::Deneb(BeaconBlockDeneb::empty(spec));
+    let mut block = BeaconBlock::Fulu(BeaconBlockFulu::empty(spec));
     let mut body = block.body_mut();
     let blob_kzg_commitments = body.blob_kzg_commitments_mut().unwrap();
     *blob_kzg_commitments =
@@ -27,7 +27,7 @@ fn create_test_block_and_blobs<E: EthSpec>(
         .map(|_| Blob::<E>::default())
         .collect::<Vec<_>>()
         .into();
-    let proofs = vec![KzgProof::empty(); num_of_blobs * spec.number_of_columns as usize].into();
+    let proofs = vec![KzgProof::empty(); num_of_blobs * E::number_of_columns()].into();
 
     (signed_block, blobs, proofs)
 }

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -1247,8 +1247,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         if self.spec.is_peer_das_enabled_for_epoch(block.epoch()) {
             if let Some(columns) = self.store.get_data_columns(block_root)? {
-                let num_required_columns = self.spec.number_of_columns / 2;
-                let reconstruction_possible = columns.len() >= num_required_columns as usize;
+                let num_required_columns = T::EthSpec::number_of_columns() / 2;
+                let reconstruction_possible = columns.len() >= num_required_columns;
                 if reconstruction_possible {
                     reconstruct_blobs(&self.kzg, &columns, None, &block, &self.spec)
                         .map(Some)

beacon_node/beacon_chain/src/block_verification_types.rs

@@ -3,13 +3,14 @@ pub use crate::data_availability_checker::{AvailableBlock, MaybeAvailableBlock};
 use crate::data_column_verification::{CustodyDataColumn, CustodyDataColumnList};
 use crate::{PayloadVerificationOutcome, get_block_root};
 use derivative::Derivative;
+use ssz_types::VariableList;
 use state_processing::ConsensusContext;
 use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 use types::blob_sidecar::BlobIdentifier;
 use types::{
-    BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarList, ChainSpec, Epoch, EthSpec,
-    Hash256, RuntimeVariableList, SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
+    BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarList, Epoch, EthSpec, Hash256,
+    SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
 };
 
 /// A block that has been received over RPC. It has 2 internal variants:
@@ -151,7 +152,6 @@ impl<E: EthSpec> RpcBlock<E> {
         block_root: Option<Hash256>,
         block: Arc<SignedBeaconBlock<E>>,
         custody_columns: Vec<CustodyDataColumn<E>>,
-        spec: &ChainSpec,
     ) -> Result<Self, AvailabilityCheckError> {
         let block_root = block_root.unwrap_or_else(|| get_block_root(&block));
 
@@ -161,10 +161,7 @@ impl<E: EthSpec> RpcBlock<E> {
         }
         // Treat empty data column lists as if they are missing.
         let inner = if !custody_columns.is_empty() {
-            RpcBlockInner::BlockAndCustodyColumns(
-                block,
-                RuntimeVariableList::new(custody_columns, spec.number_of_columns as usize)?,
-            )
+            RpcBlockInner::BlockAndCustodyColumns(block, VariableList::new(custody_columns)?)
         } else {
             RpcBlockInner::Block(block)
         };

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -446,7 +446,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
             .map(CustodyDataColumn::into_inner)
             .collect::<Vec<_>>();
         let all_data_columns =
-            RuntimeVariableList::from_vec(all_data_columns, self.spec.number_of_columns as usize);
+            RuntimeVariableList::from_vec(all_data_columns, T::EthSpec::number_of_columns());
 
         // verify kzg for all data columns at once
         if !all_data_columns.is_empty() {

beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

@@ -591,7 +591,7 @@ impl<T: BeaconChainTypes> DataAvailabilityCheckerInner<T> {
         };
 
         // If we're sampling all columns, it means we must be custodying all columns.
-        let total_column_count = self.spec.number_of_columns as usize;
+        let total_column_count = T::EthSpec::number_of_columns();
         let received_column_count = pending_components.verified_data_columns.len();
 
         if pending_components.reconstruction_started {

beacon_node/beacon_chain/src/data_column_verification.rs

@@ -12,14 +12,15 @@ use kzg::{Error as KzgError, Kzg};
 use proto_array::Block;
 use slot_clock::SlotClock;
 use ssz_derive::{Decode, Encode};
+use ssz_types::VariableList;
 use std::iter;
 use std::marker::PhantomData;
 use std::sync::Arc;
 use tracing::{debug, instrument};
 use types::data_column_sidecar::ColumnIndex;
 use types::{
     BeaconStateError, ChainSpec, DataColumnSidecar, DataColumnSubnetId, EthSpec, Hash256,
-    RuntimeVariableList, SignedBeaconBlockHeader, Slot,
+    SignedBeaconBlockHeader, Slot,
 };
 
 /// An error occurred while validating a gossip data column.
@@ -315,7 +316,8 @@ impl<E: EthSpec> KzgVerifiedDataColumn<E> {
     }
 }
 
-pub type CustodyDataColumnList<E> = RuntimeVariableList<CustodyDataColumn<E>>;
+pub type CustodyDataColumnList<E> =
+    VariableList<CustodyDataColumn<E>, <E as EthSpec>::NumberOfColumns>;
 
 /// Data column that we must custody
 #[derive(Debug, Derivative, Clone, Encode, Decode)]
@@ -479,7 +481,7 @@ pub fn validate_data_column_sidecar_for_gossip<T: BeaconChainTypes, O: Observati
     chain: &BeaconChain<T>,
 ) -> Result<GossipVerifiedDataColumn<T, O>, GossipDataColumnError> {
     let column_slot = data_column.slot();
-    verify_data_column_sidecar(&data_column, &chain.spec)?;
+    verify_data_column_sidecar(&data_column)?;
     verify_index_matches_subnet(&data_column, subnet, &chain.spec)?;
     verify_sidecar_not_from_future_slot(chain, column_slot)?;
     verify_slot_greater_than_latest_finalized_slot(chain, column_slot)?;
@@ -533,9 +535,8 @@ pub fn validate_data_column_sidecar_for_gossip<T: BeaconChainTypes, O: Observati
 /// Verify if the data column sidecar is valid.
 fn verify_data_column_sidecar<E: EthSpec>(
     data_column: &DataColumnSidecar<E>,
-    spec: &ChainSpec,
 ) -> Result<(), GossipDataColumnError> {
-    if data_column.index >= spec.number_of_columns {
+    if data_column.index >= E::number_of_columns() as u64 {
         return Err(GossipDataColumnError::InvalidColumnIndex(data_column.index));
     }
     if data_column.kzg_commitments.is_empty() {

beacon_node/beacon_chain/src/kzg_utils.rs

@@ -185,7 +185,7 @@ pub fn blobs_to_data_column_sidecars<E: EthSpec>(
     let signed_block_header = block.signed_block_header();
 
     let proof_chunks = cell_proofs
-        .chunks_exact(spec.number_of_columns as usize)
+        .chunks_exact(E::number_of_columns())
         .collect::<Vec<_>>();
 
     // NOTE: assumes blob sidecars are ordered by index
@@ -243,7 +243,7 @@ pub(crate) fn build_data_column_sidecars<E: EthSpec>(
     blob_cells_and_proofs_vec: Vec<CellsAndKzgProofs>,
     spec: &ChainSpec,
 ) -> Result<DataColumnSidecarList<E>, String> {
-    let number_of_columns = spec.number_of_columns as usize;
+    let number_of_columns = E::number_of_columns();
     let max_blobs_per_block = spec
         .max_blobs_per_block(signed_block_header.message.slot.epoch(E::slots_per_epoch()))
         as usize;
@@ -495,7 +495,7 @@ mod test {
             .kzg_commitments_merkle_proof()
             .unwrap();
 
-        assert_eq!(column_sidecars.len(), spec.number_of_columns as usize);
+        assert_eq!(column_sidecars.len(), E::number_of_columns());
         for (idx, col_sidecar) in column_sidecars.iter().enumerate() {
             assert_eq!(col_sidecar.index, idx as u64);
 
@@ -530,7 +530,7 @@ mod test {
         )
         .unwrap();
 
-        for i in 0..spec.number_of_columns as usize {
+        for i in 0..E::number_of_columns() {
             assert_eq!(reconstructed_columns.get(i), column_sidecars.get(i), "{i}");
         }
     }

beacon_node/beacon_chain/src/observed_data_sidecars.rs

@@ -58,8 +58,8 @@ impl<E: EthSpec> ObservableDataSidecar for DataColumnSidecar<E> {
         self.index
     }
 
-    fn max_num_of_items(spec: &ChainSpec, _slot: Slot) -> usize {
-        spec.number_of_columns as usize
+    fn max_num_of_items(_spec: &ChainSpec, _slot: Slot) -> usize {
+        E::number_of_columns()
     }
 }
 

beacon_node/beacon_chain/src/test_utils.rs

@@ -2358,8 +2358,7 @@ where
                 .into_iter()
                 .map(CustodyDataColumn::from_asserted_custody)
                 .collect::<Vec<_>>();
-            RpcBlock::new_with_custody_columns(Some(block_root), block, custody_columns, &self.spec)
-                .unwrap()
+            RpcBlock::new_with_custody_columns(Some(block_root), block, custody_columns).unwrap()
         } else {
             let blobs = self.chain.get_blobs(&block_root).unwrap().blobs();
             RpcBlock::new(Some(block_root), block, blobs).unwrap()
@@ -2386,7 +2385,7 @@ where
                     .filter(|d| sampling_columns.contains(&d.index))
                     .map(CustodyDataColumn::from_asserted_custody)
                     .collect::<Vec<_>>();
-                RpcBlock::new_with_custody_columns(Some(block_root), block, columns, &self.spec)?
+                RpcBlock::new_with_custody_columns(Some(block_root), block, columns)?
             } else {
                 RpcBlock::new_without_blobs(Some(block_root), block)
             }
@@ -3310,7 +3309,7 @@ fn generate_data_column_sidecars_from_block<E: EthSpec>(
     // load the precomputed column sidecar to avoid computing them for every block in the tests.
     let template_data_columns = RuntimeVariableList::<DataColumnSidecar<E>>::from_ssz_bytes(
         TEST_DATA_COLUMN_SIDECARS_SSZ,
-        spec.number_of_columns as usize,
+        E::number_of_columns(),
     )
     .unwrap();
 

beacon_node/beacon_chain/src/validator_custody.rs

@@ -197,7 +197,7 @@ impl<E: EthSpec> CustodyContext<E> {
     ) -> Result<(), String> {
         let mut ordered_custody_columns = vec![];
         for custody_index in all_custody_groups_ordered {
-            let columns = compute_columns_for_custody_group(custody_index, spec)
+            let columns = compute_columns_for_custody_group::<E>(custody_index, spec)
                 .map_err(|e| format!("Failed to compute columns for custody group {e:?}"))?;
             ordered_custody_columns.extend(columns);
         }
@@ -303,7 +303,7 @@ impl<E: EthSpec> CustodyContext<E> {
     /// Returns the count of columns this node must _sample_ for a block at `epoch` to import.
     pub fn num_of_data_columns_to_sample(&self, epoch: Epoch, spec: &ChainSpec) -> usize {
         let custody_group_count = self.custody_group_count_at_epoch(epoch, spec);
-        spec.sampling_size_columns(custody_group_count)
+        spec.sampling_size_columns::<E>(custody_group_count)
             .expect("should compute node sampling size from valid chain spec")
     }
 
@@ -641,7 +641,7 @@ mod tests {
         let expected_sampling_columns = &all_custody_groups_ordered
             .iter()
             .flat_map(|custody_index| {
-                compute_columns_for_custody_group(*custody_index, &spec)
+                compute_columns_for_custody_group::<E>(*custody_index, &spec)
                     .expect("should compute columns for custody group")
             })
             .collect::<Vec<_>>()[0..sampling_size];