fix(rpc): engine_rest blobs/bodies containers

Author: iovoid

crates/networking/rpc/benches/fixtures.rs

@@ -945,9 +945,11 @@ pub fn bodies_range_ssz_paris(
             })
         })
         .collect();
-    entries_vec
-        .try_into()
-        .expect("bodies fit MAX_BODIES_PER_REQUEST")
+    ethrex_rpc::engine_rest::types::bodies::BodiesResponseParis {
+        entries: entries_vec
+            .try_into()
+            .expect("bodies fit MAX_BODIES_PER_REQUEST"),
+    }
 }
 
 /// SSZ-side bodies response for the shanghai → osaka paths (Shanghai shape).
@@ -968,9 +970,11 @@ pub fn bodies_range_ssz_shanghai(
             })
         })
         .collect();
-    entries_vec
-        .try_into()
-        .expect("bodies fit MAX_BODIES_PER_REQUEST")
+    ethrex_rpc::engine_rest::types::bodies::BodiesResponseShanghai {
+        entries: entries_vec
+            .try_into()
+            .expect("bodies fit MAX_BODIES_PER_REQUEST"),
+    }
 }
 
 /// JSON-side Amsterdam bodies response (`…BodiesByRangeV2`): adds a per-body
@@ -1020,9 +1024,11 @@ pub fn bodies_range_ssz_amsterdam(
             })
         })
         .collect();
-    entries_vec
-        .try_into()
-        .expect("bodies fit MAX_BODIES_PER_REQUEST")
+    ethrex_rpc::engine_rest::types::bodies::BodiesResponseAmsterdam {
+        entries: entries_vec
+            .try_into()
+            .expect("bodies fit MAX_BODIES_PER_REQUEST"),
+    }
 }
 
 #[allow(dead_code)]
@@ -1116,7 +1122,9 @@ pub fn blobs_v1_response_ssz(
             })
         })
         .collect();
-    entries.try_into().expect("n <= MAX_BLOBS_REQUEST")
+    ethrex_rpc::engine_rest::types::blobs::BlobsV1Response {
+        entries: entries.try_into().expect("n <= MAX_BLOBS_REQUEST"),
+    }
 }
 
 /// SSZ-side `/blobs/v1` all-miss response: zero-padded full-size entries.
@@ -1127,7 +1135,9 @@ pub fn blobs_v1_response_ssz_allmiss(
     use ethrex_rpc::engine_rest::types::blobs::BlobV1Entry;
 
     let entries: Vec<BlobV1Entry> = (0..n).map(|_| BlobV1Entry::unavailable()).collect();
-    entries.try_into().expect("n <= MAX_BLOBS_REQUEST")
+    ethrex_rpc::engine_rest::types::blobs::BlobsV1Response {
+        entries: entries.try_into().expect("n <= MAX_BLOBS_REQUEST"),
+    }
 }
 
 /// JSON-side v1 all-miss response: `n` nulls.
@@ -1200,7 +1210,9 @@ pub fn blobs_v2_response_ssz(
             })
         })
         .collect();
-    entries.try_into().expect("n <= MAX_BLOBS_REQUEST")
+    ethrex_rpc::engine_rest::types::blobs::BlobsV2Response {
+        entries: entries.try_into().expect("n <= MAX_BLOBS_REQUEST"),
+    }
 }
 
 /// SSZ-side `/blobs/v3` all-miss response: every entry `available == false`
@@ -1214,7 +1226,9 @@ pub fn blobs_v3_response_ssz_allmiss(
     use ethrex_rpc::engine_rest::types::blobs::BlobV2Entry;
 
     let entries: Vec<BlobV2Entry> = (0..n).map(|_| BlobV2Entry::unavailable()).collect();
-    entries.try_into().expect("n <= MAX_BLOBS_REQUEST")
+    ethrex_rpc::engine_rest::types::blobs::BlobsV3Response {
+        entries: entries.try_into().expect("n <= MAX_BLOBS_REQUEST"),
+    }
 }
 
 /// JSON-side v3 all-miss response: `n` nulls.
@@ -1267,5 +1281,7 @@ pub fn blobs_v4_response_ssz(
             }
         })
         .collect();
-    entries.try_into().expect("n <= MAX_BLOBS_REQUEST")
+    ethrex_rpc::engine_rest::types::blobs::BlobsV4Response {
+        entries: entries.try_into().expect("n <= MAX_BLOBS_REQUEST"),
+    }
 }

crates/networking/rpc/engine_rest/handlers/blobs.rs

@@ -1,7 +1,10 @@
 //! /blobs/v{1..4} — blob retrieval from mempool, per execution-apis #793.
 //!
-//! Requests are a bare `List[VersionedHash]` (v1/v2/v3) or a `BlobsRequestV4`
-//! container (v4). Responses are a bare `List[BlobV*Entry]`. `/blobs/v2` is
+//! Requests are single-field SSZ containers wrapping a `List[VersionedHash]`
+//! (`BlobsV1Request`/`BlobsV2Request`) or the `BlobsRequestV4` container (v4) —
+//! per execution-apis #793, NOT bare top-level lists. Responses are likewise
+//! single-field containers (`BlobsV*Response { entries: List[BlobV*Entry] }`).
+//! `/blobs/v2` is
 //! all-or-nothing: if any requested blob is missing the handler returns
 //! `204 No Content` instead of emitting unavailable entries. `/blobs/v3`
 //! surfaces missing blobs per entry. `/blobs/v4` requires per-cell data that
@@ -17,8 +20,8 @@ use crate::engine_rest::extractors::Ssz;
 use crate::engine_rest::handlers::capabilities::BLOBS_MAX_COUNT;
 use crate::engine_rest::responses::SszBody;
 use crate::engine_rest::types::blobs::{
-    BlobAndProofV1, BlobAndProofV2, BlobV1Entry, BlobV2Entry, BlobsRequestV4, BlobsV1Response,
-    BlobsV2Response, BlobsV3Response, VersionedHashList,
+    BlobAndProofV1, BlobAndProofV2, BlobV1Entry, BlobV2Entry, BlobsRequestV4, BlobsV1Request,
+    BlobsV1Response, BlobsV2Request, BlobsV2Response, BlobsV3Response,
 };
 use crate::rpc::RpcApiContext;
 
@@ -32,10 +35,7 @@ fn request_hashes(versioned_hashes: &[[u8; 32]]) -> Result<Vec<H256>, ProblemJso
     Ok(versioned_hashes.iter().map(|h| H256::from(*h)).collect())
 }
 
-pub async fn blobs_v1(
-    State(ctx): State<RpcApiContext>,
-    Ssz(req): Ssz<VersionedHashList>,
-) -> Response {
+pub async fn blobs_v1(State(ctx): State<RpcApiContext>, Ssz(req): Ssz<BlobsV1Request>) -> Response {
     // Osaka gate (mirror JSON-RPC getBlobsV1, engine/blobs.rs): /blobs/v1 serves
     // whole-blob proofs and is only valid pre-Osaka. After Osaka a blob carries
     // cell proofs, so the `proofs[0]` below would be a cell proof rather than a
@@ -60,7 +60,7 @@ pub async fn blobs_v1(
         Err(e) => return ProblemJson::internal(&format!("storage: {e}")).into_response(),
     }
 
-    let hashes = match request_hashes(&req) {
+    let hashes = match request_hashes(&req.versioned_hashes) {
         Ok(h) => h,
         Err(p) => return p.into_response(),
     };
@@ -92,19 +92,16 @@ pub async fn blobs_v1(
         entries.push(entry);
     }
 
-    match TryInto::<BlobsV1Response>::try_into(entries) {
-        Ok(resp) => SszBody(resp).into_response(),
+    match entries.try_into() {
+        Ok(entries) => SszBody(BlobsV1Response { entries }).into_response(),
         Err(_) => ProblemJson::internal("blobs response exceeds MAX_BLOBS_REQUEST").into_response(),
     }
 }
 
 /// `/blobs/v2` — all-or-nothing (Osaka). If any requested blob is missing the
 /// EL MUST return `204 No Content`, mirroring `engine_getBlobsV2`'s `null`.
-pub async fn blobs_v2(
-    State(ctx): State<RpcApiContext>,
-    Ssz(req): Ssz<VersionedHashList>,
-) -> Response {
-    let hashes = match request_hashes(&req) {
+pub async fn blobs_v2(State(ctx): State<RpcApiContext>, Ssz(req): Ssz<BlobsV2Request>) -> Response {
+    let hashes = match request_hashes(&req.versioned_hashes) {
         Ok(h) => h,
         Err(p) => return p.into_response(),
     };
@@ -141,20 +138,17 @@ pub async fn blobs_v2(
         }
     }
 
-    match TryInto::<BlobsV2Response>::try_into(entries) {
-        Ok(resp) => SszBody(resp).into_response(),
+    match entries.try_into() {
+        Ok(entries) => SszBody(BlobsV2Response { entries }).into_response(),
         Err(_) => ProblemJson::internal("blobs response exceeds MAX_BLOBS_REQUEST").into_response(),
     }
 }
 
 /// `/blobs/v3` — partial responses (Osaka). Missing blobs surface as
 /// `available == false` entries; `204 No Content` is reserved for "EL cannot
 /// serve the request at all".
-pub async fn blobs_v3(
-    State(ctx): State<RpcApiContext>,
-    Ssz(req): Ssz<VersionedHashList>,
-) -> Response {
-    let hashes = match request_hashes(&req) {
+pub async fn blobs_v3(State(ctx): State<RpcApiContext>, Ssz(req): Ssz<BlobsV2Request>) -> Response {
+    let hashes = match request_hashes(&req.versioned_hashes) {
         Ok(h) => h,
         Err(p) => return p.into_response(),
     };
@@ -186,8 +180,8 @@ pub async fn blobs_v3(
         entries.push(entry);
     }
 
-    match TryInto::<BlobsV3Response>::try_into(entries) {
-        Ok(resp) => SszBody(resp).into_response(),
+    match entries.try_into() {
+        Ok(entries) => SszBody(BlobsV3Response { entries }).into_response(),
         Err(_) => ProblemJson::internal("blobs response exceeds MAX_BLOBS_REQUEST").into_response(),
     }
 }

crates/networking/rpc/engine_rest/handlers/bodies.rs

@@ -16,7 +16,7 @@ use crate::engine_rest::fork_path::ForkPath;
 use crate::engine_rest::handlers::capabilities::BODIES_MAX_COUNT;
 use crate::engine_rest::responses::SszBody;
 use crate::engine_rest::types::bodies::{
-    BlockHashList, BodiesResponseAmsterdam, BodiesResponseParis, BodiesResponseShanghai,
+    BodiesByHashRequest, BodiesResponseAmsterdam, BodiesResponseParis, BodiesResponseShanghai,
     BodyAmsterdam, BodyEntryAmsterdam, BodyEntryParis, BodyEntryShanghai, BodyParis, BodyShanghai,
 };
 use crate::engine_rest::types::common::Bytes20;
@@ -28,8 +28,9 @@ use crate::rpc::RpcApiContext;
 pub async fn bodies_by_hash(
     ForkPath(fork): ForkPath,
     State(ctx): State<RpcApiContext>,
-    Ssz(hashes): Ssz<BlockHashList>,
+    Ssz(req): Ssz<BodiesByHashRequest>,
 ) -> Response {
+    let hashes = &req.block_hashes;
     if hashes.len() > BODIES_MAX_COUNT as usize {
         return ProblemJson::payload_too_large(&format!(
             "request exceeds BODIES_MAX_COUNT ({BODIES_MAX_COUNT})"
@@ -146,8 +147,8 @@ async fn build_bodies_response(
                 };
                 entries.push(entry);
             }
-            match TryInto::<BodiesResponseParis>::try_into(entries) {
-                Ok(resp) => SszBody(resp).into_response(),
+            match entries.try_into() {
+                Ok(entries) => SszBody(BodiesResponseParis { entries }).into_response(),
                 Err(_) => bodies_overflow().into_response(),
             }
         }
@@ -165,8 +166,8 @@ async fn build_bodies_response(
                 };
                 entries.push(entry);
             }
-            match TryInto::<BodiesResponseShanghai>::try_into(entries) {
-                Ok(resp) => SszBody(resp).into_response(),
+            match entries.try_into() {
+                Ok(entries) => SszBody(BodiesResponseShanghai { entries }).into_response(),
                 Err(_) => bodies_overflow().into_response(),
             }
         }
@@ -204,8 +205,8 @@ async fn build_bodies_response(
                 };
                 entries.push(entry);
             }
-            match TryInto::<BodiesResponseAmsterdam>::try_into(entries) {
-                Ok(resp) => SszBody(resp).into_response(),
+            match entries.try_into() {
+                Ok(entries) => SszBody(BodiesResponseAmsterdam { entries }).into_response(),
                 Err(_) => bodies_overflow().into_response(),
             }
         }

crates/networking/rpc/engine_rest/types/blobs.rs

@@ -29,9 +29,23 @@ pub const MAX_BLOBS_REQUEST: usize = 128;
 
 // ── Requests ──────────────────────────────────────────────────────────────────
 
-/// `/blobs/v1`, `/blobs/v2`, `/blobs/v3` request: a bare `List[VersionedHash, N]`.
+/// Inner versioned-hash list wrapped by the v1/v2/v3 request containers.
 pub type VersionedHashList = SszList<[u8; 32], MAX_BLOBS_REQUEST>;
 
+/// `/blobs/v1` request. Per execution-apis #793 the request is a single-field
+/// SSZ **container** wrapping the list (a 4-byte offset precedes the hashes on
+/// the wire), NOT a bare top-level list.
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BlobsV1Request {
+    pub versioned_hashes: VersionedHashList,
+}
+
+/// `/blobs/v2` and `/blobs/v3` request — same single-field container as v1.
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BlobsV2Request {
+    pub versioned_hashes: VersionedHashList,
+}
+
 /// `/blobs/v4` request: versioned hashes + a `CELLS_PER_EXT_BLOB`-bit bitarray
 /// selecting which cell indices to return.
 #[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
@@ -127,14 +141,23 @@ impl BlobV2Entry {
     }
 }
 
-// ── Response aliases (bare top-level lists, per the CL) ────────────────────────
+// ── Response containers (single-field, per execution-apis #793) ───────────────
 
-/// `/blobs/v1` response.
-pub type BlobsV1Response = SszList<BlobV1Entry, MAX_BLOBS_REQUEST>;
+/// `/blobs/v1` response: `{ entries: List[BlobV1Entry, N] }`.
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BlobsV1Response {
+    pub entries: SszList<BlobV1Entry, MAX_BLOBS_REQUEST>,
+}
 /// `/blobs/v2` response (all-or-nothing; every entry is `available`).
-pub type BlobsV2Response = SszList<BlobV2Entry, MAX_BLOBS_REQUEST>;
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BlobsV2Response {
+    pub entries: SszList<BlobV2Entry, MAX_BLOBS_REQUEST>,
+}
 /// `/blobs/v3` response (partial; missing blobs surface as `available == false`).
-pub type BlobsV3Response = SszList<BlobV2Entry, MAX_BLOBS_REQUEST>;
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BlobsV3Response {
+    pub entries: SszList<BlobV2Entry, MAX_BLOBS_REQUEST>,
+}
 
 // ── `/blobs/v4` types ─────────────────────────────────────────────────────────
 //
@@ -163,5 +186,8 @@ pub struct BlobV4Entry {
     pub contents: BlobCellsAndProofs,
 }
 
-/// `/blobs/v4` response.
-pub type BlobsV4Response = SszList<BlobV4Entry, MAX_BLOBS_REQUEST>;
+/// `/blobs/v4` response: `{ entries: List[BlobV4Entry, N] }`.
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode)]
+pub struct BlobsV4Response {
+    pub entries: SszList<BlobV4Entry, MAX_BLOBS_REQUEST>,
+}

crates/networking/rpc/engine_rest/types/bodies.rs

@@ -19,9 +19,16 @@ use super::shanghai::Withdrawal;
 /// bodies response (`MAX_BODIES_REQUEST = 2**5`); matches the consensoor CL.
 pub const MAX_BODIES_PER_REQUEST: usize = 32;
 
-/// `POST /{fork}/bodies/hash` request body: a bare `List[Hash32, MAX_BODIES_REQUEST]`.
+/// Inner block-hash list wrapped by `BodiesByHashRequest`.
 pub type BlockHashList = SszList<[u8; 32], MAX_BODIES_PER_REQUEST>;
 
+/// `POST /{fork}/bodies/hash` request. Per execution-apis #793 the request is a
+/// single-field SSZ **container** wrapping the list, NOT a bare top-level list.
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BodiesByHashRequest {
+    pub block_hashes: BlockHashList,
+}
+
 // ── Per-fork ExecutionPayloadBody ─────────────────────────────────────────────
 
 /// Paris body: transactions only.
@@ -143,13 +150,22 @@ impl BodyEntryAmsterdam {
     }
 }
 
-// ── Response aliases (bare top-level lists, per the CL) ───────────────────────
+// ── Response containers (single-field, per execution-apis #793) ───────────────
 //
 // Shared by both `POST /{fork}/bodies/hash` and `GET /{fork}/bodies` (range).
 
-/// Paris bodies response.
-pub type BodiesResponseParis = SszList<BodyEntryParis, MAX_BODIES_PER_REQUEST>;
+/// Paris bodies response: `{ entries: List[BodyEntryParis, N] }`.
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BodiesResponseParis {
+    pub entries: SszList<BodyEntryParis, MAX_BODIES_PER_REQUEST>,
+}
 /// Shanghai/Cancun/Prague/Osaka bodies response.
-pub type BodiesResponseShanghai = SszList<BodyEntryShanghai, MAX_BODIES_PER_REQUEST>;
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BodiesResponseShanghai {
+    pub entries: SszList<BodyEntryShanghai, MAX_BODIES_PER_REQUEST>,
+}
 /// Amsterdam bodies response.
-pub type BodiesResponseAmsterdam = SszList<BodyEntryAmsterdam, MAX_BODIES_PER_REQUEST>;
+#[derive(Debug, Clone, PartialEq, Eq, SszEncode, SszDecode, HashTreeRoot)]
+pub struct BodiesResponseAmsterdam {
+    pub entries: SszList<BodyEntryAmsterdam, MAX_BODIES_PER_REQUEST>,
+}