consolidate duplicate code in *_light and *_full into

decode_by_encoding()

Author: JasonVranek

crates/pbs/src/mev_boost/get_header.rs

@@ -547,17 +547,7 @@ async fn send_get_header_full(
     };
 
     // Decode the response
-    let get_header_response = match info.content_type {
-        EncodingType::Json => decode_json_payload(&info.response_bytes)?,
-        EncodingType::Ssz => {
-            let fork = info.fork.ok_or(PbsError::RelayResponse {
-                error_msg: "relay did not provide consensus version header for ssz payload"
-                    .to_string(),
-                code: info.code.as_u16(),
-            })?;
-            decode_ssz_payload(&info.response_bytes, fork)?
-        }
-    };
+    let get_header_response = decode_by_encoding(&info, decode_json_payload, decode_ssz_payload)?;
 
     // Log and return
     info!(
@@ -594,17 +584,9 @@ async fn send_get_header_light(
     };
 
     // Decode the value / fork from the response
-    let (fork, value) = match info.content_type {
-        EncodingType::Json => get_light_info_from_json(&info.response_bytes)?,
-        EncodingType::Ssz => {
-            let fork = info.fork.ok_or(PbsError::RelayResponse {
-                error_msg: "relay did not provide consensus version header for ssz payload"
-                    .to_string(),
-                code: info.code.as_u16(),
-            })?;
-            (fork, get_bid_value_from_signed_builder_bid_ssz(&info.response_bytes, fork)?)
-        }
-    };
+    let (fork, value) = decode_by_encoding(&info, get_light_info_from_json, |bytes, fork| {
+        Ok((fork, get_bid_value_from_signed_builder_bid_ssz(bytes, fork)?))
+    })?;
 
     // Log and return
     debug!(
@@ -627,6 +609,28 @@ async fn send_get_header_light(
     ))
 }
 
+/// Dispatch a get_header response to the appropriate decoder based on the
+/// negotiated content-type. SSZ requires a fork header; its absence is a
+/// protocol violation reported as `PbsError::RelayResponse`. Callers supply
+/// the format-specific decoders, keeping the encoding branch in one place.
+fn decode_by_encoding<T>(
+    info: &GetHeaderResponseInfo,
+    on_json: impl FnOnce(&[u8]) -> Result<T, PbsError>,
+    on_ssz: impl FnOnce(&[u8], ForkName) -> Result<T, PbsError>,
+) -> Result<T, PbsError> {
+    match info.content_type {
+        EncodingType::Json => on_json(&info.response_bytes),
+        EncodingType::Ssz => {
+            let fork = info.fork.ok_or_else(|| PbsError::RelayResponse {
+                error_msg: "relay did not provide consensus version header for ssz payload"
+                    .to_string(),
+                code: info.code.as_u16(),
+            })?;
+            on_ssz(&info.response_bytes, fork)
+        }
+    }
+}
+
 /// Sends a get_header request to a relay, returning the response, the time the
 /// request was started, and the encoding type of the response (if any).
 /// Used by send_one_get_header to perform the actual request submission.

crates/pbs/src/mev_boost/submit_block.rs

@@ -341,28 +341,10 @@ async fn send_submit_block_full(
         return Ok(None);
     }
 
-    // Decode the payload based on content type.
-    // The v1 guard above ensures `content_type` is Some
-    let content_type = block_response.content_type.ok_or_else(|| PbsError::RelayResponse {
-        error_msg: "v1 submit_block response missing Content-Type".to_string(),
-        code: block_response.code.as_u16(),
-    })?;
-    let decoded_response = match content_type {
-        EncodingType::Json => decode_json_payload(&block_response.response_bytes)?,
-        EncodingType::Ssz => {
-            let fork = match block_response.fork {
-                Some(fork) => fork,
-                None => {
-                    return Err(PbsError::RelayResponse {
-                        error_msg: "missing fork version header in SSZ submit_block response"
-                            .to_string(),
-                        code: block_response.code.as_u16(),
-                    });
-                }
-            };
-            decode_ssz_payload(&block_response.response_bytes, fork)?
-        }
-    };
+    // Decode the payload based on content type. The v1 guard above ensures
+    // `content_type` is Some.
+    let decoded_response =
+        decode_by_encoding(&block_response, decode_json_payload, decode_ssz_payload)?;
 
     // Log and return
     debug!(
@@ -407,24 +389,13 @@ async fn send_submit_block_light(
     }
 
     // Decode the payload based on content type. The v1 guard above ensures
-    // `content_type` is Some (v2 paths return None and early-exit).
-    let content_type = block_response.content_type.ok_or_else(|| PbsError::RelayResponse {
-        error_msg: "v1 submit_block response missing Content-Type".to_string(),
-        code: block_response.code.as_u16(),
-    })?;
-    let fork = match content_type {
-        EncodingType::Json => get_light_info_from_json(&block_response.response_bytes)?,
-        EncodingType::Ssz => match block_response.fork {
-            Some(fork) => fork,
-            None => {
-                return Err(PbsError::RelayResponse {
-                    error_msg: "missing fork version header in SSZ submit_block response"
-                        .to_string(),
-                    code: block_response.code.as_u16(),
-                });
-            }
-        },
-    };
+    // `content_type` is Some.
+    let fork =
+        decode_by_encoding(&block_response, get_light_info_from_json, |_bytes, fork| Ok(fork))?;
+    // `content_type` is guaranteed Some on v1 per decode_by_encoding.
+    let encoding_type = block_response.content_type.expect(
+        "v1 submit_block response carries Content-Type; decode_by_encoding already enforced this",
+    );
 
     // Log and return
     debug!(
@@ -437,11 +408,36 @@ async fn send_submit_block_light(
 
     Ok(Some(LightSubmitBlockResponse {
         version: fork,
-        encoding_type: content_type,
+        encoding_type,
         raw_bytes: block_response.response_bytes,
     }))
 }
 
+/// Dispatch a v1 submit_block response to the appropriate decoder based on the
+/// negotiated content-type. Caller guarantees `content_type` is Some (v2
+/// paths early-exit before reaching decode); an absent Content-Type on v1 is
+/// treated as a protocol violation. SSZ additionally requires a fork header.
+fn decode_by_encoding<T>(
+    info: &SubmitBlockResponseInfo,
+    on_json: impl FnOnce(&[u8]) -> Result<T, PbsError>,
+    on_ssz: impl FnOnce(&[u8], ForkName) -> Result<T, PbsError>,
+) -> Result<T, PbsError> {
+    let content_type = info.content_type.ok_or_else(|| PbsError::RelayResponse {
+        error_msg: "v1 submit_block response missing Content-Type".to_string(),
+        code: info.code.as_u16(),
+    })?;
+    match content_type {
+        EncodingType::Json => on_json(&info.response_bytes),
+        EncodingType::Ssz => {
+            let fork = info.fork.ok_or_else(|| PbsError::RelayResponse {
+                error_msg: "missing fork version header in SSZ submit_block response".to_string(),
+                code: info.code.as_u16(),
+            })?;
+            on_ssz(&info.response_bytes, fork)
+        }
+    }
+}
+
 /// Sends the actual HTTP request to the relay's submit_block endpoint,
 /// returning the response (if applicable), the round-trip time, and the
 /// encoding type used for the body (if any). Used by send_submit_block.