fix(rpc): engine_rest #793 interop w/ consensoor

Author: iovoid

.github/workflows/pr-main_l1.yaml

@@ -119,11 +119,20 @@ jobs:
 
       - name: Run unit tests
         run: |
+          # macOS runners have a low default process/thread limit; the per-Blockchain
+          # merkle thread pool (crates/blockchain/blockchain.rs) multiplied across the
+          # parallel test suite exhausts it (pthread_create EAGAIN, code 35). Raise it.
+          if [ "$RUNNER_OS" = "macOS" ]; then
+            ulimit -u 16384 2>/dev/null || ulimit -u "$(ulimit -H -u)" 2>/dev/null || true
+          fi
           cargo test --workspace --exclude 'ethrex-l2*' --exclude ethrex-prover --exclude ethrex-guest-program
 
       - name: Run Blockchain EF tests
         if: ${{ github.event_name != 'merge_group' }}
         run: |
+          if [ "$RUNNER_OS" = "macOS" ]; then
+            ulimit -u 16384 2>/dev/null || ulimit -u "$(ulimit -H -u)" 2>/dev/null || true
+          fi
           make -C tooling/ef_tests/blockchain test
 
       - name: Append Known Issues to job summary

crates/l2/tee/quote-gen/Cargo.lock

@@ -9,7 +9,12 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-axum = { features = ["ws"], workspace = true }
+# "http2" is required so `axum::serve` serves HTTP/2 cleartext (h2c) on the
+# authrpc port: the engine REST/SSZ API (execution-apis #793) mandates HTTP/2,
+# and CLs like consensoor connect with h2c prior-knowledge and do NOT fall back
+# to HTTP/1.1. Without this feature h2c serving would only work incidentally via
+# reqwest's feature unification — declare it explicitly so it can't regress.
+axum = { features = ["ws", "http2"], workspace = true }
 tower-http.workspace = true
 serde.workspace = true
 serde_json = "1.0.117"

crates/networking/rpc/Cargo.toml

@@ -150,7 +150,7 @@ fn bodies_bench(c: &mut Criterion) {
     });
     g.bench_function("decode_ssz", |b| {
         b.iter(|| {
-            let r = ethrex_rpc::engine_rest::types::bodies::BodiesByHashResponseShanghai::from_ssz_bytes(
+            let r = ethrex_rpc::engine_rest::types::bodies::BodiesResponseShanghai::from_ssz_bytes(
                 &ssz_bytes,
             )
             .unwrap();

crates/networking/rpc/benches/engine_transport.rs

@@ -281,23 +281,21 @@ pub fn bodies_range_json(
         .collect()
 }
 
-/// SSZ-side bodies response wrapping `Vec<OptBodyShanghai>`.
+/// SSZ-side bodies response wrapping `List[BodyEntryShanghai]`.
 #[allow(dead_code)]
 pub fn bodies_range_ssz(
     seed: u64,
     n: usize,
     tx_per_body: usize,
-) -> ethrex_rpc::engine_rest::types::bodies::BodiesByHashResponseShanghai {
-    use ethrex_rpc::engine_rest::types::bodies::{
-        BodiesByHashResponseShanghai, BodyShanghai, OptBodyShanghai,
-    };
+) -> ethrex_rpc::engine_rest::types::bodies::BodiesResponseShanghai {
+    use ethrex_rpc::engine_rest::types::bodies::{BodyEntryShanghai, BodyShanghai};
     use ethrex_rpc::engine_rest::types::common::{
         MAX_BYTES_PER_TRANSACTION, MAX_TRANSACTIONS_PER_PAYLOAD, MAX_WITHDRAWALS_PER_PAYLOAD,
     };
     use libssz_types::SszList;
 
     let mut rng = StdRng::seed_from_u64(seed);
-    let bodies: Vec<OptBodyShanghai> = (0..n)
+    let entries_vec: Vec<BodyEntryShanghai> = (0..n)
         .map(|_| {
             let tx_lists: Vec<SszList<u8, MAX_BYTES_PER_TRANSACTION>> = (0..tx_per_body)
                 .map(|_| {
@@ -317,13 +315,15 @@ pub fn bodies_range_ssz(
                 ethrex_rpc::engine_rest::types::shanghai::Withdrawal,
                 MAX_WITHDRAWALS_PER_PAYLOAD,
             > = Vec::new().try_into().expect("empty withdrawals fits");
-            OptBodyShanghai(Some(BodyShanghai {
+            BodyEntryShanghai::available(BodyShanghai {
                 transactions,
                 withdrawals,
-            }))
+            })
         })
         .collect();
-    BodiesByHashResponseShanghai { bodies }
+    entries_vec
+        .try_into()
+        .expect("bodies fit MAX_BODIES_PER_REQUEST")
 }
 
 /// JSON-side blobs response: `Vec<Option<BlobAndProofV1>>`.
@@ -354,7 +354,6 @@ pub fn blobs_v1_response_ssz(
 ) -> ethrex_rpc::engine_rest::types::blobs::BlobsV1Response {
     use ethrex_rpc::engine_rest::types::blobs::{
         BYTES_PER_BLOB, BYTES_PER_PROOF, BlobAndProofV1 as SszBlobAndProofV1, BlobV1Entry,
-        BlobsV1Response,
     };
     use libssz_types::SszVector;
 
@@ -373,9 +372,7 @@ pub fn blobs_v1_response_ssz(
             })
         })
         .collect();
-    BlobsV1Response {
-        entries: entries.try_into().expect("n <= MAX_BLOBS_REQUEST"),
-    }
+    entries.try_into().expect("n <= MAX_BLOBS_REQUEST")
 }
 
 /// JSON-side getPayload response — same `ExecutionPayload` shape as newPayload.

crates/networking/rpc/benches/fixtures.rs

@@ -49,9 +49,14 @@ pub async fn engine_auth_middleware(
         }
     };
 
-    let token = match auth_str.strip_prefix(BEARER_PREFIX) {
-        Some(t) => t,
-        None => {
+    // RFC 7235 §2.1: the auth-scheme token is case-insensitive. `BEARER_PREFIX`
+    // is ASCII, so byte index 7 is also char index 7 — slicing is safe once the
+    // prefix matches.
+    let token = match auth_str.get(..BEARER_PREFIX.len()) {
+        Some(prefix) if prefix.eq_ignore_ascii_case(BEARER_PREFIX) => {
+            &auth_str[BEARER_PREFIX.len()..]
+        }
+        _ => {
             return ProblemJson::unauthorized("Authorization header must be Bearer")
                 .into_response();
         }

crates/networking/rpc/engine_rest/auth.rs

@@ -7,10 +7,9 @@ use axum::http::{Request, header};
 use http_body_util::LengthLimitError;
 use libssz::SszDecode;
 
+use crate::engine_rest::CONTENT_TYPE_OCTET_STREAM;
 use crate::engine_rest::error::ProblemJson;
 
-const CONTENT_TYPE_OCTET_STREAM: &str = "application/octet-stream";
-
 /// Axum extractor that reads an SSZ-encoded request body into `T`.
 ///
 /// Errors map to RFC 7807 responses:

crates/networking/rpc/engine_rest/extractors.rs

@@ -1,12 +1,11 @@
 //! /blobs/v{1..4} — blob retrieval from mempool, per execution-apis #793.
 //!
-//! Response shape is `List[BlobV*Entry]` where each entry carries an
-//! `available` flag plus `contents` (zeroed when unavailable). `/blobs/v2` is
+//! Requests are a bare `List[VersionedHash]` (v1/v2/v3) or a `BlobsRequestV4`
+//! container (v4). Responses are a bare `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
-//! the mempool does not store, so it returns `204 No Content` ("EL cannot
-//! serve this request at all").
+//! the mempool does not store, so it returns `204 No Content`.
 
 use axum::extract::State;
 use axum::http::StatusCode;
@@ -18,8 +17,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, BlobsRequest, BlobsRequestV4,
-    BlobsV1Response, BlobsV2Response, BlobsV3Response,
+    BlobAndProofV1, BlobAndProofV2, BlobV1Entry, BlobV2Entry, BlobsRequestV4, BlobsV1Response,
+    BlobsV2Response, BlobsV3Response, VersionedHashList,
 };
 use crate::rpc::RpcApiContext;
 
@@ -33,8 +32,11 @@ 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<BlobsRequest>) -> Response {
-    let hashes = match request_hashes(&req.versioned_hashes) {
+pub async fn blobs_v1(
+    State(ctx): State<RpcApiContext>,
+    Ssz(req): Ssz<VersionedHashList>,
+) -> Response {
+    let hashes = match request_hashes(&req) {
         Ok(h) => h,
         Err(p) => return p.into_response(),
     };
@@ -66,17 +68,19 @@ pub async fn blobs_v1(State(ctx): State<RpcApiContext>, Ssz(req): Ssz<BlobsReque
         entries.push(entry);
     }
 
-    match entries.try_into() {
-        Ok(entries) => SszBody(BlobsV1Response { entries }).into_response(),
+    match TryInto::<BlobsV1Response>::try_into(entries) {
+        Ok(resp) => SszBody(resp).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` (spec §`POST /blobs/v2`), mirroring
-/// `engine_getBlobsV2`'s `null` response.
-pub async fn blobs_v2(State(ctx): State<RpcApiContext>, Ssz(req): Ssz<BlobsRequest>) -> Response {
-    let hashes = match request_hashes(&req.versioned_hashes) {
+/// 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) {
         Ok(h) => h,
         Err(p) => return p.into_response(),
     };
@@ -113,17 +117,20 @@ pub async fn blobs_v2(State(ctx): State<RpcApiContext>, Ssz(req): Ssz<BlobsReque
         }
     }
 
-    match entries.try_into() {
-        Ok(entries) => SszBody(BlobsV2Response { entries }).into_response(),
+    match TryInto::<BlobsV2Response>::try_into(entries) {
+        Ok(resp) => SszBody(resp).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<BlobsRequest>) -> Response {
-    let hashes = match request_hashes(&req.versioned_hashes) {
+pub async fn blobs_v3(
+    State(ctx): State<RpcApiContext>,
+    Ssz(req): Ssz<VersionedHashList>,
+) -> Response {
+    let hashes = match request_hashes(&req) {
         Ok(h) => h,
         Err(p) => return p.into_response(),
     };
@@ -155,8 +162,8 @@ pub async fn blobs_v3(State(ctx): State<RpcApiContext>, Ssz(req): Ssz<BlobsReque
         entries.push(entry);
     }
 
-    match entries.try_into() {
-        Ok(entries) => SszBody(BlobsV3Response { entries }).into_response(),
+    match TryInto::<BlobsV3Response>::try_into(entries) {
+        Ok(resp) => SszBody(resp).into_response(),
         Err(_) => ProblemJson::internal("blobs response exceeds MAX_BLOBS_REQUEST").into_response(),
     }
 }