reuse shared content_type_header

Author: JasonVranek

crates/common/src/utils.rs

@@ -5,6 +5,7 @@ use std::{
     fmt::Display,
     net::Ipv4Addr,
     str::FromStr,
+    sync::LazyLock,
     time::{SystemTime, UNIX_EPOCH},
 };
 
@@ -747,6 +748,22 @@ impl EncodingType {
             EncodingType::Ssz => APPLICATION_OCTET_STREAM,
         }
     }
+
+    /// Pre-built `Content-Type` header for this encoding. `HeaderValue` is
+    /// not `const`-constructible in stable Rust, so the values are
+    /// lazy-initialized once per process via `LazyLock` from static ASCII
+    /// strings. Callers can clone the returned reference cheaply (the
+    /// underlying bytes are shared).
+    pub fn content_type_header(&self) -> &'static HeaderValue {
+        static JSON_HEADER: LazyLock<HeaderValue> =
+            LazyLock::new(|| HeaderValue::from_static(APPLICATION_JSON));
+        static SSZ_HEADER: LazyLock<HeaderValue> =
+            LazyLock::new(|| HeaderValue::from_static(APPLICATION_OCTET_STREAM));
+        match self {
+            EncodingType::Json => &JSON_HEADER,
+            EncodingType::Ssz => &SSZ_HEADER,
+        }
+    }
 }
 
 impl std::fmt::Display for EncodingType {

crates/pbs/src/routes/get_header.rs

@@ -63,16 +63,15 @@ pub async fn handle_get_header<S: BuilderApiState, A: BuilderApi<S>>(
                         let consensus_version_header =
                             HeaderValue::from_str(&light_bid.version.to_string())
                                 .expect("fork name is always a valid header value");
-                        let content_type = light_bid.encoding_type.content_type();
-                        let content_type_header = HeaderValue::from_str(content_type)
-                            .expect("content type is a static ASCII string");
+                        let content_type_header =
+                            light_bid.encoding_type.content_type_header().clone();
 
                         // Build response
                         let mut res = light_bid.raw_bytes.into_response();
                         res.headers_mut()
                             .insert(CONSENSUS_VERSION_HEADER, consensus_version_header);
                         res.headers_mut().insert(CONTENT_TYPE, content_type_header);
-                        info!("sending response as {} (light)", content_type);
+                        info!("sending response as {} (light)", light_bid.encoding_type);
                         Ok(res)
                     }
                     CompoundGetHeaderResponse::Full(max_bid) => {
@@ -94,8 +93,7 @@ pub async fn handle_get_header<S: BuilderApiState, A: BuilderApi<S>>(
                                     HeaderValue::from_str(&max_bid.version.to_string())
                                         .expect("fork name is always a valid header value");
                                 let content_type_header =
-                                    HeaderValue::from_str(EncodingType::Ssz.content_type())
-                                        .expect("content type is a static ASCII string");
+                                    EncodingType::Ssz.content_type_header().clone();
 
                                 let mut res = max_bid.data.as_ssz_bytes().into_response();
                                 res.headers_mut()

crates/pbs/src/routes/submit_block.rs

@@ -108,14 +108,14 @@ async fn handle_submit_block_impl<S: BuilderApiState, A: BuilderApi<S>>(
                             )));
                         }
                     }?;
-                let content_type = payload_and_blobs.encoding_type.content_type();
-                let content_type_header = HeaderValue::from_str(content_type).unwrap();
+                let content_type_header =
+                    payload_and_blobs.encoding_type.content_type_header().clone();
 
                 // Build response
                 let mut res = payload_and_blobs.raw_bytes.into_response();
                 res.headers_mut().insert(CONSENSUS_VERSION_HEADER, consensus_version_header);
                 res.headers_mut().insert(CONTENT_TYPE, content_type_header);
-                info!("sending response as {} (light)", content_type);
+                info!("sending response as {} (light)", payload_and_blobs.encoding_type);
                 Ok(res)
             }
             CompoundSubmitBlockResponse::Full(payload_and_blobs) => {
@@ -130,9 +130,7 @@ async fn handle_submit_block_impl<S: BuilderApiState, A: BuilderApi<S>>(
                 if accepts_ssz {
                     let mut response = payload_and_blobs.data.as_ssz_bytes().into_response();
 
-                    // This won't actually fail since the string is a const
-                    let content_type_header =
-                        HeaderValue::from_str(EncodingType::Ssz.content_type()).unwrap();
+                    let content_type_header = EncodingType::Ssz.content_type_header().clone();
                     response.headers_mut().insert(CONTENT_TYPE, content_type_header);
                     response.headers_mut().insert(
                         CONSENSUS_VERSION_HEADER,