Merge branch 'deneb-free-blobs' of https://github.com/sigp/lighthouse into partial-processing

beacon_node/http_api/src/block_id.rs

@@ -4,7 +4,7 @@ use eth2::types::BlockId as CoreBlockId;
 use std::fmt;
 use std::str::FromStr;
 use std::sync::Arc;
-use types::{BlobSidecar, Hash256, SignedBeaconBlock, SignedBlindedBeaconBlock, Slot};
+use types::{BlobSidecarList, Hash256, SignedBeaconBlock, SignedBlindedBeaconBlock, Slot};
 
 /// Wraps `eth2::types::BlockId` and provides a simple way to obtain a block or root for a given
 /// `BlockId`.
@@ -212,19 +212,16 @@ impl BlockId {
         }
     }
 
-    /// Return the `BlobsSidecar` identified by `self`.
-    pub async fn blobs_sidecar<T: BeaconChainTypes>(
+    /// Return the `BlobSidecarList` identified by `self`.
+    pub async fn blob_sidecar_list<T: BeaconChainTypes>(
         &self,
         chain: &BeaconChain<T>,
-    ) -> Result<Arc<BlobSidecar<T::EthSpec>>, warp::Rejection> {
+    ) -> Result<BlobSidecarList<T::EthSpec>, warp::Rejection> {
         let root = self.root(chain)?.0;
-        let Some(_data_availability_boundary) = chain.data_availability_boundary() else {
-            return Err(warp_utils::reject::custom_not_found("Eip4844 fork disabled".into()));
-        };
         match chain.get_blobs(&root) {
-            Ok(Some(_blob)) => todo!(), // Jimmy's PR will fix this,
+            Ok(Some(blob_sidecar_list)) => Ok(blob_sidecar_list),
             Ok(None) => Err(warp_utils::reject::custom_not_found(format!(
-                "Blob with block root {} is not in the store",
+                "No blobs with block root {} found in the store",
                 root
             ))),
             Err(e) => Err(warp_utils::reject::beacon_chain_error(e)),

beacon_node/http_api/src/lib.rs

@@ -1293,6 +1293,45 @@ pub fn serve<T: BeaconChainTypes>(
             },
         );
 
+    /*
+     * beacon/blobs
+     */
+
+    // GET beacon/blobs/{block_id}
+    let get_blobs = eth_v1
+        .and(warp::path("beacon"))
+        .and(warp::path("blobs"))
+        .and(block_id_or_err)
+        .and(warp::path::end())
+        .and(chain_filter.clone())
+        .and(warp::header::optional::<api_types::Accept>("accept"))
+        .and_then(
+            |block_id: BlockId,
+             chain: Arc<BeaconChain<T>>,
+             accept_header: Option<api_types::Accept>| {
+                async move {
+                    let blob_sidecar_list = block_id.blob_sidecar_list(&chain).await?;
+
+                    match accept_header {
+                        Some(api_types::Accept::Ssz) => Response::builder()
+                            .status(200)
+                            .header("Content-Type", "application/octet-stream")
+                            .body(blob_sidecar_list.as_ssz_bytes().into())
+                            .map_err(|e| {
+                                warp_utils::reject::custom_server_error(format!(
+                                    "failed to create response: {}",
+                                    e
+                                ))
+                            }),
+                        _ => Ok(warp::reply::json(&api_types::GenericResponse::from(
+                            blob_sidecar_list,
+                        ))
+                        .into_response()),
+                    }
+                }
+            },
+        );
+
     /*
      * beacon/pool
      */
@@ -3498,41 +3537,6 @@ pub fn serve<T: BeaconChainTypes>(
             )
         });
 
-    // GET lighthouse/beacon/blobs_sidecars/{block_id}
-    let get_lighthouse_blobs_sidecars = warp::path("lighthouse")
-        .and(warp::path("beacon"))
-        .and(warp::path("blobs_sidecars"))
-        .and(block_id_or_err)
-        .and(warp::path::end())
-        .and(chain_filter.clone())
-        .and(warp::header::optional::<api_types::Accept>("accept"))
-        .and_then(
-            |block_id: BlockId,
-             chain: Arc<BeaconChain<T>>,
-             accept_header: Option<api_types::Accept>| {
-                async move {
-                    let blobs_sidecar = block_id.blobs_sidecar(&chain).await?;
-
-                    match accept_header {
-                        Some(api_types::Accept::Ssz) => Response::builder()
-                            .status(200)
-                            .header("Content-Type", "application/octet-stream")
-                            .body(blobs_sidecar.as_ssz_bytes().into())
-                            .map_err(|e| {
-                                warp_utils::reject::custom_server_error(format!(
-                                    "failed to create response: {}",
-                                    e
-                                ))
-                            }),
-                        _ => Ok(warp::reply::json(&api_types::GenericResponse::from(
-                            blobs_sidecar,
-                        ))
-                        .into_response()),
-                    }
-                }
-            },
-        );
-
     let get_events = eth_v1
         .and(warp::path("events"))
         .and(warp::path::end())
@@ -3627,6 +3631,7 @@ pub fn serve<T: BeaconChainTypes>(
                 .uor(get_beacon_block_attestations)
                 .uor(get_beacon_blinded_block)
                 .uor(get_beacon_block_root)
+                .uor(get_blobs)
                 .uor(get_beacon_pool_attestations)
                 .uor(get_beacon_pool_attester_slashings)
                 .uor(get_beacon_pool_proposer_slashings)
@@ -3672,7 +3677,6 @@ pub fn serve<T: BeaconChainTypes>(
                 .uor(get_lighthouse_attestation_performance)
                 .uor(get_lighthouse_block_packing_efficiency)
                 .uor(get_lighthouse_merge_readiness)
-                .uor(get_lighthouse_blobs_sidecars.boxed())
                 .uor(get_events)
                 .recover(warp_utils::reject::handle_rejection),
         )