address review comments

Author: JasonVranek

crates/common/src/wire.rs

@@ -42,8 +42,8 @@ pub enum AcceptedEncodingsError {
     #[error("invalid header string: {0}")]
     InvalidString(#[from] ToStrError),
 
-    #[error("invalid accept header: {error_msg}")]
-    InvalidEncoding { error_msg: String },
+    #[error("invalid accept header")]
+    InvalidAccept,
 
     #[error("unsupported accept type")]
     UnsupportedAcceptType,
@@ -220,11 +220,9 @@ pub fn get_accept_types(
     let mut saw_any = false;
     let mut had_supported = false;
     for header in req_headers.get_all(ACCEPT).iter() {
-        let accept_str = header.to_str().map_err(AcceptedEncodingsError::InvalidString)?;
+        let accept_str = header.to_str()?;
         let accept =
-            Accept::from_str(accept_str).map_err(|e| AcceptedEncodingsError::InvalidEncoding {
-                error_msg: (format!("invalid accept header: {e}")).to_string(),
-            })?;
+            Accept::from_str(accept_str).map_err(|_| AcceptedEncodingsError::InvalidAccept)?;
 
         for mt in accept.media_types() {
             saw_any = true;

crates/pbs/src/mev_boost/get_header.rs

@@ -50,8 +50,6 @@ use crate::{
 /// Sent from get_header to each send_timed_get_header call.
 #[derive(Clone)]
 struct RequestInfo {
-    /// The blockchain parameters of the get_header request (what slot it's for,
-    /// which pubkey is requesting it, etc)
     params: GetHeaderParams,
 
     /// Common baseline of headers to send with each request
@@ -834,9 +832,6 @@ mod tests {
                 .expect("failed to extract bid value from SSZ");
 
             // Compare to the original value
-            println!("Testing fork: {}", fork_name);
-            println!("Original value: {}", decoded.value());
-            println!("Extracted value: {}", bid_value);
             assert_eq!(*decoded.value(), bid_value);
         }
     }

crates/pbs/src/service.rs

@@ -69,8 +69,8 @@ impl PbsService {
             watcher = RecommendedWatcher::new(
                 move |result: Result<Event, Error>| {
                     match result {
-                        Err(e) => {
-                            warn!(%e, "error watching PBS config file for changes");
+                        Err(err) => {
+                            warn!(%err, "error watching PBS config file for changes");
                             return;
                         }
                         Ok(event) => {

tests/src/mock_relay.rs

@@ -351,9 +351,9 @@ async fn handle_submit_block_v1(
         vec![1u8; 1 + MAX_SIZE_SUBMIT_BLOCK_RESPONSE]
     } else {
         let mut execution_payload = ExecutionPayloadElectra::test_random();
-        let submit_block = deserialize_body(&headers, body_bytes).map_err(|e| {
-            error!(%e, "failed to deserialize signed blinded block");
-            (StatusCode::BAD_REQUEST, format!("failed to deserialize body: {e}"))
+        let submit_block = deserialize_body(&headers, body_bytes).map_err(|err| {
+            error!(%err, "failed to deserialize signed blinded block");
+            (StatusCode::BAD_REQUEST, format!("failed to deserialize body: {err}"))
         });
         if let Err(e) = submit_block {
             return e.into_response();

tests/src/utils.rs

@@ -28,13 +28,6 @@ pub fn get_local_address(port: u16) -> String {
 }
 
 /// Bind to port 0 and let the OS assign an unused ephemeral port.
-///
-/// The returned listener keeps the port reserved. Pass it to
-/// [`start_mock_relay_service_with_listener`] so the socket is never released
-/// between allocation and use (zero TOCTOU race). For servers that bind
-/// internally (e.g. `PbsService::run`), read the port with
-/// `listener.local_addr().unwrap().port()`, then `drop` the listener
-/// immediately before starting the server.
 pub async fn get_free_listener() -> tokio::net::TcpListener {
     tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap()
 }