Add blobs v2 rpc, update blob index and length check

Author: hangleang

eth2_libp2p

@@ -1710,8 +1710,14 @@ impl<P: Preset> Store<P> {
         let block_header = blob_sidecar.signed_block_header.message;
 
         // [REJECT] The sidecar's index is consistent with MAX_BLOBS_PER_BLOCK -- i.e. blob_sidecar.index < MAX_BLOBS_PER_BLOCK.
+        let max_blobs_per_block =
+            if self.chain_config().phase_at_slot::<P>(block_header.slot) == Phase::Electra {
+                P::MaxBlobsPerBlockElectra::U64
+            } else {
+                P::MaxBlobsPerBlock::U64
+            };
         ensure!(
-            blob_sidecar.index < P::MaxBlobsPerBlock::U64,
+            blob_sidecar.index < max_blobs_per_block,
             Error::BlobSidecarInvalidIndex { blob_sidecar },
         );
 

fork_choice_store/src/store.rs

@@ -951,7 +951,16 @@ impl<P: Preset> Network<P> {
         debug!("received BeaconBlocksByRange request (peer_id: {peer_id}, request: {request:?})");
 
         let start_slot = request.start_slot();
-        let difference = request.count().min(MAX_FOR_DOS_PREVENTION);
+        let max_request_blocks = match request {
+            OldBlocksByRangeRequest::V1(_) => self.controller.chain_config().max_request_blocks,
+            OldBlocksByRangeRequest::V2(_) => {
+                self.controller.chain_config().max_request_blocks_deneb
+            }
+        };
+        let difference = request
+            .count()
+            .min(max_request_blocks)
+            .min(MAX_FOR_DOS_PREVENTION);
 
         // `end_slot` is exclusive.
         let end_slot = start_slot
@@ -1013,17 +1022,28 @@ impl<P: Preset> Network<P> {
     ) -> Result<()> {
         debug!("received BlobSidecarsByRange request (peer_id: {peer_id}, request: {request:?})");
 
-        let BlobsByRangeRequest { start_slot, count } = request;
-        let difference = count
-            .min(self.controller.chain_config().max_request_blob_sidecars)
+        let start_slot = request.start_slot();
+        let max_request_blob_sidecars = match request {
+            BlobsByRangeRequest::V1(_) => self.controller.chain_config().max_request_blob_sidecars,
+            BlobsByRangeRequest::V2(_) => {
+                self.controller
+                    .chain_config()
+                    .max_request_blob_sidecars_electra
+            }
+        };
+        let difference = request
+            .count()
+            .min(max_request_blob_sidecars)
             .min(MAX_FOR_DOS_PREVENTION);
 
-        let end_slot = start_slot
-            .checked_add(difference)
-            .ok_or(Error::EndSlotOverflow {
-                start_slot,
-                difference,
-            })?;
+        let end_slot =
+            request
+                .start_slot()
+                .checked_add(difference)
+                .ok_or(Error::EndSlotOverflow {
+                    start_slot,
+                    difference,
+                })?;
 
         let controller = self.controller.clone_arc();
         let network_to_service_tx = self.network_to_service_tx.clone();
@@ -1078,11 +1098,18 @@ impl<P: Preset> Network<P> {
         debug!("received BlobsByRootRequest request (peer_id: {peer_id}, request: {request:?})");
 
         // TODO(feature/deneb): MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
-        let BlobsByRootRequest { blob_ids } = request;
+        let max_request_blob_sidecars = match request {
+            BlobsByRootRequest::V1(_) => self.controller.chain_config().max_request_blob_sidecars,
+            BlobsByRootRequest::V2(_) => {
+                self.controller
+                    .chain_config()
+                    .max_request_blob_sidecars_electra
+            }
+        };
+        let blob_ids = request.blob_ids();
 
         let controller = self.controller.clone_arc();
         let network_to_service_tx = self.network_to_service_tx.clone();
-        let max_request_blob_sidecars = self.controller.chain_config().max_request_blob_sidecars;
 
         self.dedicated_executor
             .spawn(async move {
@@ -1136,6 +1163,10 @@ impl<P: Preset> Network<P> {
         request_id: IncomingRequestId,
         request: BlocksByRootRequest,
     ) {
+        let max_request_blocks = match request {
+            BlocksByRootRequest::V1(_) => self.controller.chain_config().max_request_blocks,
+            BlocksByRootRequest::V2(_) => self.controller.chain_config().max_request_blocks_deneb,
+        };
         let block_roots = request.block_roots();
 
         debug!(
@@ -1149,7 +1180,7 @@ impl<P: Preset> Network<P> {
             .spawn(async move {
                 let block_roots = block_roots
                     .into_iter()
-                    .take(MAX_FOR_DOS_PREVENTION.try_into()?);
+                    .take(MAX_FOR_DOS_PREVENTION.min(max_request_blocks).try_into()?);
 
                 let blocks = controller.blocks_by_root(block_roots)?;
 
@@ -1652,7 +1683,7 @@ impl<P: Preset> Network<P> {
         count: u64,
     ) {
         // TODO: is count capped in eth2_libp2p?
-        let request = BlobsByRangeRequest { start_slot, count };
+        let request = BlobsByRangeRequest::new(start_slot, count);
 
         debug!(
             "sending BlobSidecarsByRange request (request_id: {request_id} peer_id: {peer_id}, \

p2p/src/network.rs

@@ -220,7 +220,7 @@ fn process_execution_payload_for_gossip<P: Preset>(
 
     ensure!(
         in_block <= maximum,
-        Error::<P>::TooManyBlockKzgCommitments { in_block },
+        Error::<P>::TooManyBlockKzgCommitments { in_block, maximum },
     );
 
     Ok(())

transition_functions/src/deneb/block_processing.rs

@@ -216,13 +216,13 @@ fn process_execution_payload_for_gossip<P: Preset>(
         Error::<P>::ExecutionPayloadTimestampMismatch { computed, in_block },
     );
 
-    // > [New in Deneb:EIP4844] Verify commitments are under limit
-    let maximum = P::MaxBlobsPerBlock::USIZE;
+    // > [Modified in Electra:EIP7691] Verify commitments are under limit
+    let maximum = P::MaxBlobsPerBlockElectra::USIZE;
     let in_block = body.blob_kzg_commitments.len();
 
     ensure!(
         in_block <= maximum,
-        Error::<P>::TooManyBlockKzgCommitments { in_block },
+        Error::<P>::TooManyBlockKzgCommitments { in_block, maximum },
     );
 
     Ok(())

transition_functions/src/electra/block_processing.rs

@@ -1,5 +1,4 @@
 use thiserror::Error;
-use typenum::Unsigned as _;
 use types::{
     capella::containers::Withdrawal,
     combined::Attestation,
@@ -101,11 +100,8 @@ pub enum Error<P: Preset> {
     SlotNotLater { current: Slot, target: Slot },
     #[error("state root in block ({in_block:?}) does not match state ({computed:?})")]
     StateRootMismatch { computed: H256, in_block: H256 },
-    #[error(
-        "too many blob KZG commitments (maximum: {}, in_block: {in_block})",
-        P::MaxBlobsPerBlock::USIZE
-    )]
-    TooManyBlockKzgCommitments { in_block: usize },
+    #[error("too many blob KZG commitments (maximum: {maximum}, in_block: {in_block})")]
+    TooManyBlockKzgCommitments { maximum: usize, in_block: usize },
     #[error("validator {index} exited in epoch {exit_epoch}")]
     ValidatorAlreadyExited {
         index: ValidatorIndex,

transition_functions/src/unphased/error.rs

@@ -148,6 +148,10 @@ pub struct Config {
     pub blob_sidecar_subnet_count: NonZeroU64,
     #[serde(with = "serde_utils::string_or_native")]
     pub data_column_sidecar_subnet_count: u64,
+    #[serde(with = "serde_utils::string_or_native")]
+    pub max_request_blob_sidecars_electra: u64,
+    #[serde(with = "serde_utils::string_or_native")]
+    pub blob_sidecar_subnet_count_electra: NonZeroU64,
 
     // Transition
     pub terminal_block_hash: ExecutionBlockHash,
@@ -245,6 +249,8 @@ impl Default for Config {
             min_epochs_for_block_requests: 33024,
             blob_sidecar_subnet_count: nonzero!(6_u64),
             data_column_sidecar_subnet_count: 64,
+            max_request_blob_sidecars_electra: 1152,
+            blob_sidecar_subnet_count_electra: nonzero!(9_u64),
 
             // Transition
             terminal_block_hash: ExecutionBlockHash::zero(),

types/src/config.rs

@@ -176,6 +176,13 @@ pub trait Preset: Copy + Eq + Ord + Hash + Default + Debug + Send + Sync + 'stat
         + Debug
         + Send
         + Sync;
+    type MaxBlobsPerBlockElectra: MerkleElements<Blob<Self>>
+        + MerkleElements<KzgCommitment>
+        + MerkleElements<KzgProof>
+        + Eq
+        + Debug
+        + Send
+        + Sync;
 
     // Derived type-level variables
     type MaxAggregatorsPerSlot: MerkleElements<ValidatorIndex>
@@ -297,6 +304,7 @@ impl Preset for Mainnet {
     type PendingDepositsLimit = U134217728;
     type PendingConsolidationsLimit = U262144;
     type PendingPartialWithdrawalsLimit = U134217728;
+    type MaxBlobsPerBlockElectra = U9;
 
     // Derived type-level variables
     type MaxAggregatorsPerSlot = Prod<Self::MaxValidatorsPerCommittee, Self::MaxCommitteesPerSlot>;
@@ -361,6 +369,7 @@ impl Preset for Minimal {
         type MaxAttesterSlashingsElectra;
         type MaxConsolidationRequestsPerPayload;
         type PendingDepositsLimit;
+        type MaxBlobsPerBlockElectra;
     }
 
     // Phase 0
@@ -463,6 +472,7 @@ impl Preset for Medalla {
         type PendingDepositsLimit;
         type PendingConsolidationsLimit;
         type PendingPartialWithdrawalsLimit;
+        type MaxBlobsPerBlockElectra;
 
         // Derived type-level variables
         type MaxAggregatorsPerSlot;
@@ -885,6 +895,8 @@ pub struct ElectraPreset {
     pending_partial_withdrawals_limit: u64,
     #[serde(with = "serde_utils::string_or_native")]
     whistleblower_reward_quotient_electra: NonZeroU64,
+    #[serde(with = "serde_utils::string_or_native")]
+    max_blobs_per_block_electra: u64,
 }
 
 impl ElectraPreset {
@@ -905,6 +917,7 @@ impl ElectraPreset {
             pending_consolidations_limit: P::PendingConsolidationsLimit::U64,
             pending_partial_withdrawals_limit: P::PendingPartialWithdrawalsLimit::U64,
             whistleblower_reward_quotient_electra: P::WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA,
+            max_blobs_per_block_electra: P::MaxBlobsPerBlockElectra::U64,
         }
     }
 }