From 759b0612b37f354b70bd00298082e6aacb20ba89 Mon Sep 17 00:00:00 2001
From: Jimmy Chen <jimmy@sigmaprime.io>
Date: Tue, 8 Apr 2025 17:37:16 +1000
Subject: [PATCH] Offloading KZG Proof Computation from the beacon node (#7117)

Addresses #7108

- Add EL integration for `getPayloadV5` and `getBlobsV2`
- Offload proof computation and use proofs from EL RPC APIs
---
 beacon_node/beacon_chain/benches/benches.rs   |  12 +-
 beacon_node/beacon_chain/src/beacon_chain.rs  | 137 ++++----
 .../beacon_chain/src/block_verification.rs    |  15 +-
 beacon_node/beacon_chain/src/builder.rs       |  59 +++-
 .../src/data_availability_checker.rs          |  64 ++--
 .../overflow_lru_cache.rs                     |  82 +----
 .../src/data_column_verification.rs           |  43 ++-
 .../beacon_chain/src/early_attester_cache.rs  |   4 -
 beacon_node/beacon_chain/src/fetch_blobs.rs   | 301 +++++++++++-------
 .../beacon_chain/src/fulu_readiness.rs        |   8 +-
 .../beacon_chain/src/historical_blocks.rs     |   2 +-
 beacon_node/beacon_chain/src/kzg_utils.rs     | 143 +++++++--
 beacon_node/beacon_chain/src/metrics.rs       |   2 +-
 beacon_node/beacon_chain/src/test_utils.rs    |   6 +-
 beacon_node/execution_layer/src/engine_api.rs |  13 +-
 .../execution_layer/src/engine_api/http.rs    |  37 ++-
 .../src/engine_api/json_structures.rs         |  15 +-
 beacon_node/execution_layer/src/lib.rs        |  35 +-
 .../test_utils/execution_block_generator.rs   | 126 +++++---
 .../fixtures/mainnet/test_blobs_bundle_v2.ssz | Bin 0 -> 137276 bytes
 .../src/test_utils/handle_rpc.rs              |  21 +-
 .../src/test_utils/mock_builder.rs            |   6 +-
 .../execution_layer/src/test_utils/mod.rs     |   1 +
 beacon_node/http_api/src/publish_blocks.rs    |   5 +-
 .../gossip_methods.rs                         |   3 +-
 .../src/network_beacon_processor/mod.rs       |   7 +-
 consensus/types/src/data_column_sidecar.rs    |   4 +-
 consensus/types/src/eth_spec.rs               |  12 +-
 consensus/types/src/lib.rs                    |   9 +-
 crypto/kzg/src/lib.rs                         |  13 +-
 scripts/local_testnet/network_params_das.yaml |  12 +-
 31 files changed, 721 insertions(+), 476 deletions(-)
 create mode 100644 beacon_node/execution_layer/src/test_utils/fixtures/mainnet/test_blobs_bundle_v2.ssz

diff --git a/beacon_node/beacon_chain/benches/benches.rs b/beacon_node/beacon_chain/benches/benches.rs
index c09af00be6..aae627da13 100644
--- a/beacon_node/beacon_chain/benches/benches.rs
+++ b/beacon_node/beacon_chain/benches/benches.rs
@@ -5,16 +5,16 @@ use beacon_chain::test_utils::get_kzg;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 use bls::Signature;
-use kzg::KzgCommitment;
+use kzg::{KzgCommitment, KzgProof};
 use types::{
     beacon_block_body::KzgCommitments, BeaconBlock, BeaconBlockDeneb, Blob, BlobsList, ChainSpec,
-    EmptyBlock, EthSpec, MainnetEthSpec, SignedBeaconBlock,
+    EmptyBlock, EthSpec, KzgProofs, MainnetEthSpec, SignedBeaconBlock,
 };
 
 fn create_test_block_and_blobs<E: EthSpec>(
     num_of_blobs: usize,
     spec: &ChainSpec,
-) -> (SignedBeaconBlock<E>, BlobsList<E>) {
+) -> (SignedBeaconBlock<E>, BlobsList<E>, KzgProofs<E>) {
     let mut block = BeaconBlock::Deneb(BeaconBlockDeneb::empty(spec));
     let mut body = block.body_mut();
     let blob_kzg_commitments = body.blob_kzg_commitments_mut().unwrap();
@@ -27,8 +27,9 @@ 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();
 
-    (signed_block, blobs)
+    (signed_block, blobs, proofs)
 }
 
 fn all_benches(c: &mut Criterion) {
@@ -37,10 +38,11 @@ fn all_benches(c: &mut Criterion) {
 
     let kzg = get_kzg(&spec);
     for blob_count in [1, 2, 3, 6] {
-        let (signed_block, blobs) = create_test_block_and_blobs::<E>(blob_count, &spec);
+        let (signed_block, blobs, proofs) = create_test_block_and_blobs::<E>(blob_count, &spec);
 
         let column_sidecars = blobs_to_data_column_sidecars(
             &blobs.iter().collect::<Vec<_>>(),
+            proofs.to_vec(),
             &signed_block,
             &kzg,
             &spec,
diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index d9ac2fa6ea..d6475de243 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -31,6 +31,7 @@ use crate::eth1_chain::{Eth1Chain, Eth1ChainBackend};
 use crate::eth1_finalization_cache::{Eth1FinalizationCache, Eth1FinalizationData};
 use crate::events::ServerSentEventHandler;
 use crate::execution_payload::{get_execution_payload, NotifyExecutionLayer, PreparePayloadHandle};
+use crate::fetch_blobs::EngineGetBlobsOutput;
 use crate::fork_choice_signal::{ForkChoiceSignalRx, ForkChoiceSignalTx, ForkChoiceWaitResult};
 use crate::graffiti_calculator::GraffitiCalculator;
 use crate::kzg_utils::reconstruct_blobs;
@@ -121,7 +122,6 @@ use store::{
     KeyValueStore, KeyValueStoreOp, StoreItem, StoreOp,
 };
 use task_executor::{ShutdownReason, TaskExecutor};
-use tokio::sync::oneshot;
 use tokio_stream::Stream;
 use tracing::{debug, error, info, trace, warn};
 use tree_hash::TreeHash;
@@ -3137,16 +3137,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     }
 
     /// Process blobs retrieved from the EL and returns the `AvailabilityProcessingStatus`.
-    ///
-    /// `data_column_recv`: An optional receiver for `DataColumnSidecarList`.
-    /// If PeerDAS is enabled, this receiver will be provided and used to send
-    /// the `DataColumnSidecar`s once they have been successfully computed.
     pub async fn process_engine_blobs(
         self: &Arc<Self>,
         slot: Slot,
         block_root: Hash256,
-        blobs: FixedBlobSidecarList<T::EthSpec>,
-        data_column_recv: Option<oneshot::Receiver<DataColumnSidecarList<T::EthSpec>>>,
+        engine_get_blobs_output: EngineGetBlobsOutput<T::EthSpec>,
     ) -> Result<AvailabilityProcessingStatus, BlockError> {
         // If this block has already been imported to forkchoice it must have been available, so
         // we don't need to process its blobs again.
@@ -3160,15 +3155,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         // process_engine_blobs is called for both pre and post PeerDAS. However, post PeerDAS
         // consumers don't expect the blobs event to fire erratically.
-        if !self
-            .spec
-            .is_peer_das_enabled_for_epoch(slot.epoch(T::EthSpec::slots_per_epoch()))
-        {
+        if let EngineGetBlobsOutput::Blobs(blobs) = &engine_get_blobs_output {
             self.emit_sse_blob_sidecar_events(&block_root, blobs.iter().flatten().map(Arc::as_ref));
         }
 
         let r = self
-            .check_engine_blob_availability_and_import(slot, block_root, blobs, data_column_recv)
+            .check_engine_blobs_availability_and_import(slot, block_root, engine_get_blobs_output)
             .await;
         self.remove_notified(&block_root, r)
     }
@@ -3618,20 +3610,24 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .await
     }
 
-    async fn check_engine_blob_availability_and_import(
+    async fn check_engine_blobs_availability_and_import(
         self: &Arc<Self>,
         slot: Slot,
         block_root: Hash256,
-        blobs: FixedBlobSidecarList<T::EthSpec>,
-        data_column_recv: Option<oneshot::Receiver<DataColumnSidecarList<T::EthSpec>>>,
+        engine_get_blobs_output: EngineGetBlobsOutput<T::EthSpec>,
     ) -> Result<AvailabilityProcessingStatus, BlockError> {
-        self.check_blobs_for_slashability(block_root, &blobs)?;
-        let availability = self.data_availability_checker.put_engine_blobs(
-            block_root,
-            slot.epoch(T::EthSpec::slots_per_epoch()),
-            blobs,
-            data_column_recv,
-        )?;
+        let availability = match engine_get_blobs_output {
+            EngineGetBlobsOutput::Blobs(blobs) => {
+                self.check_blobs_for_slashability(block_root, &blobs)?;
+                self.data_availability_checker
+                    .put_engine_blobs(block_root, blobs)?
+            }
+            EngineGetBlobsOutput::CustodyColumns(data_columns) => {
+                self.check_columns_for_slashability(block_root, &data_columns)?;
+                self.data_availability_checker
+                    .put_engine_data_columns(block_root, data_columns)?
+            }
+        };
 
         self.process_availability(slot, availability, || Ok(()))
             .await
@@ -3645,27 +3641,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         block_root: Hash256,
         custody_columns: DataColumnSidecarList<T::EthSpec>,
     ) -> Result<AvailabilityProcessingStatus, BlockError> {
-        // Need to scope this to ensure the lock is dropped before calling `process_availability`
-        // Even an explicit drop is not enough to convince the borrow checker.
-        {
-            let mut slashable_cache = self.observed_slashable.write();
-            // Assumes all items in custody_columns are for the same block_root
-            if let Some(column) = custody_columns.first() {
-                let header = &column.signed_block_header;
-                if verify_header_signature::<T, BlockError>(self, header).is_ok() {
-                    slashable_cache
-                        .observe_slashable(
-                            header.message.slot,
-                            header.message.proposer_index,
-                            block_root,
-                        )
-                        .map_err(|e| BlockError::BeaconChainError(e.into()))?;
-                    if let Some(slasher) = self.slasher.as_ref() {
-                        slasher.accept_block_header(header.clone());
-                    }
-                }
-            }
-        }
+        self.check_columns_for_slashability(block_root, &custody_columns)?;
 
         // This slot value is purely informative for the consumers of
         // `AvailabilityProcessingStatus::MissingComponents` to log an error with a slot.
@@ -3677,6 +3653,31 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .await
     }
 
+    fn check_columns_for_slashability(
+        self: &Arc<Self>,
+        block_root: Hash256,
+        custody_columns: &DataColumnSidecarList<T::EthSpec>,
+    ) -> Result<(), BlockError> {
+        let mut slashable_cache = self.observed_slashable.write();
+        // Assumes all items in custody_columns are for the same block_root
+        if let Some(column) = custody_columns.first() {
+            let header = &column.signed_block_header;
+            if verify_header_signature::<T, BlockError>(self, header).is_ok() {
+                slashable_cache
+                    .observe_slashable(
+                        header.message.slot,
+                        header.message.proposer_index,
+                        block_root,
+                    )
+                    .map_err(|e| BlockError::BeaconChainError(e.into()))?;
+                if let Some(slasher) = self.slasher.as_ref() {
+                    slasher.accept_block_header(header.clone());
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Imports a fully available block. Otherwise, returns `AvailabilityProcessingStatus::MissingComponents`
     ///
     /// An error is returned if the block was unable to be imported. It may be partially imported
@@ -5798,15 +5799,26 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 let kzg_proofs = Vec::from(proofs);
 
                 let kzg = self.kzg.as_ref();
-
-                // TODO(fulu): we no longer need blob proofs from PeerDAS and could avoid computing.
-                kzg_utils::validate_blobs::<T::EthSpec>(
-                    kzg,
-                    expected_kzg_commitments,
-                    blobs.iter().collect(),
-                    &kzg_proofs,
-                )
-                .map_err(BlockProductionError::KzgError)?;
+                if self
+                    .spec
+                    .is_peer_das_enabled_for_epoch(slot.epoch(T::EthSpec::slots_per_epoch()))
+                {
+                    kzg_utils::validate_blobs_and_cell_proofs::<T::EthSpec>(
+                        kzg,
+                        blobs.iter().collect(),
+                        &kzg_proofs,
+                        expected_kzg_commitments,
+                    )
+                    .map_err(BlockProductionError::KzgError)?;
+                } else {
+                    kzg_utils::validate_blobs::<T::EthSpec>(
+                        kzg,
+                        expected_kzg_commitments,
+                        blobs.iter().collect(),
+                        &kzg_proofs,
+                    )
+                    .map_err(BlockProductionError::KzgError)?;
+                }
 
                 Some((kzg_proofs.into(), blobs))
             }
@@ -7118,27 +7130,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 );
                 Ok(Some(StoreOp::PutDataColumns(block_root, data_columns)))
             }
-            AvailableBlockData::DataColumnsRecv(data_column_recv) => {
-                // Blobs were available from the EL, in this case we wait for the data columns to be computed (blocking).
-                let _column_recv_timer =
-                    metrics::start_timer(&metrics::BLOCK_PROCESSING_DATA_COLUMNS_WAIT);
-                // Unable to receive data columns from sender, sender is either dropped or
-                // failed to compute data columns from blobs. We restore fork choice here and
-                // return to avoid inconsistency in database.
-                let computed_data_columns = data_column_recv
-                    .blocking_recv()
-                    .map_err(|e| format!("Did not receive data columns from sender: {e:?}"))?;
-                debug!(
-                    %block_root,
-                    count = computed_data_columns.len(),
-                    "Writing data columns to store"
-                );
-                // TODO(das): Store only this node's custody columns
-                Ok(Some(StoreOp::PutDataColumns(
-                    block_root,
-                    computed_data_columns,
-                )))
-            }
         }
     }
 }
diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs
index 39bad34cd6..46ba1bc992 100644
--- a/beacon_node/beacon_chain/src/block_verification.rs
+++ b/beacon_node/beacon_chain/src/block_verification.rs
@@ -97,8 +97,8 @@ use tracing::{debug, error};
 use types::{
     data_column_sidecar::DataColumnSidecarError, BeaconBlockRef, BeaconState, BeaconStateError,
     BlobsList, ChainSpec, DataColumnSidecarList, Epoch, EthSpec, ExecutionBlockHash, FullPayload,
-    Hash256, InconsistentFork, PublicKey, PublicKeyBytes, RelativeEpoch, SignedBeaconBlock,
-    SignedBeaconBlockHeader, Slot,
+    Hash256, InconsistentFork, KzgProofs, PublicKey, PublicKeyBytes, RelativeEpoch,
+    SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
 };
 
 pub const POS_PANDA_BANNER: &str = r#"
@@ -755,6 +755,7 @@ pub fn build_blob_data_column_sidecars<T: BeaconChainTypes>(
     chain: &BeaconChain<T>,
     block: &SignedBeaconBlock<T::EthSpec, FullPayload<T::EthSpec>>,
     blobs: BlobsList<T::EthSpec>,
+    kzg_cell_proofs: KzgProofs<T::EthSpec>,
 ) -> Result<DataColumnSidecarList<T::EthSpec>, DataColumnSidecarError> {
     // Only attempt to build data columns if blobs is non empty to avoid skewing the metrics.
     if blobs.is_empty() {
@@ -766,8 +767,14 @@ pub fn build_blob_data_column_sidecars<T: BeaconChainTypes>(
         &[&blobs.len().to_string()],
     );
     let blob_refs = blobs.iter().collect::<Vec<_>>();
-    let sidecars = blobs_to_data_column_sidecars(&blob_refs, block, &chain.kzg, &chain.spec)
-        .discard_timer_on_break(&mut timer)?;
+    let sidecars = blobs_to_data_column_sidecars(
+        &blob_refs,
+        kzg_cell_proofs.to_vec(),
+        block,
+        &chain.kzg,
+        &chain.spec,
+    )
+    .discard_timer_on_break(&mut timer)?;
     drop(timer);
     Ok(sidecars)
 }
diff --git a/beacon_node/beacon_chain/src/builder.rs b/beacon_node/beacon_chain/src/builder.rs
index 6f8a0dcb7c..975be33f0b 100644
--- a/beacon_node/beacon_chain/src/builder.rs
+++ b/beacon_node/beacon_chain/src/builder.rs
@@ -8,7 +8,7 @@ use crate::eth1_finalization_cache::Eth1FinalizationCache;
 use crate::fork_choice_signal::ForkChoiceSignalTx;
 use crate::fork_revert::{reset_fork_choice_to_finalization, revert_to_fork_boundary};
 use crate::graffiti_calculator::{GraffitiCalculator, GraffitiOrigin};
-use crate::kzg_utils::blobs_to_data_column_sidecars;
+use crate::kzg_utils::build_data_column_sidecars;
 use crate::light_client_server_cache::LightClientServerCache;
 use crate::migrate::{BackgroundMigrator, MigratorConfig};
 use crate::observed_data_sidecars::ObservedDataSidecars;
@@ -30,6 +30,7 @@ use logging::crit;
 use operation_pool::{OperationPool, PersistedOperationPool};
 use parking_lot::{Mutex, RwLock};
 use proto_array::{DisallowedReOrgOffsets, ReOrgThreshold};
+use rayon::prelude::*;
 use slasher::Slasher;
 use slot_clock::{SlotClock, TestingSlotClock};
 use state_processing::{per_slot_processing, AllCaches};
@@ -40,8 +41,8 @@ use store::{Error as StoreError, HotColdDB, ItemStore, KeyValueStoreOp};
 use task_executor::{ShutdownReason, TaskExecutor};
 use tracing::{debug, error, info};
 use types::{
-    BeaconBlock, BeaconState, BlobSidecarList, ChainSpec, Checkpoint, Epoch, EthSpec,
-    FixedBytesExtended, Hash256, Signature, SignedBeaconBlock, Slot,
+    BeaconBlock, BeaconState, BlobSidecarList, ChainSpec, Checkpoint, DataColumnSidecarList, Epoch,
+    EthSpec, FixedBytesExtended, Hash256, Signature, SignedBeaconBlock, Slot,
 };
 
 /// An empty struct used to "witness" all the `BeaconChainTypes` traits. It has no user-facing
@@ -546,15 +547,8 @@ where
             {
                 // After PeerDAS recompute columns from blobs to not force the checkpointz server
                 // into exposing another route.
-                let blobs = blobs
-                    .iter()
-                    .map(|blob_sidecar| &blob_sidecar.blob)
-                    .collect::<Vec<_>>();
                 let data_columns =
-                    blobs_to_data_column_sidecars(&blobs, &weak_subj_block, &self.kzg, &self.spec)
-                        .map_err(|e| {
-                            format!("Failed to compute weak subjectivity data_columns: {e:?}")
-                        })?;
+                    build_data_columns_from_blobs(&weak_subj_block, &blobs, &self.kzg, &self.spec)?;
                 // TODO(das): only persist the columns under custody
                 store
                     .put_data_columns(&weak_subj_block_root, data_columns)
@@ -1138,6 +1132,49 @@ fn descriptive_db_error(item: &str, error: &StoreError) -> String {
     )
 }
 
+/// Build data columns and proofs from blobs.
+fn build_data_columns_from_blobs<E: EthSpec>(
+    block: &SignedBeaconBlock<E>,
+    blobs: &BlobSidecarList<E>,
+    kzg: &Kzg,
+    spec: &ChainSpec,
+) -> Result<DataColumnSidecarList<E>, String> {
+    let blob_cells_and_proofs_vec = blobs
+        .into_par_iter()
+        .map(|blob_sidecar| {
+            let kzg_blob_ref = blob_sidecar
+                .blob
+                .as_ref()
+                .try_into()
+                .map_err(|e| format!("Failed to convert blob to kzg blob: {e:?}"))?;
+            let cells_and_proofs = kzg
+                .compute_cells_and_proofs(kzg_blob_ref)
+                .map_err(|e| format!("Failed to compute cell kzg proofs: {e:?}"))?;
+            Ok(cells_and_proofs)
+        })
+        .collect::<Result<Vec<_>, String>>()?;
+
+    let data_columns = {
+        let beacon_block_body = block.message().body();
+        let kzg_commitments = beacon_block_body
+            .blob_kzg_commitments()
+            .cloned()
+            .map_err(|e| format!("Unexpected pre Deneb block: {e:?}"))?;
+        let kzg_commitments_inclusion_proof = beacon_block_body
+            .kzg_commitments_merkle_proof()
+            .map_err(|e| format!("Failed to compute kzg commitments merkle proof: {e:?}"))?;
+        build_data_column_sidecars(
+            kzg_commitments,
+            kzg_commitments_inclusion_proof,
+            block.signed_block_header(),
+            blob_cells_and_proofs_vec,
+            spec,
+        )
+        .map_err(|e| format!("Failed to compute weak subjectivity data_columns: {e:?}"))?
+    };
+    Ok(data_columns)
+}
+
 #[cfg(not(debug_assertions))]
 #[cfg(test)]
 mod test {
diff --git a/beacon_node/beacon_chain/src/data_availability_checker.rs b/beacon_node/beacon_chain/src/data_availability_checker.rs
index 2b7ae9e4d1..033b472da0 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker.rs
@@ -14,7 +14,6 @@ use std::num::NonZeroUsize;
 use std::sync::Arc;
 use std::time::Duration;
 use task_executor::TaskExecutor;
-use tokio::sync::oneshot;
 use tracing::{debug, error, info_span, Instrument};
 use types::blob_sidecar::{BlobIdentifier, BlobSidecar, FixedBlobSidecarList};
 use types::{
@@ -226,27 +225,45 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
     pub fn put_engine_blobs(
         &self,
         block_root: Hash256,
-        block_epoch: Epoch,
         blobs: FixedBlobSidecarList<T::EthSpec>,
-        data_columns_recv: Option<oneshot::Receiver<DataColumnSidecarList<T::EthSpec>>>,
     ) -> Result<Availability<T::EthSpec>, AvailabilityCheckError> {
-        // `data_columns_recv` is always Some if block_root is post-PeerDAS
-        if let Some(data_columns_recv) = data_columns_recv {
-            self.availability_cache.put_computed_data_columns_recv(
-                block_root,
-                block_epoch,
-                data_columns_recv,
-            )
-        } else {
-            let seen_timestamp = self
-                .slot_clock
-                .now_duration()
-                .ok_or(AvailabilityCheckError::SlotClockError)?;
-            self.availability_cache.put_kzg_verified_blobs(
-                block_root,
-                KzgVerifiedBlobList::from_verified(blobs.iter().flatten().cloned(), seen_timestamp),
-            )
-        }
+        let seen_timestamp = self
+            .slot_clock
+            .now_duration()
+            .ok_or(AvailabilityCheckError::SlotClockError)?;
+        self.availability_cache.put_kzg_verified_blobs(
+            block_root,
+            KzgVerifiedBlobList::from_verified(blobs.iter().flatten().cloned(), seen_timestamp),
+        )
+    }
+
+    /// Put a list of data columns computed from blobs received from the EL pool into the
+    /// availability cache.
+    ///
+    /// This DOES NOT perform KZG proof and inclusion proof verification because
+    /// - The KZG proofs should have been verified by the trusted EL.
+    /// - The KZG commitments inclusion proof should have been constructed immediately prior to
+    ///   calling this function so they are assumed to be valid.
+    ///
+    /// This method is used if the EL already has the blobs and returns them via the `getBlobsV2`
+    /// engine method.
+    /// More details in [fetch_blobs.rs](https://github.com/sigp/lighthouse/blob/44f8add41ea2252769bb967864af95b3c13af8ca/beacon_node/beacon_chain/src/fetch_blobs.rs).
+    pub fn put_engine_data_columns(
+        &self,
+        block_root: Hash256,
+        data_columns: DataColumnSidecarList<T::EthSpec>,
+    ) -> Result<Availability<T::EthSpec>, AvailabilityCheckError> {
+        let kzg_verified_custody_columns = data_columns
+            .into_iter()
+            .map(|d| {
+                KzgVerifiedCustodyDataColumn::from_asserted_custody(
+                    KzgVerifiedDataColumn::from_verified(d),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        self.availability_cache
+            .put_kzg_verified_data_columns(block_root, kzg_verified_custody_columns)
     }
 
     /// Check if we've cached other blobs for this block. If it completes a set and we also
@@ -704,9 +721,6 @@ pub enum AvailableBlockData<E: EthSpec> {
     Blobs(BlobSidecarList<E>),
     /// Block is post-PeerDAS and has more than zero blobs
     DataColumns(DataColumnSidecarList<E>),
-    /// Block is post-PeerDAS, has more than zero blobs and we recomputed the columns from the EL's
-    /// mempool blobs
-    DataColumnsRecv(oneshot::Receiver<DataColumnSidecarList<E>>),
 }
 
 /// A fully available block that is ready to be imported into fork choice.
@@ -756,7 +770,6 @@ impl<E: EthSpec> AvailableBlock<E> {
             AvailableBlockData::NoData => false,
             AvailableBlockData::Blobs(..) => true,
             AvailableBlockData::DataColumns(_) => false,
-            AvailableBlockData::DataColumnsRecv(_) => false,
         }
     }
 
@@ -782,9 +795,6 @@ impl<E: EthSpec> AvailableBlock<E> {
                 AvailableBlockData::DataColumns(data_columns) => {
                     AvailableBlockData::DataColumns(data_columns.clone())
                 }
-                AvailableBlockData::DataColumnsRecv(_) => {
-                    return Err("Can't clone DataColumnsRecv".to_owned())
-                }
             },
             blobs_available_timestamp: self.blobs_available_timestamp,
             spec: self.spec.clone(),
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
index 4359d7fbdb..f5fd24483a 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
@@ -13,13 +13,11 @@ use parking_lot::RwLock;
 use std::cmp::Ordering;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
-use tokio::sync::oneshot;
 use tracing::debug;
 use types::blob_sidecar::BlobIdentifier;
 use types::{
-    BlobSidecar, ChainSpec, ColumnIndex, DataColumnIdentifier, DataColumnSidecar,
-    DataColumnSidecarList, Epoch, EthSpec, Hash256, RuntimeFixedVector, RuntimeVariableList,
-    SignedBeaconBlock,
+    BlobSidecar, ChainSpec, ColumnIndex, DataColumnIdentifier, DataColumnSidecar, Epoch, EthSpec,
+    Hash256, RuntimeFixedVector, RuntimeVariableList, SignedBeaconBlock,
 };
 
 /// This represents the components of a partially available block
@@ -32,12 +30,6 @@ pub struct PendingComponents<E: EthSpec> {
     pub verified_data_columns: Vec<KzgVerifiedCustodyDataColumn<E>>,
     pub executed_block: Option<DietAvailabilityPendingExecutedBlock<E>>,
     pub reconstruction_started: bool,
-    /// Receiver for data columns that are computed asynchronously;
-    ///
-    /// If `data_column_recv` is `Some`, it means data column computation or reconstruction has been
-    /// started. This can happen either via engine blobs fetching or data column reconstruction
-    /// (triggered when >= 50% columns are received via gossip).
-    pub data_column_recv: Option<oneshot::Receiver<DataColumnSidecarList<E>>>,
 }
 
 impl<E: EthSpec> PendingComponents<E> {
@@ -202,13 +194,8 @@ impl<E: EthSpec> PendingComponents<E> {
                     Some(AvailableBlockData::DataColumns(data_columns))
                 }
                 Ordering::Less => {
-                    // The data_columns_recv is an infallible promise that we will receive all expected
-                    // columns, so we consider the block available.
-                    // We take the receiver as it can't be cloned, and make_available should never
-                    // be called again once it returns `Some`.
-                    self.data_column_recv
-                        .take()
-                        .map(AvailableBlockData::DataColumnsRecv)
+                    // Not enough data columns received yet
+                    None
                 }
             }
         } else {
@@ -261,7 +248,6 @@ impl<E: EthSpec> PendingComponents<E> {
                 .max(),
             // TODO(das): To be fixed with https://github.com/sigp/lighthouse/pull/6850
             AvailableBlockData::DataColumns(_) => None,
-            AvailableBlockData::DataColumnsRecv(_) => None,
         };
 
         let AvailabilityPendingExecutedBlock {
@@ -293,7 +279,6 @@ impl<E: EthSpec> PendingComponents<E> {
             verified_data_columns: vec![],
             executed_block: None,
             reconstruction_started: false,
-            data_column_recv: None,
         }
     }
 
@@ -331,17 +316,11 @@ impl<E: EthSpec> PendingComponents<E> {
             } else {
                 "?"
             };
-            let data_column_recv_count = if self.data_column_recv.is_some() {
-                1
-            } else {
-                0
-            };
             format!(
-                "block {} data_columns {}/{} data_columns_recv {}",
+                "block {} data_columns {}/{}",
                 block_count,
                 self.verified_data_columns.len(),
                 custody_columns_count,
-                data_column_recv_count,
             )
         } else {
             let num_expected_blobs = if let Some(block) = self.get_cached_block() {
@@ -498,7 +477,6 @@ impl<T: BeaconChainTypes> DataAvailabilityCheckerInner<T> {
             self.state_cache.recover_pending_executed_block(block)
         })? {
             // We keep the pending components in the availability cache during block import (#5845).
-            // `data_column_recv` is returned as part of the available block and is no longer needed here.
             write_lock.put(block_root, pending_components);
             drop(write_lock);
             Ok(Availability::Available(Box::new(available_block)))
@@ -551,55 +529,6 @@ impl<T: BeaconChainTypes> DataAvailabilityCheckerInner<T> {
             self.state_cache.recover_pending_executed_block(block)
         })? {
             // We keep the pending components in the availability cache during block import (#5845).
-            // `data_column_recv` is returned as part of the available block and is no longer needed here.
-            write_lock.put(block_root, pending_components);
-            drop(write_lock);
-            Ok(Availability::Available(Box::new(available_block)))
-        } else {
-            write_lock.put(block_root, pending_components);
-            Ok(Availability::MissingComponents(block_root))
-        }
-    }
-
-    /// The `data_column_recv` parameter is a `Receiver` for data columns that are computed
-    /// asynchronously. This method is used if the EL already has the blobs and returns them via the
-    /// `getBlobsV1` engine method. More details in [fetch_blobs.rs](https://github.com/sigp/lighthouse/blob/44f8add41ea2252769bb967864af95b3c13af8ca/beacon_node/beacon_chain/src/fetch_blobs.rs).
-    pub fn put_computed_data_columns_recv(
-        &self,
-        block_root: Hash256,
-        block_epoch: Epoch,
-        data_column_recv: oneshot::Receiver<DataColumnSidecarList<T::EthSpec>>,
-    ) -> Result<Availability<T::EthSpec>, AvailabilityCheckError> {
-        let mut write_lock = self.critical.write();
-
-        // Grab existing entry or create a new entry.
-        let mut pending_components = write_lock
-            .pop_entry(&block_root)
-            .map(|(_, v)| v)
-            .unwrap_or_else(|| {
-                PendingComponents::empty(
-                    block_root,
-                    self.spec.max_blobs_per_block(block_epoch) as usize,
-                )
-            });
-
-        // We have all the blobs from engine, and have started computing data columns. We store the
-        // receiver in `PendingComponents` for later use when importing the block.
-        // TODO(das): Error or log if we overwrite a prior receiver https://github.com/sigp/lighthouse/issues/6764
-        pending_components.data_column_recv = Some(data_column_recv);
-
-        debug!(
-            component = "data_columns_recv",
-            ?block_root,
-            status = pending_components.status_str(block_epoch, &self.spec),
-            "Component added to data availability checker"
-        );
-
-        if let Some(available_block) = pending_components.make_available(&self.spec, |block| {
-            self.state_cache.recover_pending_executed_block(block)
-        })? {
-            // We keep the pending components in the availability cache during block import (#5845).
-            // `data_column_recv` is returned as part of the available block and is no longer needed here.
             write_lock.put(block_root, pending_components);
             drop(write_lock);
             Ok(Availability::Available(Box::new(available_block)))
@@ -694,7 +623,6 @@ impl<T: BeaconChainTypes> DataAvailabilityCheckerInner<T> {
             self.state_cache.recover_pending_executed_block(block)
         })? {
             // We keep the pending components in the availability cache during block import (#5845).
-            // `data_column_recv` is returned as part of the available block and is no longer needed here.
             write_lock.put(block_root, pending_components);
             drop(write_lock);
             Ok(Availability::Available(Box::new(available_block)))
diff --git a/beacon_node/beacon_chain/src/data_column_verification.rs b/beacon_node/beacon_chain/src/data_column_verification.rs
index 2f95d834b5..57efbb0a77 100644
--- a/beacon_node/beacon_chain/src/data_column_verification.rs
+++ b/beacon_node/beacon_chain/src/data_column_verification.rs
@@ -141,13 +141,23 @@ pub enum GossipDataColumnError {
     ///
     /// The column sidecar is invalid and the peer is faulty
     UnexpectedDataColumn,
-    /// The data column length must be equal to the number of commitments/proofs, otherwise the
+    /// The data column length must be equal to the number of commitments, otherwise the
     /// sidecar is invalid.
     ///
     /// ## Peer scoring
     ///
     /// The column sidecar is invalid and the peer is faulty
-    InconsistentCommitmentsOrProofLength,
+    InconsistentCommitmentsLength {
+        cells_len: usize,
+        commitments_len: usize,
+    },
+    /// The data column length must be equal to the number of proofs, otherwise the
+    /// sidecar is invalid.
+    ///
+    /// ## Peer scoring
+    ///
+    /// The column sidecar is invalid and the peer is faulty
+    InconsistentProofsLength { cells_len: usize, proofs_len: usize },
 }
 
 impl From<BeaconChainError> for GossipDataColumnError {
@@ -240,6 +250,14 @@ impl<E: EthSpec> KzgVerifiedDataColumn<E> {
         verify_kzg_for_data_column(data_column, kzg)
     }
 
+    /// Create a `KzgVerifiedDataColumn` from `data_column` that are already KZG verified.
+    ///
+    /// This should be used with caution, as used incorrectly it could result in KZG verification
+    /// being skipped and invalid data_columns being deemed valid.
+    pub fn from_verified(data_column: Arc<DataColumnSidecar<E>>) -> Self {
+        Self { data: data_column }
+    }
+
     pub fn from_batch(
         data_columns: Vec<Arc<DataColumnSidecar<E>>>,
         kzg: &Kzg,
@@ -473,10 +491,23 @@ fn verify_data_column_sidecar<E: EthSpec>(
     if data_column.kzg_commitments.is_empty() {
         return Err(GossipDataColumnError::UnexpectedDataColumn);
     }
-    if data_column.column.len() != data_column.kzg_commitments.len()
-        || data_column.column.len() != data_column.kzg_proofs.len()
-    {
-        return Err(GossipDataColumnError::InconsistentCommitmentsOrProofLength);
+
+    let cells_len = data_column.column.len();
+    let commitments_len = data_column.kzg_commitments.len();
+    let proofs_len = data_column.kzg_proofs.len();
+
+    if cells_len != commitments_len {
+        return Err(GossipDataColumnError::InconsistentCommitmentsLength {
+            cells_len,
+            commitments_len,
+        });
+    }
+
+    if cells_len != proofs_len {
+        return Err(GossipDataColumnError::InconsistentProofsLength {
+            cells_len,
+            proofs_len,
+        });
     }
 
     Ok(())
diff --git a/beacon_node/beacon_chain/src/early_attester_cache.rs b/beacon_node/beacon_chain/src/early_attester_cache.rs
index f4810e7b4a..5665ef3775 100644
--- a/beacon_node/beacon_chain/src/early_attester_cache.rs
+++ b/beacon_node/beacon_chain/src/early_attester_cache.rs
@@ -74,10 +74,6 @@ impl<E: EthSpec> EarlyAttesterCache<E> {
             AvailableBlockData::NoData => (None, None),
             AvailableBlockData::Blobs(blobs) => (Some(blobs.clone()), None),
             AvailableBlockData::DataColumns(data_columns) => (None, Some(data_columns.clone())),
-            // TODO(das): Once the columns are received, they will not be available in
-            // the early attester cache. If someone does a query to us via RPC we
-            // will get downscored.
-            AvailableBlockData::DataColumnsRecv(_) => (None, None),
         };
 
         let item = CacheItem {
diff --git a/beacon_node/beacon_chain/src/fetch_blobs.rs b/beacon_node/beacon_chain/src/fetch_blobs.rs
index 3c28ac9a44..3b576da1c7 100644
--- a/beacon_node/beacon_chain/src/fetch_blobs.rs
+++ b/beacon_node/beacon_chain/src/fetch_blobs.rs
@@ -7,34 +7,52 @@
 //! on P2P gossip to the network. From PeerDAS onwards, together with the increase in blob count,
 //! broadcasting blobs requires a much higher bandwidth, and is only done by high capacity
 //! supernodes.
+
 use crate::blob_verification::{GossipBlobError, GossipVerifiedBlob};
 use crate::kzg_utils::blobs_to_data_column_sidecars;
 use crate::observed_data_sidecars::DoNotObserve;
-use crate::{metrics, AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError};
-use execution_layer::json_structures::BlobAndProofV1;
+use crate::{
+    metrics, AvailabilityProcessingStatus, BeaconChain, BeaconChainError, BeaconChainTypes,
+    BlockError,
+};
+use execution_layer::json_structures::{BlobAndProofV1, BlobAndProofV2};
 use execution_layer::Error as ExecutionLayerError;
 use metrics::{inc_counter, TryExt};
 use ssz_types::FixedVector;
 use state_processing::per_block_processing::deneb::kzg_commitment_to_versioned_hash;
+use std::collections::HashSet;
 use std::sync::Arc;
-use tokio::sync::oneshot;
-use tracing::{debug, error};
+use tracing::debug;
 use types::blob_sidecar::{BlobSidecarError, FixedBlobSidecarList};
+use types::data_column_sidecar::DataColumnSidecarError;
 use types::{
-    BeaconStateError, BlobSidecar, ChainSpec, DataColumnSidecar, DataColumnSidecarList, EthSpec,
-    FullPayload, Hash256, SignedBeaconBlock, SignedBeaconBlockHeader,
+    BeaconStateError, Blob, BlobSidecar, ChainSpec, ColumnIndex, DataColumnSidecarList, EthSpec,
+    FullPayload, Hash256, KzgProofs, SignedBeaconBlock, SignedBeaconBlockHeader, VersionedHash,
 };
 
+/// Blobs or data column to be published to the gossip network.
 pub enum BlobsOrDataColumns<T: BeaconChainTypes> {
     Blobs(Vec<GossipVerifiedBlob<T, DoNotObserve>>),
     DataColumns(DataColumnSidecarList<T::EthSpec>),
 }
 
+/// Result from engine get blobs to be passed onto `DataAvailabilityChecker`.
+///
+/// The blobs are retrieved from a trusted EL and columns are computed locally, therefore they are
+/// considered valid without requiring extra validation.
+pub enum EngineGetBlobsOutput<E: EthSpec> {
+    Blobs(FixedBlobSidecarList<E>),
+    /// A filtered list of custody data columns to be imported into the `DataAvailabilityChecker`.
+    CustodyColumns(DataColumnSidecarList<E>),
+}
+
 #[derive(Debug)]
 pub enum FetchEngineBlobError {
     BeaconStateError(BeaconStateError),
+    BeaconChainError(BeaconChainError),
     BlobProcessingError(BlockError),
     BlobSidecarError(BlobSidecarError),
+    DataColumnSidecarError(DataColumnSidecarError),
     ExecutionLayerMissing,
     InternalError(String),
     GossipBlob(GossipBlobError),
@@ -48,6 +66,7 @@ pub async fn fetch_and_process_engine_blobs<T: BeaconChainTypes>(
     chain: Arc<BeaconChain<T>>,
     block_root: Hash256,
     block: Arc<SignedBeaconBlock<T::EthSpec, FullPayload<T::EthSpec>>>,
+    custody_columns: HashSet<ColumnIndex>,
     publish_fn: impl Fn(BlobsOrDataColumns<T>) + Send + 'static,
 ) -> Result<Option<AvailabilityProcessingStatus>, FetchEngineBlobError> {
     let versioned_hashes = if let Some(kzg_commitments) = block
@@ -66,8 +85,34 @@ pub async fn fetch_and_process_engine_blobs<T: BeaconChainTypes>(
         return Ok(None);
     };
 
-    let num_expected_blobs = versioned_hashes.len();
+    debug!(
+        num_expected_blobs = versioned_hashes.len(),
+        "Fetching blobs from the EL"
+    );
 
+    if chain.spec.is_peer_das_enabled_for_epoch(block.epoch()) {
+        fetch_and_process_blobs_v2(
+            chain,
+            block_root,
+            block,
+            versioned_hashes,
+            custody_columns,
+            publish_fn,
+        )
+        .await
+    } else {
+        fetch_and_process_blobs_v1(chain, block_root, block, versioned_hashes, publish_fn).await
+    }
+}
+
+async fn fetch_and_process_blobs_v1<T: BeaconChainTypes>(
+    chain: Arc<BeaconChain<T>>,
+    block_root: Hash256,
+    block: Arc<SignedBeaconBlock<T::EthSpec>>,
+    versioned_hashes: Vec<VersionedHash>,
+    publish_fn: impl Fn(BlobsOrDataColumns<T>) + Send + Sized,
+) -> Result<Option<AvailabilityProcessingStatus>, FetchEngineBlobError> {
+    let num_expected_blobs = versioned_hashes.len();
     let execution_layer = chain
         .execution_layer
         .as_ref()
@@ -76,7 +121,7 @@ pub async fn fetch_and_process_engine_blobs<T: BeaconChainTypes>(
     metrics::observe(&metrics::BLOBS_FROM_EL_EXPECTED, num_expected_blobs as f64);
     debug!(num_expected_blobs, "Fetching blobs from the EL");
     let response = execution_layer
-        .get_blobs(versioned_hashes)
+        .get_blobs_v1(versioned_hashes)
         .await
         .inspect_err(|_| {
             inc_counter(&metrics::BLOBS_FROM_EL_ERROR_TOTAL);
@@ -125,59 +170,9 @@ pub async fn fetch_and_process_engine_blobs<T: BeaconChainTypes>(
         .collect::<Result<Vec<_>, _>>()
         .map_err(FetchEngineBlobError::GossipBlob)?;
 
-    let peer_das_enabled = chain.spec.is_peer_das_enabled_for_epoch(block.epoch());
-
-    let data_columns_receiver_opt = if peer_das_enabled {
-        // Partial blobs response isn't useful for PeerDAS, so we don't bother building and publishing data columns.
-        if num_fetched_blobs != num_expected_blobs {
-            debug!(
-                info = "Unable to compute data columns",
-                num_fetched_blobs, num_expected_blobs, "Not all blobs fetched from the EL"
-            );
-            return Ok(None);
-        }
-
-        if chain
-            .canonical_head
-            .fork_choice_read_lock()
-            .contains_block(&block_root)
-        {
-            // Avoid computing columns if block has already been imported.
-            debug!(
-                info = "block has already been imported",
-                "Ignoring EL blobs response"
-            );
-            return Ok(None);
-        }
-
-        if chain
-            .canonical_head
-            .fork_choice_read_lock()
-            .contains_block(&block_root)
-        {
-            // Avoid computing columns if block has already been imported.
-            debug!(
-                info = "block has already been imported",
-                "Ignoring EL blobs response"
-            );
-            return Ok(None);
-        }
-
-        let data_columns_receiver = spawn_compute_and_publish_data_columns_task(
-            &chain,
-            block.clone(),
-            fixed_blob_sidecar_list.clone(),
-            publish_fn,
-        );
-
-        Some(data_columns_receiver)
-    } else {
-        if !blobs_to_import_and_publish.is_empty() {
-            publish_fn(BlobsOrDataColumns::Blobs(blobs_to_import_and_publish));
-        }
-
-        None
-    };
+    if !blobs_to_import_and_publish.is_empty() {
+        publish_fn(BlobsOrDataColumns::Blobs(blobs_to_import_and_publish));
+    }
 
     debug!(num_fetched_blobs, "Processing engine blobs");
 
@@ -185,8 +180,7 @@ pub async fn fetch_and_process_engine_blobs<T: BeaconChainTypes>(
         .process_engine_blobs(
             block.slot(),
             block_root,
-            fixed_blob_sidecar_list.clone(),
-            data_columns_receiver_opt,
+            EngineGetBlobsOutput::Blobs(fixed_blob_sidecar_list.clone()),
         )
         .await
         .map_err(FetchEngineBlobError::BlobProcessingError)?;
@@ -194,67 +188,140 @@ pub async fn fetch_and_process_engine_blobs<T: BeaconChainTypes>(
     Ok(Some(availability_processing_status))
 }
 
-/// Spawn a blocking task here for long computation tasks, so it doesn't block processing, and it
-/// allows blobs / data columns to propagate without waiting for processing.
-///
-/// An `mpsc::Sender` is then used to send the produced data columns to the `beacon_chain` for it
-/// to be persisted, **after** the block is made attestable.
-///
-/// The reason for doing this is to make the block available and attestable as soon as possible,
-/// while maintaining the invariant that block and data columns are persisted atomically.
-fn spawn_compute_and_publish_data_columns_task<T: BeaconChainTypes>(
+async fn fetch_and_process_blobs_v2<T: BeaconChainTypes>(
+    chain: Arc<BeaconChain<T>>,
+    block_root: Hash256,
+    block: Arc<SignedBeaconBlock<T::EthSpec>>,
+    versioned_hashes: Vec<VersionedHash>,
+    custody_columns_indices: HashSet<ColumnIndex>,
+    publish_fn: impl Fn(BlobsOrDataColumns<T>) + Send + 'static,
+) -> Result<Option<AvailabilityProcessingStatus>, FetchEngineBlobError> {
+    let num_expected_blobs = versioned_hashes.len();
+    let execution_layer = chain
+        .execution_layer
+        .as_ref()
+        .ok_or(FetchEngineBlobError::ExecutionLayerMissing)?;
+
+    metrics::observe(&metrics::BLOBS_FROM_EL_EXPECTED, num_expected_blobs as f64);
+    debug!(num_expected_blobs, "Fetching blobs from the EL");
+    let response = execution_layer
+        .get_blobs_v2(versioned_hashes)
+        .await
+        .inspect_err(|_| {
+            inc_counter(&metrics::BLOBS_FROM_EL_ERROR_TOTAL);
+        })
+        .map_err(FetchEngineBlobError::RequestFailed)?;
+
+    let (blobs, proofs): (Vec<_>, Vec<_>) = response
+        .into_iter()
+        .filter_map(|blob_and_proof_opt| {
+            blob_and_proof_opt.map(|blob_and_proof| {
+                let BlobAndProofV2 { blob, proofs } = blob_and_proof;
+                (blob, proofs)
+            })
+        })
+        .unzip();
+
+    let num_fetched_blobs = blobs.len();
+    metrics::observe(&metrics::BLOBS_FROM_EL_RECEIVED, num_fetched_blobs as f64);
+
+    // Partial blobs response isn't useful for PeerDAS, so we don't bother building and publishing data columns.
+    if num_fetched_blobs != num_expected_blobs {
+        debug!(
+            info = "Unable to compute data columns",
+            num_fetched_blobs, num_expected_blobs, "Not all blobs fetched from the EL"
+        );
+        inc_counter(&metrics::BLOBS_FROM_EL_MISS_TOTAL);
+        return Ok(None);
+    } else {
+        inc_counter(&metrics::BLOBS_FROM_EL_HIT_TOTAL);
+    }
+
+    if chain
+        .canonical_head
+        .fork_choice_read_lock()
+        .contains_block(&block_root)
+    {
+        // Avoid computing columns if block has already been imported.
+        debug!(
+            info = "block has already been imported",
+            "Ignoring EL blobs response"
+        );
+        return Ok(None);
+    }
+
+    let custody_columns = compute_and_publish_data_columns(
+        &chain,
+        block.clone(),
+        blobs,
+        proofs,
+        custody_columns_indices,
+        publish_fn,
+    )
+    .await?;
+
+    debug!(num_fetched_blobs, "Processing engine blobs");
+
+    let availability_processing_status = chain
+        .process_engine_blobs(
+            block.slot(),
+            block_root,
+            EngineGetBlobsOutput::CustodyColumns(custody_columns),
+        )
+        .await
+        .map_err(FetchEngineBlobError::BlobProcessingError)?;
+
+    Ok(Some(availability_processing_status))
+}
+
+/// Offload the data column computation to a blocking task to avoid holding up the async runtime.
+async fn compute_and_publish_data_columns<T: BeaconChainTypes>(
     chain: &Arc<BeaconChain<T>>,
     block: Arc<SignedBeaconBlock<T::EthSpec, FullPayload<T::EthSpec>>>,
-    blobs: FixedBlobSidecarList<T::EthSpec>,
+    blobs: Vec<Blob<T::EthSpec>>,
+    proofs: Vec<KzgProofs<T::EthSpec>>,
+    custody_columns_indices: HashSet<ColumnIndex>,
     publish_fn: impl Fn(BlobsOrDataColumns<T>) + Send + 'static,
-) -> oneshot::Receiver<Vec<Arc<DataColumnSidecar<T::EthSpec>>>> {
+) -> Result<DataColumnSidecarList<T::EthSpec>, FetchEngineBlobError> {
     let chain_cloned = chain.clone();
-    let (data_columns_sender, data_columns_receiver) = oneshot::channel();
+    chain
+        .spawn_blocking_handle(
+            move || {
+                let mut timer = metrics::start_timer_vec(
+                    &metrics::DATA_COLUMN_SIDECAR_COMPUTATION,
+                    &[&blobs.len().to_string()],
+                );
 
-    chain.task_executor.spawn_blocking(
-        move || {
-            let mut timer = metrics::start_timer_vec(
-                &metrics::DATA_COLUMN_SIDECAR_COMPUTATION,
-                &[&blobs.len().to_string()],
-            );
-            let blob_refs = blobs
-                .iter()
-                .filter_map(|b| b.as_ref().map(|b| &b.blob))
-                .collect::<Vec<_>>();
-            let data_columns_result = blobs_to_data_column_sidecars(
-                &blob_refs,
-                &block,
-                &chain_cloned.kzg,
-                &chain_cloned.spec,
-            )
-            .discard_timer_on_break(&mut timer);
-            drop(timer);
+                let blob_refs = blobs.iter().collect::<Vec<_>>();
+                let cell_proofs = proofs.into_iter().flatten().collect();
+                let data_columns_result = blobs_to_data_column_sidecars(
+                    &blob_refs,
+                    cell_proofs,
+                    &block,
+                    &chain_cloned.kzg,
+                    &chain_cloned.spec,
+                )
+                .discard_timer_on_break(&mut timer);
+                drop(timer);
 
-            let all_data_columns = match data_columns_result {
-                Ok(d) => d,
-                Err(e) => {
-                    error!(
-                        error = ?e,
-                        "Failed to build data column sidecars from blobs"
-                    );
-                    return;
-                }
-            };
+                // This filtering ensures we only import and publish the custody columns.
+                // `DataAvailabilityChecker` requires a strict match on custody columns count to
+                // consider a block available.
+                let custody_columns = data_columns_result
+                    .map(|mut data_columns| {
+                        data_columns.retain(|col| custody_columns_indices.contains(&col.index));
+                        data_columns
+                    })
+                    .map_err(FetchEngineBlobError::DataColumnSidecarError)?;
 
-            if data_columns_sender.send(all_data_columns.clone()).is_err() {
-                // Data column receiver have been dropped - block may have already been imported.
-                // This race condition exists because gossip columns may arrive and trigger block
-                // import during the computation. Here we just drop the computed columns.
-                debug!("Failed to send computed data columns");
-                return;
-            };
-
-            publish_fn(BlobsOrDataColumns::DataColumns(all_data_columns));
-        },
-        "compute_and_publish_data_columns",
-    );
-
-    data_columns_receiver
+                publish_fn(BlobsOrDataColumns::DataColumns(custody_columns.clone()));
+                Ok(custody_columns)
+            },
+            "compute_and_publish_data_columns",
+        )
+        .await
+        .map_err(FetchEngineBlobError::BeaconChainError)
+        .and_then(|r| r)
 }
 
 fn build_blob_sidecars<E: EthSpec>(
diff --git a/beacon_node/beacon_chain/src/fulu_readiness.rs b/beacon_node/beacon_chain/src/fulu_readiness.rs
index 872fe58f2b..1107acad74 100644
--- a/beacon_node/beacon_chain/src/fulu_readiness.rs
+++ b/beacon_node/beacon_chain/src/fulu_readiness.rs
@@ -1,7 +1,7 @@
 //! Provides tools for checking if a node is ready for the Fulu upgrade.
 
 use crate::{BeaconChain, BeaconChainTypes};
-use execution_layer::http::{ENGINE_GET_PAYLOAD_V4, ENGINE_NEW_PAYLOAD_V4};
+use execution_layer::http::{ENGINE_GET_PAYLOAD_V5, ENGINE_NEW_PAYLOAD_V4};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::time::Duration;
@@ -87,12 +87,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 Ok(capabilities) => {
                     let mut missing_methods = String::from("Required Methods Unsupported:");
                     let mut all_good = true;
-                    // TODO(fulu) switch to v5 when the EL is ready
-                    if !capabilities.get_payload_v4 {
+                    if !capabilities.get_payload_v5 {
                         missing_methods.push(' ');
-                        missing_methods.push_str(ENGINE_GET_PAYLOAD_V4);
+                        missing_methods.push_str(ENGINE_GET_PAYLOAD_V5);
                         all_good = false;
                     }
+                    // TODO(fulu) switch to v5 when the EL is ready
                     if !capabilities.new_payload_v4 {
                         missing_methods.push(' ');
                         missing_methods.push_str(ENGINE_NEW_PAYLOAD_V4);
diff --git a/beacon_node/beacon_chain/src/historical_blocks.rs b/beacon_node/beacon_chain/src/historical_blocks.rs
index ee51964910..348e6d52a6 100644
--- a/beacon_node/beacon_chain/src/historical_blocks.rs
+++ b/beacon_node/beacon_chain/src/historical_blocks.rs
@@ -132,7 +132,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 AvailableBlockData::Blobs(..) => {
                     new_oldest_blob_slot = Some(block.slot());
                 }
-                AvailableBlockData::DataColumns(_) | AvailableBlockData::DataColumnsRecv(_) => {
+                AvailableBlockData::DataColumns(_) => {
                     new_oldest_data_column_slot = Some(block.slot());
                 }
             }
diff --git a/beacon_node/beacon_chain/src/kzg_utils.rs b/beacon_node/beacon_chain/src/kzg_utils.rs
index 06cce14144..eaaa23130d 100644
--- a/beacon_node/beacon_chain/src/kzg_utils.rs
+++ b/beacon_node/beacon_chain/src/kzg_utils.rs
@@ -1,14 +1,15 @@
 use kzg::{
-    Blob as KzgBlob, Bytes48, CellRef as KzgCellRef, CellsAndKzgProofs, Error as KzgError, Kzg,
+    Blob as KzgBlob, Bytes48, Cell as KzgCell, CellRef as KzgCellRef, CellsAndKzgProofs,
+    Error as KzgError, Kzg, CELLS_PER_EXT_BLOB,
 };
 use rayon::prelude::*;
-use ssz_types::FixedVector;
+use ssz_types::{FixedVector, VariableList};
 use std::sync::Arc;
 use types::beacon_block_body::KzgCommitments;
 use types::data_column_sidecar::{Cell, DataColumn, DataColumnSidecarError};
 use types::{
     Blob, BlobSidecar, BlobSidecarList, ChainSpec, ColumnIndex, DataColumnSidecar,
-    DataColumnSidecarList, EthSpec, Hash256, KzgCommitment, KzgProof, KzgProofs, SignedBeaconBlock,
+    DataColumnSidecarList, EthSpec, Hash256, KzgCommitment, KzgProof, SignedBeaconBlock,
     SignedBeaconBlockHeader, SignedBlindedBeaconBlock,
 };
 
@@ -43,6 +44,33 @@ pub fn validate_blob<E: EthSpec>(
     kzg.verify_blob_kzg_proof(&kzg_blob, kzg_commitment, kzg_proof)
 }
 
+/// Validates a list of blobs along with their corresponding KZG commitments and
+/// cell proofs for the extended blobs.
+pub fn validate_blobs_and_cell_proofs<E: EthSpec>(
+    kzg: &Kzg,
+    blobs: Vec<&Blob<E>>,
+    cell_proofs: &[KzgProof],
+    kzg_commitments: &KzgCommitments<E>,
+) -> Result<(), KzgError> {
+    let cells = compute_cells::<E>(&blobs, kzg)?;
+    let cell_refs = cells.iter().map(|cell| cell.as_ref()).collect::<Vec<_>>();
+    let cell_indices = (0..blobs.len())
+        .flat_map(|_| 0..CELLS_PER_EXT_BLOB as u64)
+        .collect::<Vec<_>>();
+
+    let proofs = cell_proofs
+        .iter()
+        .map(|&proof| Bytes48::from(proof))
+        .collect::<Vec<_>>();
+
+    let commitments = kzg_commitments
+        .iter()
+        .flat_map(|&commitment| std::iter::repeat_n(Bytes48::from(commitment), CELLS_PER_EXT_BLOB))
+        .collect::<Vec<_>>();
+
+    kzg.verify_cell_proof_batch(&cell_refs, &proofs, cell_indices, &commitments)
+}
+
 /// Validate a batch of `DataColumnSidecar`.
 pub fn validate_data_columns<'a, E: EthSpec, I>(
     kzg: &Kzg,
@@ -148,6 +176,7 @@ pub fn verify_kzg_proof<E: EthSpec>(
 /// Build data column sidecars from a signed beacon block and its blobs.
 pub fn blobs_to_data_column_sidecars<E: EthSpec>(
     blobs: &[&Blob<E>],
+    cell_proofs: Vec<KzgProof>,
     block: &SignedBeaconBlock<E>,
     kzg: &Kzg,
     spec: &ChainSpec,
@@ -164,15 +193,28 @@ pub fn blobs_to_data_column_sidecars<E: EthSpec>(
     let kzg_commitments_inclusion_proof = block.message().body().kzg_commitments_merkle_proof()?;
     let signed_block_header = block.signed_block_header();
 
+    let proof_chunks = cell_proofs
+        .chunks_exact(spec.number_of_columns as usize)
+        .collect::<Vec<_>>();
+
     // NOTE: assumes blob sidecars are ordered by index
     let blob_cells_and_proofs_vec = blobs
         .into_par_iter()
-        .map(|blob| {
+        .zip(proof_chunks.into_par_iter())
+        .map(|(blob, proofs)| {
             let blob = blob
                 .as_ref()
                 .try_into()
                 .expect("blob should have a guaranteed size due to FixedVector");
-            kzg.compute_cells_and_proofs(blob)
+
+            kzg.compute_cells(blob).map(|cells| {
+                (
+                    cells,
+                    proofs
+                        .try_into()
+                        .expect("proof chunks should have exactly `number_of_columns` proofs"),
+                )
+            })
         })
         .collect::<Result<Vec<_>, KzgError>>()?;
 
@@ -186,6 +228,23 @@ pub fn blobs_to_data_column_sidecars<E: EthSpec>(
     .map_err(DataColumnSidecarError::BuildSidecarFailed)
 }
 
+pub fn compute_cells<E: EthSpec>(blobs: &[&Blob<E>], kzg: &Kzg) -> Result<Vec<KzgCell>, KzgError> {
+    let cells_vec = blobs
+        .into_par_iter()
+        .map(|blob| {
+            let blob = blob
+                .as_ref()
+                .try_into()
+                .expect("blob should have a guaranteed size due to FixedVector");
+
+            kzg.compute_cells(blob)
+        })
+        .collect::<Result<Vec<_>, KzgError>>()?;
+
+    let cells_flattened: Vec<KzgCell> = cells_vec.into_iter().flatten().collect();
+    Ok(cells_flattened)
+}
+
 pub(crate) fn build_data_column_sidecars<E: EthSpec>(
     kzg_commitments: KzgCommitments<E>,
     kzg_commitments_inclusion_proof: FixedVector<Hash256, E::KzgCommitmentsInclusionProofDepth>,
@@ -236,7 +295,7 @@ pub(crate) fn build_data_column_sidecars<E: EthSpec>(
                 index: index as u64,
                 column: DataColumn::<E>::from(col),
                 kzg_commitments: kzg_commitments.clone(),
-                kzg_proofs: KzgProofs::<E>::from(proofs),
+                kzg_proofs: VariableList::from(proofs),
                 signed_block_header: signed_block_header.clone(),
                 kzg_commitments_inclusion_proof: kzg_commitments_inclusion_proof.clone(),
             })
@@ -300,12 +359,7 @@ pub fn reconstruct_blobs<E: EthSpec>(
                 .collect();
 
             let blob = Blob::<E>::new(blob_bytes).map_err(|e| format!("{e:?}"))?;
-            let kzg_commitment = first_data_column
-                .kzg_commitments
-                .get(row_index)
-                .ok_or(format!("Missing KZG commitment for blob {row_index}"))?;
-            let kzg_proof = compute_blob_kzg_proof::<E>(kzg, &blob, *kzg_commitment)
-                .map_err(|e| format!("{e:?}"))?;
+            let kzg_proof = KzgProof::empty();
 
             BlobSidecar::<E>::new_with_existing_proof(
                 row_index,
@@ -373,14 +427,15 @@ pub fn reconstruct_data_columns<E: EthSpec>(
 mod test {
     use crate::kzg_utils::{
         blobs_to_data_column_sidecars, reconstruct_blobs, reconstruct_data_columns,
+        validate_blobs_and_cell_proofs,
     };
     use bls::Signature;
     use eth2::types::BlobsBundle;
     use execution_layer::test_utils::generate_blobs;
     use kzg::{trusted_setup::get_trusted_setup, Kzg, KzgCommitment, TrustedSetup};
     use types::{
-        beacon_block_body::KzgCommitments, BeaconBlock, BeaconBlockDeneb, BlobsList, ChainSpec,
-        EmptyBlock, EthSpec, MainnetEthSpec, SignedBeaconBlock,
+        beacon_block_body::KzgCommitments, BeaconBlock, BeaconBlockFulu, BlobsList, ChainSpec,
+        EmptyBlock, EthSpec, ForkName, FullPayload, KzgProofs, MainnetEthSpec, SignedBeaconBlock,
     };
 
     type E = MainnetEthSpec;
@@ -389,32 +444,52 @@ mod test {
     // only load it once.
     #[test]
     fn test_build_data_columns_sidecars() {
-        let spec = E::default_spec();
+        let spec = ForkName::Fulu.make_genesis_spec(E::default_spec());
         let kzg = get_kzg();
         test_build_data_columns_empty(&kzg, &spec);
         test_build_data_columns(&kzg, &spec);
         test_reconstruct_data_columns(&kzg, &spec);
         test_reconstruct_blobs_from_data_columns(&kzg, &spec);
+        test_verify_blob_and_cell_proofs(&kzg);
+    }
+
+    #[track_caller]
+    fn test_verify_blob_and_cell_proofs(kzg: &Kzg) {
+        let (blobs_bundle, _) = generate_blobs::<E>(3, ForkName::Fulu).unwrap();
+        let BlobsBundle {
+            blobs,
+            commitments,
+            proofs,
+        } = blobs_bundle;
+
+        let result =
+            validate_blobs_and_cell_proofs::<E>(kzg, blobs.iter().collect(), &proofs, &commitments);
+
+        assert!(result.is_ok());
     }
 
     #[track_caller]
     fn test_build_data_columns_empty(kzg: &Kzg, spec: &ChainSpec) {
         let num_of_blobs = 0;
-        let (signed_block, blobs) = create_test_block_and_blobs::<E>(num_of_blobs, spec);
+        let (signed_block, blobs, proofs) =
+            create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
         let blob_refs = blobs.iter().collect::<Vec<_>>();
         let column_sidecars =
-            blobs_to_data_column_sidecars(&blob_refs, &signed_block, kzg, spec).unwrap();
+            blobs_to_data_column_sidecars(&blob_refs, proofs.to_vec(), &signed_block, kzg, spec)
+                .unwrap();
         assert!(column_sidecars.is_empty());
     }
 
     #[track_caller]
     fn test_build_data_columns(kzg: &Kzg, spec: &ChainSpec) {
         let num_of_blobs = 6;
-        let (signed_block, blobs) = create_test_block_and_blobs::<E>(num_of_blobs, spec);
+        let (signed_block, blobs, proofs) =
+            create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
 
         let blob_refs = blobs.iter().collect::<Vec<_>>();
         let column_sidecars =
-            blobs_to_data_column_sidecars(&blob_refs, &signed_block, kzg, spec).unwrap();
+            blobs_to_data_column_sidecars(&blob_refs, proofs.to_vec(), &signed_block, kzg, spec)
+                .unwrap();
 
         let block_kzg_commitments = signed_block
             .message()
@@ -448,10 +523,12 @@ mod test {
     #[track_caller]
     fn test_reconstruct_data_columns(kzg: &Kzg, spec: &ChainSpec) {
         let num_of_blobs = 6;
-        let (signed_block, blobs) = create_test_block_and_blobs::<E>(num_of_blobs, spec);
+        let (signed_block, blobs, proofs) =
+            create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
         let blob_refs = blobs.iter().collect::<Vec<_>>();
         let column_sidecars =
-            blobs_to_data_column_sidecars(&blob_refs, &signed_block, kzg, spec).unwrap();
+            blobs_to_data_column_sidecars(&blob_refs, proofs.to_vec(), &signed_block, kzg, spec)
+                .unwrap();
 
         // Now reconstruct
         let reconstructed_columns = reconstruct_data_columns(
@@ -469,10 +546,12 @@ mod test {
     #[track_caller]
     fn test_reconstruct_blobs_from_data_columns(kzg: &Kzg, spec: &ChainSpec) {
         let num_of_blobs = 6;
-        let (signed_block, blobs) = create_test_block_and_blobs::<E>(num_of_blobs, spec);
+        let (signed_block, blobs, proofs) =
+            create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
         let blob_refs = blobs.iter().collect::<Vec<_>>();
         let column_sidecars =
-            blobs_to_data_column_sidecars(&blob_refs, &signed_block, kzg, spec).unwrap();
+            blobs_to_data_column_sidecars(&blob_refs, proofs.to_vec(), &signed_block, kzg, spec)
+                .unwrap();
 
         // Now reconstruct
         let signed_blinded_block = signed_block.into();
@@ -504,11 +583,15 @@ mod test {
         Kzg::new_from_trusted_setup_das_enabled(trusted_setup).expect("should create kzg")
     }
 
-    fn create_test_block_and_blobs<E: EthSpec>(
+    fn create_test_fulu_block_and_blobs<E: EthSpec>(
         num_of_blobs: usize,
         spec: &ChainSpec,
-    ) -> (SignedBeaconBlock<E>, BlobsList<E>) {
-        let mut block = BeaconBlock::Deneb(BeaconBlockDeneb::empty(spec));
+    ) -> (
+        SignedBeaconBlock<E, FullPayload<E>>,
+        BlobsList<E>,
+        KzgProofs<E>,
+    ) {
+        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 =
@@ -516,12 +599,12 @@ mod test {
                 .unwrap();
 
         let mut signed_block = SignedBeaconBlock::from_block(block, Signature::empty());
-
-        let (blobs_bundle, _) = generate_blobs::<E>(num_of_blobs).unwrap();
+        let fork = signed_block.fork_name_unchecked();
+        let (blobs_bundle, _) = generate_blobs::<E>(num_of_blobs, fork).unwrap();
         let BlobsBundle {
             blobs,
             commitments,
-            proofs: _,
+            proofs,
         } = blobs_bundle;
 
         *signed_block
@@ -530,6 +613,6 @@ mod test {
             .blob_kzg_commitments_mut()
             .unwrap() = commitments;
 
-        (signed_block, blobs)
+        (signed_block, blobs, proofs)
     }
 }
diff --git a/beacon_node/beacon_chain/src/metrics.rs b/beacon_node/beacon_chain/src/metrics.rs
index 871721b4d8..57012161ec 100644
--- a/beacon_node/beacon_chain/src/metrics.rs
+++ b/beacon_node/beacon_chain/src/metrics.rs
@@ -1663,7 +1663,7 @@ pub static BLOBS_FROM_EL_HIT_TOTAL: LazyLock<Result<IntCounter>> = LazyLock::new
 pub static BLOBS_FROM_EL_MISS_TOTAL: LazyLock<Result<IntCounter>> = LazyLock::new(|| {
     try_create_int_counter(
         "beacon_blobs_from_el_miss_total",
-        "Number of empty blob responses from the execution layer",
+        "Number of empty or incomplete blob responses from the execution layer",
     )
 });
 
diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs
index fe78d83c03..bcab512a4b 100644
--- a/beacon_node/beacon_chain/src/test_utils.rs
+++ b/beacon_node/beacon_chain/src/test_utils.rs
@@ -3194,7 +3194,7 @@ pub fn generate_rand_block_and_blobs<E: EthSpec>(
                 NumBlobs::None => 0,
             };
             let (bundle, transactions) =
-                execution_layer::test_utils::generate_blobs::<E>(num_blobs).unwrap();
+                execution_layer::test_utils::generate_blobs::<E>(num_blobs, fork_name).unwrap();
 
             payload.execution_payload.transactions = <_>::default();
             for tx in Vec::from(transactions) {
@@ -3214,7 +3214,7 @@ pub fn generate_rand_block_and_blobs<E: EthSpec>(
                 NumBlobs::None => 0,
             };
             let (bundle, transactions) =
-                execution_layer::test_utils::generate_blobs::<E>(num_blobs).unwrap();
+                execution_layer::test_utils::generate_blobs::<E>(num_blobs, fork_name).unwrap();
             payload.execution_payload.transactions = <_>::default();
             for tx in Vec::from(transactions) {
                 payload.execution_payload.transactions.push(tx).unwrap();
@@ -3233,7 +3233,7 @@ pub fn generate_rand_block_and_blobs<E: EthSpec>(
                 NumBlobs::None => 0,
             };
             let (bundle, transactions) =
-                execution_layer::test_utils::generate_blobs::<E>(num_blobs).unwrap();
+                execution_layer::test_utils::generate_blobs::<E>(num_blobs, fork_name).unwrap();
             payload.execution_payload.transactions = <_>::default();
             for tx in Vec::from(transactions) {
                 payload.execution_payload.transactions.push(tx).unwrap();
diff --git a/beacon_node/execution_layer/src/engine_api.rs b/beacon_node/execution_layer/src/engine_api.rs
index aed6cdba67..4bfee223ff 100644
--- a/beacon_node/execution_layer/src/engine_api.rs
+++ b/beacon_node/execution_layer/src/engine_api.rs
@@ -1,10 +1,11 @@
 use crate::engines::ForkchoiceState;
 use crate::http::{
     ENGINE_FORKCHOICE_UPDATED_V1, ENGINE_FORKCHOICE_UPDATED_V2, ENGINE_FORKCHOICE_UPDATED_V3,
-    ENGINE_GET_BLOBS_V1, ENGINE_GET_CLIENT_VERSION_V1, ENGINE_GET_PAYLOAD_BODIES_BY_HASH_V1,
-    ENGINE_GET_PAYLOAD_BODIES_BY_RANGE_V1, ENGINE_GET_PAYLOAD_V1, ENGINE_GET_PAYLOAD_V2,
-    ENGINE_GET_PAYLOAD_V3, ENGINE_GET_PAYLOAD_V4, ENGINE_GET_PAYLOAD_V5, ENGINE_NEW_PAYLOAD_V1,
-    ENGINE_NEW_PAYLOAD_V2, ENGINE_NEW_PAYLOAD_V3, ENGINE_NEW_PAYLOAD_V4, ENGINE_NEW_PAYLOAD_V5,
+    ENGINE_GET_BLOBS_V1, ENGINE_GET_BLOBS_V2, ENGINE_GET_CLIENT_VERSION_V1,
+    ENGINE_GET_PAYLOAD_BODIES_BY_HASH_V1, ENGINE_GET_PAYLOAD_BODIES_BY_RANGE_V1,
+    ENGINE_GET_PAYLOAD_V1, ENGINE_GET_PAYLOAD_V2, ENGINE_GET_PAYLOAD_V3, ENGINE_GET_PAYLOAD_V4,
+    ENGINE_GET_PAYLOAD_V5, ENGINE_NEW_PAYLOAD_V1, ENGINE_NEW_PAYLOAD_V2, ENGINE_NEW_PAYLOAD_V3,
+    ENGINE_NEW_PAYLOAD_V4, ENGINE_NEW_PAYLOAD_V5,
 };
 use eth2::types::{
     BlobsBundle, SsePayloadAttributes, SsePayloadAttributesV1, SsePayloadAttributesV2,
@@ -553,6 +554,7 @@ pub struct EngineCapabilities {
     pub get_payload_v5: bool,
     pub get_client_version_v1: bool,
     pub get_blobs_v1: bool,
+    pub get_blobs_v2: bool,
 }
 
 impl EngineCapabilities {
@@ -609,6 +611,9 @@ impl EngineCapabilities {
         if self.get_blobs_v1 {
             response.push(ENGINE_GET_BLOBS_V1);
         }
+        if self.get_blobs_v2 {
+            response.push(ENGINE_GET_BLOBS_V2);
+        }
 
         response
     }
diff --git a/beacon_node/execution_layer/src/engine_api/http.rs b/beacon_node/execution_layer/src/engine_api/http.rs
index 747383754a..bf4c391a8d 100644
--- a/beacon_node/execution_layer/src/engine_api/http.rs
+++ b/beacon_node/execution_layer/src/engine_api/http.rs
@@ -61,6 +61,7 @@ pub const ENGINE_GET_CLIENT_VERSION_V1: &str = "engine_getClientVersionV1";
 pub const ENGINE_GET_CLIENT_VERSION_TIMEOUT: Duration = Duration::from_secs(1);
 
 pub const ENGINE_GET_BLOBS_V1: &str = "engine_getBlobsV1";
+pub const ENGINE_GET_BLOBS_V2: &str = "engine_getBlobsV2";
 pub const ENGINE_GET_BLOBS_TIMEOUT: Duration = Duration::from_secs(1);
 
 /// This error is returned during a `chainId` call by Geth.
@@ -87,6 +88,7 @@ pub static LIGHTHOUSE_CAPABILITIES: &[&str] = &[
     ENGINE_GET_PAYLOAD_BODIES_BY_RANGE_V1,
     ENGINE_GET_CLIENT_VERSION_V1,
     ENGINE_GET_BLOBS_V1,
+    ENGINE_GET_BLOBS_V2,
 ];
 
 /// We opt to initialize the JsonClientVersionV1 rather than the ClientVersionV1
@@ -708,7 +710,7 @@ impl HttpJsonRpc {
         }
     }
 
-    pub async fn get_blobs<E: EthSpec>(
+    pub async fn get_blobs_v1<E: EthSpec>(
         &self,
         versioned_hashes: Vec<Hash256>,
     ) -> Result<Vec<Option<BlobAndProofV1<E>>>, Error> {
@@ -722,6 +724,20 @@ impl HttpJsonRpc {
         .await
     }
 
+    pub async fn get_blobs_v2<E: EthSpec>(
+        &self,
+        versioned_hashes: Vec<Hash256>,
+    ) -> Result<Vec<Option<BlobAndProofV2<E>>>, Error> {
+        let params = json!([versioned_hashes]);
+
+        self.rpc_request(
+            ENGINE_GET_BLOBS_V2,
+            params,
+            ENGINE_GET_BLOBS_TIMEOUT * self.execution_timeout_multiplier,
+        )
+        .await
+    }
+
     pub async fn get_block_by_number(
         &self,
         query: BlockByNumberQuery<'_>,
@@ -963,19 +979,6 @@ impl HttpJsonRpc {
                     .try_into()
                     .map_err(Error::BadResponse)
             }
-            // TODO(fulu): remove when v5 method is ready.
-            ForkName::Fulu => {
-                let response: JsonGetPayloadResponseV5<E> = self
-                    .rpc_request(
-                        ENGINE_GET_PAYLOAD_V4,
-                        params,
-                        ENGINE_GET_PAYLOAD_TIMEOUT * self.execution_timeout_multiplier,
-                    )
-                    .await?;
-                JsonGetPayloadResponse::V5(response)
-                    .try_into()
-                    .map_err(Error::BadResponse)
-            }
             _ => Err(Error::UnsupportedForkVariant(format!(
                 "called get_payload_v4 with {}",
                 fork_name
@@ -1148,6 +1151,7 @@ impl HttpJsonRpc {
             get_payload_v5: capabilities.contains(ENGINE_GET_PAYLOAD_V5),
             get_client_version_v1: capabilities.contains(ENGINE_GET_CLIENT_VERSION_V1),
             get_blobs_v1: capabilities.contains(ENGINE_GET_BLOBS_V1),
+            get_blobs_v2: capabilities.contains(ENGINE_GET_BLOBS_V2),
         })
     }
 
@@ -1320,9 +1324,8 @@ impl HttpJsonRpc {
                 }
             }
             ForkName::Fulu => {
-                // TODO(fulu): switch to v5 when the EL is ready
-                if engine_capabilities.get_payload_v4 {
-                    self.get_payload_v4(fork_name, payload_id).await
+                if engine_capabilities.get_payload_v5 {
+                    self.get_payload_v5(fork_name, payload_id).await
                 } else {
                     Err(Error::RequiredMethodUnsupported("engine_getPayloadv5"))
                 }
diff --git a/beacon_node/execution_layer/src/engine_api/json_structures.rs b/beacon_node/execution_layer/src/engine_api/json_structures.rs
index 96615297d8..30d30481ea 100644
--- a/beacon_node/execution_layer/src/engine_api/json_structures.rs
+++ b/beacon_node/execution_layer/src/engine_api/json_structures.rs
@@ -717,12 +717,23 @@ impl<E: EthSpec> From<JsonBlobsBundleV1<E>> for BlobsBundle<E> {
     }
 }
 
+#[superstruct(
+    variants(V1, V2),
+    variant_attributes(
+        derive(Debug, Clone, PartialEq, Serialize, Deserialize),
+        serde(bound = "E: EthSpec", rename_all = "camelCase")
+    )
+)]
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(bound = "E: EthSpec", rename_all = "camelCase")]
-pub struct BlobAndProofV1<E: EthSpec> {
+pub struct BlobAndProof<E: EthSpec> {
     #[serde(with = "ssz_types::serde_utils::hex_fixed_vec")]
     pub blob: Blob<E>,
+    /// KZG proof for the blob (Deneb)
+    #[superstruct(only(V1))]
     pub proof: KzgProof,
+    /// KZG cell proofs for the extended blob (PeerDAS)
+    #[superstruct(only(V2))]
+    pub proofs: KzgProofs<E>,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
diff --git a/beacon_node/execution_layer/src/lib.rs b/beacon_node/execution_layer/src/lib.rs
index 944a8e083b..ee326f22cd 100644
--- a/beacon_node/execution_layer/src/lib.rs
+++ b/beacon_node/execution_layer/src/lib.rs
@@ -4,7 +4,7 @@
 //! This crate only provides useful functionality for "The Merge", it does not provide any of the
 //! deposit-contract functionality that the `beacon_node/eth1` crate already provides.
 
-use crate::json_structures::BlobAndProofV1;
+use crate::json_structures::{BlobAndProofV1, BlobAndProofV2};
 use crate::payload_cache::PayloadCache;
 use arc_swap::ArcSwapOption;
 use auth::{strip_prefix, Auth, JwtKey};
@@ -16,8 +16,8 @@ pub use engine_api::*;
 pub use engine_api::{http, http::deposit_methods, http::HttpJsonRpc};
 use engines::{Engine, EngineError};
 pub use engines::{EngineState, ForkchoiceState};
-use eth2::types::FullPayloadContents;
-use eth2::types::{builder_bid::SignedBuilderBid, BlobsBundle, ForkVersionedResponse};
+use eth2::types::{builder_bid::SignedBuilderBid, ForkVersionedResponse};
+use eth2::types::{BlobsBundle, FullPayloadContents};
 use ethers_core::types::Transaction as EthersTransaction;
 use fixed_bytes::UintExtended;
 use fork_choice::ForkchoiceUpdateParameters;
@@ -596,13 +596,7 @@ impl<E: EthSpec> ExecutionLayer<E> {
         let (payload_ref, maybe_json_blobs_bundle) = payload_and_blobs;
 
         let payload = payload_ref.clone_from_ref();
-        let maybe_blobs_bundle = maybe_json_blobs_bundle
-            .cloned()
-            .map(|blobs_bundle| BlobsBundle {
-                commitments: blobs_bundle.commitments,
-                proofs: blobs_bundle.proofs,
-                blobs: blobs_bundle.blobs,
-            });
+        let maybe_blobs_bundle = maybe_json_blobs_bundle.cloned();
 
         self.inner
             .payload_cache
@@ -1846,7 +1840,7 @@ impl<E: EthSpec> ExecutionLayer<E> {
         }
     }
 
-    pub async fn get_blobs(
+    pub async fn get_blobs_v1(
         &self,
         query: Vec<Hash256>,
     ) -> Result<Vec<Option<BlobAndProofV1<E>>>, Error> {
@@ -1854,7 +1848,24 @@ impl<E: EthSpec> ExecutionLayer<E> {
 
         if capabilities.get_blobs_v1 {
             self.engine()
-                .request(|engine| async move { engine.api.get_blobs(query).await })
+                .request(|engine| async move { engine.api.get_blobs_v1(query).await })
+                .await
+                .map_err(Box::new)
+                .map_err(Error::EngineError)
+        } else {
+            Err(Error::GetBlobsNotSupported)
+        }
+    }
+
+    pub async fn get_blobs_v2(
+        &self,
+        query: Vec<Hash256>,
+    ) -> Result<Vec<Option<BlobAndProofV2<E>>>, Error> {
+        let capabilities = self.get_engine_capabilities(None).await?;
+
+        if capabilities.get_blobs_v2 {
+            self.engine()
+                .request(|engine| async move { engine.api.get_blobs_v2(query).await })
                 .await
                 .map_err(Box::new)
                 .map_err(Error::EngineError)
diff --git a/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs b/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
index 81fb9bd7b8..b057abe887 100644
--- a/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
+++ b/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
@@ -20,13 +20,14 @@ use tree_hash_derive::TreeHash;
 use types::{
     Blob, ChainSpec, EthSpec, ExecutionBlockHash, ExecutionPayload, ExecutionPayloadBellatrix,
     ExecutionPayloadCapella, ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadFulu,
-    ExecutionPayloadHeader, FixedBytesExtended, ForkName, Hash256, Transaction, Transactions,
-    Uint256,
+    ExecutionPayloadHeader, FixedBytesExtended, ForkName, Hash256, KzgProofs, Transaction,
+    Transactions, Uint256,
 };
 
 use super::DEFAULT_TERMINAL_BLOCK;
 
 const TEST_BLOB_BUNDLE: &[u8] = include_bytes!("fixtures/mainnet/test_blobs_bundle.ssz");
+const TEST_BLOB_BUNDLE_V2: &[u8] = include_bytes!("fixtures/mainnet/test_blobs_bundle_v2.ssz");
 
 pub const DEFAULT_GAS_LIMIT: u64 = 30_000_000;
 const GAS_USED: u64 = DEFAULT_GAS_LIMIT - 1;
@@ -697,15 +698,13 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
             },
         };
 
-        if execution_payload.fork_name().deneb_enabled() {
+        let fork_name = execution_payload.fork_name();
+        if fork_name.deneb_enabled() {
             // get random number between 0 and Max Blobs
             let mut rng = self.rng.lock();
-            let max_blobs = self
-                .spec
-                .max_blobs_per_block_by_fork(execution_payload.fork_name())
-                as usize;
+            let max_blobs = self.spec.max_blobs_per_block_by_fork(fork_name) as usize;
             let num_blobs = rng.gen::<usize>() % (max_blobs + 1);
-            let (bundle, transactions) = generate_blobs(num_blobs)?;
+            let (bundle, transactions) = generate_blobs(num_blobs, fork_name)?;
             for tx in Vec::from(transactions) {
                 execution_payload
                     .transactions_mut()
@@ -721,7 +720,8 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
     }
 }
 
-pub fn load_test_blobs_bundle<E: EthSpec>() -> Result<(KzgCommitment, KzgProof, Blob<E>), String> {
+pub fn load_test_blobs_bundle_v1<E: EthSpec>() -> Result<(KzgCommitment, KzgProof, Blob<E>), String>
+{
     let BlobsBundle::<E> {
         commitments,
         proofs,
@@ -745,32 +745,56 @@ pub fn load_test_blobs_bundle<E: EthSpec>() -> Result<(KzgCommitment, KzgProof,
     ))
 }
 
+pub fn load_test_blobs_bundle_v2<E: EthSpec>(
+) -> Result<(KzgCommitment, KzgProofs<E>, Blob<E>), String> {
+    let BlobsBundle::<E> {
+        commitments,
+        proofs,
+        blobs,
+    } = BlobsBundle::from_ssz_bytes(TEST_BLOB_BUNDLE_V2)
+        .map_err(|e| format!("Unable to decode ssz: {:?}", e))?;
+
+    Ok((
+        commitments
+            .first()
+            .cloned()
+            .ok_or("commitment missing in test bundle")?,
+        // there's only one blob in the test bundle, hence we take all the cell proofs here.
+        proofs,
+        blobs
+            .first()
+            .cloned()
+            .ok_or("blob missing in test bundle")?,
+    ))
+}
+
 pub fn generate_blobs<E: EthSpec>(
     n_blobs: usize,
+    fork_name: ForkName,
 ) -> Result<(BlobsBundle<E>, Transactions<E>), String> {
-    let (kzg_commitment, kzg_proof, blob) = load_test_blobs_bundle::<E>()?;
+    let tx = static_valid_tx::<E>()
+        .map_err(|e| format!("error creating valid tx SSZ bytes: {:?}", e))?;
+    let transactions = vec![tx; n_blobs];
 
-    let mut bundle = BlobsBundle::<E>::default();
-    let mut transactions = vec![];
-
-    for blob_index in 0..n_blobs {
-        let tx = static_valid_tx::<E>()
-            .map_err(|e| format!("error creating valid tx SSZ bytes: {:?}", e))?;
-
-        transactions.push(tx);
-        bundle
-            .blobs
-            .push(blob.clone())
-            .map_err(|_| format!("blobs are full, blob index: {:?}", blob_index))?;
-        bundle
-            .commitments
-            .push(kzg_commitment)
-            .map_err(|_| format!("blobs are full, blob index: {:?}", blob_index))?;
-        bundle
-            .proofs
-            .push(kzg_proof)
-            .map_err(|_| format!("blobs are full, blob index: {:?}", blob_index))?;
-    }
+    let bundle = if fork_name.fulu_enabled() {
+        let (kzg_commitment, kzg_proofs, blob) = load_test_blobs_bundle_v2::<E>()?;
+        BlobsBundle {
+            commitments: vec![kzg_commitment; n_blobs].into(),
+            proofs: vec![kzg_proofs.to_vec(); n_blobs]
+                .into_iter()
+                .flatten()
+                .collect::<Vec<_>>()
+                .into(),
+            blobs: vec![blob; n_blobs].into(),
+        }
+    } else {
+        let (kzg_commitment, kzg_proof, blob) = load_test_blobs_bundle_v1::<E>()?;
+        BlobsBundle {
+            commitments: vec![kzg_commitment; n_blobs].into(),
+            proofs: vec![kzg_proof; n_blobs].into(),
+            blobs: vec![blob; n_blobs].into(),
+        }
+    };
 
     Ok((bundle, transactions.into()))
 }
@@ -905,7 +929,7 @@ pub fn generate_pow_block(
 #[cfg(test)]
 mod test {
     use super::*;
-    use kzg::{trusted_setup::get_trusted_setup, TrustedSetup};
+    use kzg::{trusted_setup::get_trusted_setup, Bytes48, CellRef, KzgBlobRef, TrustedSetup};
     use types::{MainnetEthSpec, MinimalEthSpec};
 
     #[test]
@@ -974,20 +998,28 @@ mod test {
     }
 
     #[test]
-    fn valid_test_blobs() {
+    fn valid_test_blobs_bundle_v1() {
         assert!(
-            validate_blob::<MainnetEthSpec>().is_ok(),
+            validate_blob_bundle_v1::<MainnetEthSpec>().is_ok(),
             "Mainnet preset test blobs bundle should contain valid proofs"
         );
         assert!(
-            validate_blob::<MinimalEthSpec>().is_ok(),
+            validate_blob_bundle_v1::<MinimalEthSpec>().is_ok(),
             "Minimal preset test blobs bundle should contain valid proofs"
         );
     }
 
-    fn validate_blob<E: EthSpec>() -> Result<(), String> {
+    #[test]
+    fn valid_test_blobs_bundle_v2() {
+        validate_blob_bundle_v2::<MainnetEthSpec>()
+            .expect("Mainnet preset test blobs bundle v2 should contain valid proofs");
+        validate_blob_bundle_v2::<MinimalEthSpec>()
+            .expect("Minimal preset test blobs bundle v2 should contain valid proofs");
+    }
+
+    fn validate_blob_bundle_v1<E: EthSpec>() -> Result<(), String> {
         let kzg = load_kzg()?;
-        let (kzg_commitment, kzg_proof, blob) = load_test_blobs_bundle::<E>()?;
+        let (kzg_commitment, kzg_proof, blob) = load_test_blobs_bundle_v1::<E>()?;
         let kzg_blob = kzg::Blob::from_bytes(blob.as_ref())
             .map(Box::new)
             .map_err(|e| format!("Error converting blob to kzg blob: {e:?}"))?;
@@ -995,6 +1027,26 @@ mod test {
             .map_err(|e| format!("Invalid blobs bundle: {e:?}"))
     }
 
+    fn validate_blob_bundle_v2<E: EthSpec>() -> Result<(), String> {
+        let kzg = load_kzg()?;
+        let (kzg_commitments, kzg_proofs, cells) =
+            load_test_blobs_bundle_v2::<E>().map(|(commitment, proofs, blob)| {
+                let kzg_blob: KzgBlobRef = blob.as_ref().try_into().unwrap();
+                (
+                    vec![Bytes48::from(commitment); proofs.len()],
+                    proofs.into_iter().map(|p| p.into()).collect::<Vec<_>>(),
+                    kzg.compute_cells(kzg_blob).unwrap(),
+                )
+            })?;
+        let (cell_indices, cell_refs): (Vec<u64>, Vec<CellRef>) = cells
+            .iter()
+            .enumerate()
+            .map(|(cell_idx, cell)| (cell_idx as u64, CellRef::try_from(cell.as_ref()).unwrap()))
+            .unzip();
+        kzg.verify_cell_proof_batch(&cell_refs, &kzg_proofs, cell_indices, &kzg_commitments)
+            .map_err(|e| format!("Invalid blobs bundle: {e:?}"))
+    }
+
     fn load_kzg() -> Result<Kzg, String> {
         let trusted_setup: TrustedSetup =
             serde_json::from_reader(get_trusted_setup().as_slice())
diff --git a/beacon_node/execution_layer/src/test_utils/fixtures/mainnet/test_blobs_bundle_v2.ssz b/beacon_node/execution_layer/src/test_utils/fixtures/mainnet/test_blobs_bundle_v2.ssz
new file mode 100644
index 0000000000000000000000000000000000000000..e57096c0766a553be2dfbea67b7b1a2570290305
GIT binary patch
literal 137276
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
Xy^H$fL);O0l=_PWS>x*q>n{)xg&xXO

literal 0
HcmV?d00001

diff --git a/beacon_node/execution_layer/src/test_utils/handle_rpc.rs b/beacon_node/execution_layer/src/test_utils/handle_rpc.rs
index d727d2c159..70c21afed4 100644
--- a/beacon_node/execution_layer/src/test_utils/handle_rpc.rs
+++ b/beacon_node/execution_layer/src/test_utils/handle_rpc.rs
@@ -383,9 +383,8 @@ pub async fn handle_rpc<E: EthSpec>(
                 == ForkName::Fulu
                 && (method == ENGINE_GET_PAYLOAD_V1
                     || method == ENGINE_GET_PAYLOAD_V2
-                    || method == ENGINE_GET_PAYLOAD_V3)
-            // TODO(fulu): Uncomment this once v5 method is ready for Fulu
-            // || method == ENGINE_GET_PAYLOAD_V4)
+                    || method == ENGINE_GET_PAYLOAD_V3
+                    || method == ENGINE_GET_PAYLOAD_V4)
             {
                 return Err((
                     format!("{} called after Fulu fork!", method),
@@ -451,22 +450,6 @@ pub async fn handle_rpc<E: EthSpec>(
                         })
                         .unwrap()
                     }
-                    // TODO(fulu): remove this once we switch to v5 method
-                    JsonExecutionPayload::V5(execution_payload) => {
-                        serde_json::to_value(JsonGetPayloadResponseV5 {
-                            execution_payload,
-                            block_value: Uint256::from(DEFAULT_MOCK_EL_PAYLOAD_VALUE_WEI),
-                            blobs_bundle: maybe_blobs
-                                .ok_or((
-                                    "No blobs returned despite V5 Payload".to_string(),
-                                    GENERIC_ERROR_CODE,
-                                ))?
-                                .into(),
-                            should_override_builder: false,
-                            execution_requests: Default::default(),
-                        })
-                        .unwrap()
-                    }
                     _ => unreachable!(),
                 }),
                 ENGINE_GET_PAYLOAD_V5 => Ok(match JsonExecutionPayload::from(response) {
diff --git a/beacon_node/execution_layer/src/test_utils/mock_builder.rs b/beacon_node/execution_layer/src/test_utils/mock_builder.rs
index fba34121a7..87ea8642be 100644
--- a/beacon_node/execution_layer/src/test_utils/mock_builder.rs
+++ b/beacon_node/execution_layer/src/test_utils/mock_builder.rs
@@ -546,7 +546,7 @@ impl<E: EthSpec> MockBuilder<E> {
                             .map_err(|_| "incorrect payload variant".to_string())?
                             .into(),
                         blob_kzg_commitments: maybe_blobs_bundle
-                            .map(|b| b.commitments)
+                            .map(|b| b.commitments.clone())
                             .unwrap_or_default(),
                         value: self.get_bid_value(value),
                         pubkey: self.builder_sk.public_key().compress(),
@@ -558,7 +558,7 @@ impl<E: EthSpec> MockBuilder<E> {
                             .map_err(|_| "incorrect payload variant".to_string())?
                             .into(),
                         blob_kzg_commitments: maybe_blobs_bundle
-                            .map(|b| b.commitments)
+                            .map(|b| b.commitments.clone())
                             .unwrap_or_default(),
                         value: self.get_bid_value(value),
                         pubkey: self.builder_sk.public_key().compress(),
@@ -570,7 +570,7 @@ impl<E: EthSpec> MockBuilder<E> {
                             .map_err(|_| "incorrect payload variant".to_string())?
                             .into(),
                         blob_kzg_commitments: maybe_blobs_bundle
-                            .map(|b| b.commitments)
+                            .map(|b| b.commitments.clone())
                             .unwrap_or_default(),
                         value: self.get_bid_value(value),
                         pubkey: self.builder_sk.public_key().compress(),
diff --git a/beacon_node/execution_layer/src/test_utils/mod.rs b/beacon_node/execution_layer/src/test_utils/mod.rs
index 17441a15fb..245aa71a15 100644
--- a/beacon_node/execution_layer/src/test_utils/mod.rs
+++ b/beacon_node/execution_layer/src/test_utils/mod.rs
@@ -58,6 +58,7 @@ pub const DEFAULT_ENGINE_CAPABILITIES: EngineCapabilities = EngineCapabilities {
     get_payload_v5: true,
     get_client_version_v1: true,
     get_blobs_v1: true,
+    get_blobs_v2: true,
 };
 
 pub static DEFAULT_CLIENT_VERSION: LazyLock<JsonClientVersionV1> =
diff --git a/beacon_node/http_api/src/publish_blocks.rs b/beacon_node/http_api/src/publish_blocks.rs
index a5cd94536d..ab70521686 100644
--- a/beacon_node/http_api/src/publish_blocks.rs
+++ b/beacon_node/http_api/src/publish_blocks.rs
@@ -364,7 +364,7 @@ fn spawn_build_data_sidecar_task<T: BeaconChainTypes>(
                 } else {
                     // Post PeerDAS: construct data columns.
                     let gossip_verified_data_columns =
-                        build_gossip_verified_data_columns(&chain, &block, blobs)?;
+                        build_gossip_verified_data_columns(&chain, &block, blobs, kzg_proofs)?;
                     Ok((vec![], gossip_verified_data_columns))
                 }
             },
@@ -383,10 +383,11 @@ fn build_gossip_verified_data_columns<T: BeaconChainTypes>(
     chain: &BeaconChain<T>,
     block: &SignedBeaconBlock<T::EthSpec, FullPayload<T::EthSpec>>,
     blobs: BlobsList<T::EthSpec>,
+    kzg_cell_proofs: KzgProofs<T::EthSpec>,
 ) -> Result<Vec<Option<GossipVerifiedDataColumn<T>>>, Rejection> {
     let slot = block.slot();
     let data_column_sidecars =
-        build_blob_data_column_sidecars(chain, block, blobs).map_err(|e| {
+        build_blob_data_column_sidecars(chain, block, blobs, kzg_cell_proofs).map_err(|e| {
             error!(
                 error = ?e,
                 %slot,
diff --git a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
index 733f2ca1db..d61ea58377 100644
--- a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
@@ -825,7 +825,8 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     | GossipDataColumnError::InvalidKzgProof { .. }
                     | GossipDataColumnError::UnexpectedDataColumn
                     | GossipDataColumnError::InvalidColumnIndex(_)
-                    | GossipDataColumnError::InconsistentCommitmentsOrProofLength
+                    | GossipDataColumnError::InconsistentCommitmentsLength { .. }
+                    | GossipDataColumnError::InconsistentProofsLength { .. }
                     | GossipDataColumnError::NotFinalizedDescendant { .. } => {
                         debug!(
                             error = ?err,
diff --git a/beacon_node/network/src/network_beacon_processor/mod.rs b/beacon_node/network/src/network_beacon_processor/mod.rs
index cdcbe1bb8d..9a8edbfa4c 100644
--- a/beacon_node/network/src/network_beacon_processor/mod.rs
+++ b/beacon_node/network/src/network_beacon_processor/mod.rs
@@ -844,7 +844,6 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         publish_blobs: bool,
     ) {
         let custody_columns = self.network_globals.sampling_columns.clone();
-        let is_supernode = self.network_globals.is_supernode();
         let self_cloned = self.clone();
         let publish_fn = move |blobs_or_data_column| {
             if publish_blobs {
@@ -852,10 +851,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     BlobsOrDataColumns::Blobs(blobs) => {
                         self_cloned.publish_blobs_gradually(blobs, block_root);
                     }
-                    BlobsOrDataColumns::DataColumns(mut columns) => {
-                        if !is_supernode {
-                            columns.retain(|col| custody_columns.contains(&col.index));
-                        }
+                    BlobsOrDataColumns::DataColumns(columns) => {
                         self_cloned.publish_data_columns_gradually(columns, block_root);
                     }
                 };
@@ -866,6 +862,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             self.chain.clone(),
             block_root,
             block.clone(),
+            custody_columns,
             publish_fn,
         )
         .instrument(tracing::info_span!(
diff --git a/consensus/types/src/data_column_sidecar.rs b/consensus/types/src/data_column_sidecar.rs
index 90a914dfae..03ab6a74f8 100644
--- a/consensus/types/src/data_column_sidecar.rs
+++ b/consensus/types/src/data_column_sidecar.rs
@@ -1,7 +1,7 @@
 use crate::beacon_block_body::{KzgCommitments, BLOB_KZG_COMMITMENTS_INDEX};
 use crate::test_utils::TestRandom;
 use crate::BeaconStateError;
-use crate::{BeaconBlockHeader, Epoch, EthSpec, Hash256, KzgProofs, SignedBeaconBlockHeader, Slot};
+use crate::{BeaconBlockHeader, Epoch, EthSpec, Hash256, SignedBeaconBlockHeader, Slot};
 use bls::Signature;
 use derivative::Derivative;
 use kzg::Error as KzgError;
@@ -56,7 +56,7 @@ pub struct DataColumnSidecar<E: EthSpec> {
     pub column: DataColumn<E>,
     /// All the KZG commitments and proofs associated with the block, used for verifying sample cells.
     pub kzg_commitments: KzgCommitments<E>,
-    pub kzg_proofs: KzgProofs<E>,
+    pub kzg_proofs: VariableList<KzgProof, E::MaxBlobCommitmentsPerBlock>,
     pub signed_block_header: SignedBeaconBlockHeader,
     /// An inclusion proof, proving the inclusion of `blob_kzg_commitments` in `BeaconBlockBody`.
     pub kzg_commitments_inclusion_proof: FixedVector<Hash256, E::KzgCommitmentsInclusionProofDepth>,
diff --git a/consensus/types/src/eth_spec.rs b/consensus/types/src/eth_spec.rs
index 0bc074072f..6f1b3e6ce6 100644
--- a/consensus/types/src/eth_spec.rs
+++ b/consensus/types/src/eth_spec.rs
@@ -4,8 +4,8 @@ use safe_arith::SafeArith;
 use serde::{Deserialize, Serialize};
 use ssz_types::typenum::{
     bit::B0, UInt, U0, U1, U10, U1024, U1048576, U1073741824, U1099511627776, U128, U131072,
-    U134217728, U16, U16777216, U17, U2, U2048, U256, U262144, U32, U4, U4096, U512, U625, U64,
-    U65536, U8, U8192,
+    U134217728, U16, U16777216, U17, U2, U2048, U256, U262144, U32, U33554432, U4, U4096, U512,
+    U625, U64, U65536, U8, U8192,
 };
 use std::fmt::{self, Debug};
 use std::str::FromStr;
@@ -146,6 +146,11 @@ pub trait EthSpec:
     /// Must be set to `BytesPerFieldElement * FieldElementsPerCell`.
     type BytesPerCell: Unsigned + Clone + Sync + Send + Debug + PartialEq;
 
+    /// The maximum number of cell commitments per block
+    ///
+    /// FieldElementsPerExtBlob * MaxBlobCommitmentsPerBlock
+    type MaxCellsPerBlock: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+
     /*
      * New in Electra
      */
@@ -421,6 +426,7 @@ impl EthSpec for MainnetEthSpec {
     type FieldElementsPerExtBlob = U8192;
     type BytesPerBlob = U131072;
     type BytesPerCell = U2048;
+    type MaxCellsPerBlock = U33554432;
     type KzgCommitmentInclusionProofDepth = U17;
     type KzgCommitmentsInclusionProofDepth = U4; // inclusion of the whole list of commitments
     type SyncSubcommitteeSize = U128; // 512 committee size / 4 sync committee subnet count
@@ -474,6 +480,7 @@ impl EthSpec for MinimalEthSpec {
     type MaxWithdrawalRequestsPerPayload = U2;
     type FieldElementsPerCell = U64;
     type FieldElementsPerExtBlob = U8192;
+    type MaxCellsPerBlock = U33554432;
     type BytesPerCell = U2048;
     type KzgCommitmentsInclusionProofDepth = U4;
 
@@ -566,6 +573,7 @@ impl EthSpec for GnosisEthSpec {
     type MaxPendingDepositsPerEpoch = U16;
     type FieldElementsPerCell = U64;
     type FieldElementsPerExtBlob = U8192;
+    type MaxCellsPerBlock = U33554432;
     type BytesPerCell = U2048;
     type KzgCommitmentsInclusionProofDepth = U4;
 
diff --git a/consensus/types/src/lib.rs b/consensus/types/src/lib.rs
index 73a50b4ef3..1d39c89cab 100644
--- a/consensus/types/src/lib.rs
+++ b/consensus/types/src/lib.rs
@@ -272,7 +272,14 @@ pub type Address = fixed_bytes::Address;
 pub type ForkVersion = [u8; 4];
 pub type BLSFieldElement = Uint256;
 pub type Blob<E> = FixedVector<u8, <E as EthSpec>::BytesPerBlob>;
-pub type KzgProofs<E> = VariableList<KzgProof, <E as EthSpec>::MaxBlobCommitmentsPerBlock>;
+// Note on List limit:
+// - Deneb to Electra: `MaxBlobCommitmentsPerBlock`
+// - Fulu: `MaxCellsPerBlock`
+// We choose to use a single type (with the larger value from Fulu as `N`) instead of having to
+// introduce a new type for Fulu. This is to avoid messy conversions and having to add extra types
+// with no gains - as `N` does not impact serialisation at all, and only affects merkleization,
+// which we don't current do on `KzgProofs` anyway.
+pub type KzgProofs<E> = VariableList<KzgProof, <E as EthSpec>::MaxCellsPerBlock>;
 pub type VersionedHash = Hash256;
 pub type Hash64 = alloy_primitives::B64;
 
diff --git a/crypto/kzg/src/lib.rs b/crypto/kzg/src/lib.rs
index 2a5c6e47f5..5d752cc0a5 100644
--- a/crypto/kzg/src/lib.rs
+++ b/crypto/kzg/src/lib.rs
@@ -220,7 +220,7 @@ impl Kzg {
         .map_err(Into::into)
     }
 
-    /// Computes the cells and associated proofs for a given `blob` at index `index`.
+    /// Computes the cells and associated proofs for a given `blob`.
     pub fn compute_cells_and_proofs(
         &self,
         blob: KzgBlobRef<'_>,
@@ -235,11 +235,14 @@ impl Kzg {
         Ok((cells, c_kzg_proof))
     }
 
+    /// Computes the cells for a given `blob`.
+    pub fn compute_cells(&self, blob: KzgBlobRef<'_>) -> Result<[Cell; CELLS_PER_EXT_BLOB], Error> {
+        self.context()
+            .compute_cells(blob)
+            .map_err(Error::PeerDASKZG)
+    }
+
     /// Verifies a batch of cell-proof-commitment triplets.
-    ///
-    /// Here, `coordinates` correspond to the (row, col) coordinate of the cell in the extended
-    /// blob "matrix". In the 1D extension, row corresponds to the blob index, and col corresponds
-    /// to the data column index.
     pub fn verify_cell_proof_batch(
         &self,
         cells: &[CellRef<'_>],
diff --git a/scripts/local_testnet/network_params_das.yaml b/scripts/local_testnet/network_params_das.yaml
index 80b4bc95c6..d47dfa6b5a 100644
--- a/scripts/local_testnet/network_params_das.yaml
+++ b/scripts/local_testnet/network_params_das.yaml
@@ -1,6 +1,7 @@
 participants:
   - cl_type: lighthouse
     cl_image: lighthouse:local
+    el_image: ethpandaops/geth:engine-getblobs-v2-3676b56
     cl_extra_params:
       - --subscribe-all-data-column-subnets
       - --subscribe-all-subnets
@@ -10,6 +11,7 @@ participants:
     count: 2
   - cl_type: lighthouse
     cl_image: lighthouse:local
+    el_image: ethpandaops/geth:engine-getblobs-v2-3676b56
     cl_extra_params:
       # Note: useful for testing range sync (only produce block if node is in sync to prevent forking)
       - --sync-tolerance-epochs=0
@@ -19,6 +21,10 @@ network_params:
   electra_fork_epoch: 1
   fulu_fork_epoch: 2
   seconds_per_slot: 6
+  max_blobs_per_block_electra: 64
+  target_blobs_per_block_electra: 48
+  max_blobs_per_block_fulu: 64
+  target_blobs_per_block_fulu: 48
 snooper_enabled: false
 global_log_level: debug
 additional_services:
@@ -26,4 +32,8 @@ additional_services:
   - spamoor_blob
   - prometheus_grafana
 dora_params:
-  image: ethpandaops/dora:fulu-support
\ No newline at end of file
+  image: ethpandaops/dora:fulu-support
+spamoor_blob_params:
+  # Throughput of spamoor
+  # Defaults to 3
+  throughput: 32
\ No newline at end of file