address review nits

Author: JasonVranek

Cargo.lock

@@ -1,4 +1,5 @@
 use alloy::primitives::{B256, U256};
+use lh_types::ForkName;
 use thiserror::Error;
 
 use crate::{types::BlsPublicKeyBytes, utils::ResponseReadError};
@@ -116,6 +117,6 @@ pub enum SszValueError {
     #[error("invalid payload length: required {required} but payload was {actual}")]
     InvalidPayloadLength { required: usize, actual: usize },
 
-    #[error("unsupported fork")]
-    UnsupportedFork { name: String },
+    #[error("unsupported fork: {name}")]
+    UnsupportedFork { name: ForkName },
 }

crates/common/src/pbs/error.rs

@@ -50,8 +50,6 @@ pub type GetHeaderResponse = ForkVersionedResponse<SignedBuilderBid>;
 
 pub type KzgCommitments = lh_types::KzgCommitments<MainnetEthSpec>;
 
-pub type Uint256 = lh_types::Uint256;
-
 /// Response params of GET
 /// `/eth/v1/builder/header/{slot}/{parent_hash}/{pubkey}`
 #[derive(Debug, Serialize, Deserialize, Clone)]

crates/common/src/pbs/types/mod.rs

@@ -3,7 +3,6 @@ use std::cell::Cell;
 use std::{
     net::Ipv4Addr,
     str::FromStr,
-    sync::LazyLock,
     time::{SystemTime, UNIX_EPOCH},
 };
 
@@ -644,7 +643,7 @@ pub fn get_accept_types(req_headers: &HeaderMap) -> eyre::Result<AcceptedEncodin
     }
 
     if saw_any && !had_supported {
-        return Err(eyre::eyre!("unsupported accept type"));
+        eyre::bail!("unsupported accept type");
     }
 
     // No accept header (or only q=0 rejections): fall back to the request
@@ -717,16 +716,10 @@ impl EncodingType {
         }
     }
 
-    /// 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).
+    /// Pre-built `Content-Type` header for this encoding.
     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));
+        static JSON_HEADER: HeaderValue = HeaderValue::from_static(APPLICATION_JSON);
+        static SSZ_HEADER: HeaderValue = HeaderValue::from_static(APPLICATION_OCTET_STREAM);
         match self {
             EncodingType::Json => &JSON_HEADER,
             EncodingType::Ssz => &SSZ_HEADER,
@@ -917,7 +910,7 @@ fn get_ssz_value_offset_for_fork(fork: ForkName) -> Result<usize, SszValueError>
                 <ExecutionRequests as ssz::Decode>::ssz_fixed_len())
         }
 
-        _ => Err(SszValueError::UnsupportedFork { name: fork.to_string() }),
+        _ => Err(SszValueError::UnsupportedFork { name: fork }),
     }
 }
 

crates/common/src/utils.rs

@@ -31,3 +31,4 @@ tracing.workspace = true
 tree_hash.workspace = true
 url.workspace = true
 uuid.workspace = true
+thiserror.workspace = true

crates/pbs/Cargo.toml

@@ -1,13 +1,18 @@
 use axum::{http::StatusCode, response::IntoResponse};
 use cb_common::utils::BodyDeserializeError;
+use thiserror::Error;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 /// Errors that the PbsService returns to client
 pub enum PbsClientError {
+    #[error("no response from relays")]
     NoResponse,
+    #[error("no payload from relays")]
     NoPayload,
+    #[error("internal server error")]
     Internal,
-    DecodeError(String),
+    #[error("failed to deserialize body: {0}")]
+    DecodeError(#[from] BodyDeserializeError),
 }
 
 impl PbsClientError {
@@ -21,12 +26,6 @@ impl PbsClientError {
     }
 }
 
-impl From<BodyDeserializeError> for PbsClientError {
-    fn from(e: BodyDeserializeError) -> Self {
-        PbsClientError::DecodeError(format!("failed to deserialize body: {e}"))
-    }
-}
-
 impl IntoResponse for PbsClientError {
     fn into_response(self) -> axum::response::Response {
         let msg = match &self {