peerdas-devnet-7: update DataColumnSidecarsByRoot request to use DataColumnsByRootIdentifier (#7399)

Update DataColumnSidecarsByRoot request to use DataColumnsByRootIdentifier #7377


  As described in https://github.com/ethereum/consensus-specs/pull/4284

consensus/types/src/chain_spec.rs

@@ -1,6 +1,6 @@
 use crate::application_domain::{ApplicationDomain, APPLICATION_DOMAIN_BUILDER};
 use crate::blob_sidecar::BlobIdentifier;
-use crate::data_column_sidecar::DataColumnIdentifier;
+use crate::data_column_sidecar::DataColumnsByRootIdentifier;
 use crate::*;
 use int_to_bytes::int_to_bytes4;
 use safe_arith::{ArithError, SafeArith};
@@ -1754,15 +1754,21 @@ fn max_blobs_by_root_request_common(max_request_blob_sidecars: u64) -> usize {
     .len()
 }
 
-fn max_data_columns_by_root_request_common(max_request_data_column_sidecars: u64) -> usize {
-    let max_request_data_column_sidecars = max_request_data_column_sidecars as usize;
-    let empty_data_column_id = DataColumnIdentifier {
+fn max_data_columns_by_root_request_common(
+    max_request_blocks: u64,
+    number_of_columns: u64,
+) -> usize {
+    let max_request_blocks = max_request_blocks as usize;
+    let number_of_columns = number_of_columns as usize;
+
+    let empty_data_columns_by_root_id = DataColumnsByRootIdentifier {
         block_root: Hash256::zero(),
-        index: 0,
+        columns: RuntimeVariableList::from_vec(vec![0; number_of_columns], number_of_columns),
     };
-    RuntimeVariableList::from_vec(
-        vec![empty_data_column_id; max_request_data_column_sidecars],
-        max_request_data_column_sidecars,
+
+    RuntimeVariableList::<DataColumnsByRootIdentifier>::from_vec(
+        vec![empty_data_columns_by_root_id; max_request_blocks],
+        max_request_blocks,
     )
     .as_ssz_bytes()
     .len()
@@ -1781,7 +1787,10 @@ fn default_max_blobs_by_root_request() -> usize {
 }
 
 fn default_data_columns_by_root_request() -> usize {
-    max_data_columns_by_root_request_common(default_max_request_data_column_sidecars())
+    max_data_columns_by_root_request_common(
+        default_max_request_blocks_deneb(),
+        default_number_of_columns(),
+    )
 }
 
 impl Default for Config {
@@ -2082,7 +2091,8 @@ impl Config {
             ),
             max_blobs_by_root_request: max_blobs_by_root_request_common(max_request_blob_sidecars),
             max_data_columns_by_root_request: max_data_columns_by_root_request_common(
-                max_request_data_column_sidecars,
+                max_request_blocks_deneb,
+                number_of_columns,
             ),
 
             number_of_columns,

consensus/types/src/data_column_sidecar.rs

@@ -1,7 +1,9 @@
 use crate::beacon_block_body::{KzgCommitments, BLOB_KZG_COMMITMENTS_INDEX};
 use crate::test_utils::TestRandom;
-use crate::BeaconStateError;
-use crate::{BeaconBlockHeader, Epoch, EthSpec, Hash256, SignedBeaconBlockHeader, Slot};
+use crate::{
+    BeaconBlockHeader, BeaconStateError, Epoch, EthSpec, Hash256, RuntimeVariableList,
+    SignedBeaconBlockHeader, Slot,
+};
 use bls::Signature;
 use derivative::Derivative;
 use kzg::Error as KzgError;
@@ -9,11 +11,10 @@ use kzg::{KzgCommitment, KzgProof};
 use merkle_proof::verify_merkle_proof;
 use safe_arith::ArithError;
 use serde::{Deserialize, Serialize};
-use ssz::Encode;
+use ssz::{DecodeError, Encode};
 use ssz_derive::{Decode, Encode};
 use ssz_types::Error as SszError;
 use ssz_types::{FixedVector, VariableList};
-use std::hash::Hash;
 use std::sync::Arc;
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
@@ -23,13 +24,47 @@ pub type ColumnIndex = u64;
 pub type Cell<E> = FixedVector<u8, <E as EthSpec>::BytesPerCell>;
 pub type DataColumn<E> = VariableList<Cell<E>, <E as EthSpec>::MaxBlobCommitmentsPerBlock>;
 
-/// Container of the data that identifies an individual data column.
-#[derive(
-    Serialize, Deserialize, Encode, Decode, TreeHash, Copy, Clone, Debug, PartialEq, Eq, Hash,
-)]
-pub struct DataColumnIdentifier {
+/// Identifies a set of data columns associated with a specific beacon block.
+#[derive(Encode, Clone, Debug, PartialEq)]
+pub struct DataColumnsByRootIdentifier {
     pub block_root: Hash256,
-    pub index: ColumnIndex,
+    pub columns: RuntimeVariableList<ColumnIndex>,
+}
+
+impl RuntimeVariableList<DataColumnsByRootIdentifier> {
+    pub fn from_ssz_bytes_with_nested(
+        bytes: &[u8],
+        max_len: usize,
+        num_columns: usize,
+    ) -> Result<Self, DecodeError> {
+        if bytes.is_empty() {
+            return Ok(RuntimeVariableList::empty(max_len));
+        }
+
+        let vec = ssz::decode_list_of_variable_length_items::<Vec<u8>, Vec<Vec<u8>>>(
+            bytes,
+            Some(max_len),
+        )?
+        .into_iter()
+        .map(|bytes| {
+            let mut builder = ssz::SszDecoderBuilder::new(&bytes);
+            builder.register_type::<Hash256>()?;
+            builder.register_anonymous_variable_length_item()?;
+
+            let mut decoder = builder.build()?;
+            let block_root = decoder.decode_next()?;
+            let columns = decoder.decode_next_with(|bytes| {
+                RuntimeVariableList::from_ssz_bytes(bytes, num_columns)
+            })?;
+            Ok(DataColumnsByRootIdentifier {
+                block_root,
+                columns,
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(RuntimeVariableList::from_vec(vec, max_len))
+    }
 }
 
 pub type DataColumnSidecarList<E> = Vec<Arc<DataColumnSidecar<E>>>;
@@ -132,13 +167,6 @@ impl<E: EthSpec> DataColumnSidecar<E> {
         .as_ssz_bytes()
         .len()
     }
-
-    pub fn id(&self) -> DataColumnIdentifier {
-        DataColumnIdentifier {
-            block_root: self.block_root(),
-            index: self.index,
-        }
-    }
 }
 
 #[derive(Debug)]
@@ -178,3 +206,45 @@ impl From<SszError> for DataColumnSidecarError {
         Self::SszError(e)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use bls::FixedBytesExtended;
+
+    #[test]
+    fn round_trip_dcbroot_list() {
+        let max_outer = 5;
+        let max_inner = 10;
+
+        let data = vec![
+            DataColumnsByRootIdentifier {
+                block_root: Hash256::from_low_u64_be(10),
+                columns: RuntimeVariableList::<ColumnIndex>::from_vec(vec![1u64, 2, 3], max_inner),
+            },
+            DataColumnsByRootIdentifier {
+                block_root: Hash256::from_low_u64_be(20),
+                columns: RuntimeVariableList::<ColumnIndex>::from_vec(vec![4u64, 5], max_inner),
+            },
+        ];
+
+        let list = RuntimeVariableList::from_vec(data.clone(), max_outer);
+
+        let ssz_bytes = list.as_ssz_bytes();
+
+        let decoded =
+            RuntimeVariableList::<DataColumnsByRootIdentifier>::from_ssz_bytes_with_nested(
+                &ssz_bytes, max_outer, max_inner,
+            )
+            .expect("should decode list of DataColumnsByRootIdentifier");
+
+        assert_eq!(decoded.len(), data.len());
+        for (original, decoded) in data.iter().zip(decoded.iter()) {
+            assert_eq!(decoded.block_root, original.block_root);
+            assert_eq!(
+                decoded.columns.iter().copied().collect::<Vec<_>>(),
+                original.columns.iter().copied().collect::<Vec<_>>()
+            );
+        }
+    }
+}

consensus/types/src/lib.rs

@@ -149,7 +149,7 @@ pub use crate::config_and_preset::{
 pub use crate::consolidation_request::ConsolidationRequest;
 pub use crate::contribution_and_proof::ContributionAndProof;
 pub use crate::data_column_sidecar::{
-    ColumnIndex, DataColumnIdentifier, DataColumnSidecar, DataColumnSidecarList,
+    ColumnIndex, DataColumnSidecar, DataColumnSidecarList, DataColumnsByRootIdentifier,
 };
 pub use crate::data_column_subnet_id::DataColumnSubnetId;
 pub use crate::deposit::{Deposit, DEPOSIT_TREE_DEPTH};