remove request_context entirely, relay info encoded in url already

JasonVranek · JasonVranek · commit eaa84c195002 · 2026-05-27T12:08:04.000-07:00
diff --git a/crates/common/src/config/mux.rs b/crates/common/src/config/mux.rs
@@ -239,8 +239,7 @@ impl MuxKeysLoader {
                 let url = url.as_str();
                 let client = reqwest::ClientBuilder::new().timeout(http_timeout).build()?;
                 let response = client.get(url).send().await?;
-                let pubkey_bytes =
-                    safe_read_http_response(response, MUXER_HTTP_MAX_LENGTH, url).await?;
+                let pubkey_bytes = safe_read_http_response(response, MUXER_HTTP_MAX_LENGTH).await?;
                 serde_json::from_slice(&pubkey_bytes)
                     .wrap_err("failed to fetch mux keys from HTTP endpoint")
             }
@@ -472,8 +471,7 @@ async fn fetch_ssv_pubkeys_from_public_api(
         );
         let url = url.join(&route).wrap_err("failed to construct SSV API URL")?;
 
-        let response =
-            request_ssv_pubkeys_from_public_api(url, node_operator_id, http_timeout).await?;
+        let response = request_ssv_pubkeys_from_public_api(url, http_timeout).await?;
         let fetched = response.validators.len();
         if expected_total.is_none() && fetched > 0 {
             expected_total = Some(response.pagination.total);
diff --git a/crates/common/src/interop/ssv/utils.rs b/crates/common/src/interop/ssv/utils.rs
@@ -29,15 +29,12 @@ pub async fn request_ssv_pubkeys_from_ssv_node(
     })?;
 
     // Parse the response as JSON
-    let body_bytes =
-        safe_read_http_response(response, MUXER_HTTP_MAX_LENGTH, &node_operator_id.to_string())
-            .await?;
+    let body_bytes = safe_read_http_response(response, MUXER_HTTP_MAX_LENGTH).await?;
     serde_json::from_slice::<SSVNodeResponse>(&body_bytes).wrap_err("failed to parse SSV response")
 }
 
 pub async fn request_ssv_pubkeys_from_public_api(
     url: Url,
-    node_operator_id: U256,
     http_timeout: Duration,
 ) -> eyre::Result<SSVPublicResponse> {
     let client = reqwest::ClientBuilder::new().timeout(http_timeout).build()?;
@@ -50,9 +47,7 @@ pub async fn request_ssv_pubkeys_from_public_api(
     })?;
 
     // Parse the response as JSON
-    let body_bytes =
-        safe_read_http_response(response, MUXER_HTTP_MAX_LENGTH, &node_operator_id.to_string())
-            .await?;
+    let body_bytes = safe_read_http_response(response, MUXER_HTTP_MAX_LENGTH).await?;
     serde_json::from_slice::<SSVPublicResponse>(&body_bytes)
         .wrap_err("failed to parse SSV response")
 }
diff --git a/crates/common/src/wire.rs b/crates/common/src/wire.rs
@@ -24,22 +24,17 @@ pub const CONSENSUS_VERSION_HEADER: &str = "Eth-Consensus-Version";
 #[derive(Debug, Error)]
 pub enum ResponseReadError {
     #[error(
-        "response size exceeds max size; max: {max}, content_length: {content_length}, request_url: {request_url}, request_context: {request_context}"
+        "response size exceeds max size; max: {max}, content_length: {content_length}, request_url: {request_url}"
     )]
-    PayloadTooLarge {
-        max: usize,
-        content_length: usize,
-        request_url: String,
-        request_context: String,
-    },
+    PayloadTooLarge { max: usize, content_length: usize, request_url: String },
 
     #[error("error reading response stream: {0}")]
     ReqwestError(#[from] reqwest::Error),
 
     #[error(
-        "request failed with status: {status_code}, request_url: {request_url}, request_context: {request_context}, body: {error_msg}"
+        "request failed with status: {status_code}, request_url: {request_url}, body: {error_msg}"
     )]
-    NonSuccess { status_code: u16, error_msg: String, request_url: String, request_context: String },
+    NonSuccess { status_code: u16, error_msg: String, request_url: String },
 }
 
 #[cfg(feature = "testing-flags")]
@@ -63,7 +58,6 @@ fn should_ignore_content_length() -> bool {
 pub async fn read_chunked_body_with_max(
     res: Response,
     max_size: usize,
-    request_id: &str,
     request_url: &str,
 ) -> Result<Vec<u8>, ResponseReadError> {
     // Get the content length from the response headers
@@ -87,7 +81,6 @@ pub async fn read_chunked_body_with_max(
             max: max_size,
             content_length: length as usize,
             request_url: request_url.to_string(),
-            request_context: request_id.to_string(),
         });
     }
 
@@ -103,7 +96,6 @@ pub async fn read_chunked_body_with_max(
                 max: max_size,
                 content_length: content_length.unwrap_or(0) as usize,
                 request_url: request_url.to_string(),
-                request_context: request_id.to_string(),
             });
         }
 
@@ -118,19 +110,17 @@ pub async fn read_chunked_body_with_max(
 pub async fn safe_read_http_response(
     response: reqwest::Response,
     max_size: usize,
-    request_id: &str,
 ) -> Result<Vec<u8>, ResponseReadError> {
     let status_code = response.status();
     let request_url = response.url().to_string();
-    let body = read_chunked_body_with_max(response, max_size, request_id, &request_url).await?;
+    let body = read_chunked_body_with_max(response, max_size, &request_url).await?;
     if status_code.is_success() {
         Ok(body)
     } else {
         Err(ResponseReadError::NonSuccess {
             status_code: status_code.as_u16(),
             error_msg: String::from_utf8_lossy(&body).into_owned(),
             request_url: request_url.to_string(),
-            request_context: request_id.to_string(),
         })
     }
 }
diff --git a/crates/pbs/src/mev_boost/get_header.rs b/crates/pbs/src/mev_boost/get_header.rs
@@ -351,8 +351,7 @@ async fn send_one_get_header(
     let code = res.status();
     RELAY_STATUS_CODE.with_label_values(&[code.as_str(), GET_HEADER_ENDPOINT_TAG, &relay.id]).inc();
 
-    let response_bytes =
-        safe_read_http_response(res, MAX_SIZE_GET_HEADER_RESPONSE, relay.id.as_ref()).await?;
+    let response_bytes = safe_read_http_response(res, MAX_SIZE_GET_HEADER_RESPONSE).await?;
     let header_size_bytes = response_bytes.len();
     if code == StatusCode::NO_CONTENT {
         debug!(
diff --git a/crates/pbs/src/mev_boost/register_validator.rs b/crates/pbs/src/mev_boost/register_validator.rs
@@ -187,7 +187,7 @@ async fn send_register_validator(
         .with_label_values(&[code.as_str(), REGISTER_VALIDATOR_ENDPOINT_TAG, &relay.id])
         .inc();
 
-    safe_read_http_response(res, MAX_SIZE_DEFAULT, relay.id.as_ref()).await.inspect_err(|e| {
+    safe_read_http_response(res, MAX_SIZE_DEFAULT).await.inspect_err(|e| {
         error!(relay_id = relay.id.as_ref(), retry, %e, "failed registration");
     })?;
 
diff --git a/crates/pbs/src/mev_boost/status.rs b/crates/pbs/src/mev_boost/status.rs
@@ -73,7 +73,7 @@ async fn send_relay_check(relay: &RelayClient, headers: HeaderMap) -> Result<(),
     let code = res.status();
     RELAY_STATUS_CODE.with_label_values(&[code.as_str(), STATUS_ENDPOINT_TAG, &relay.id]).inc();
 
-    safe_read_http_response(res, MAX_SIZE_DEFAULT, relay.id.as_ref()).await.inspect_err(|e| {
+    safe_read_http_response(res, MAX_SIZE_DEFAULT).await.inspect_err(|e| {
         error!(relay_id = relay.id.as_ref(), %e, "status failed");
     })?;
 
diff --git a/crates/pbs/src/mev_boost/submit_block.rs b/crates/pbs/src/mev_boost/submit_block.rs
@@ -201,7 +201,7 @@ async fn send_submit_block(
         .with_label_values(&[code.as_str(), SUBMIT_BLINDED_BLOCK_ENDPOINT_TAG, &relay.id])
         .inc();
 
-    let response_bytes = safe_read_http_response(res, MAX_SIZE_SUBMIT_BLOCK_RESPONSE, relay.id.as_ref())
+    let response_bytes = safe_read_http_response(res, MAX_SIZE_SUBMIT_BLOCK_RESPONSE)
         .await
         .inspect_err(|e| {
             warn!(relay_id = relay.id.as_ref(), retry, %e, "failed to get payload (this might be ok if other relays have it)");
diff --git a/tests/tests/pbs_mux.rs b/tests/tests/pbs_mux.rs
@@ -41,13 +41,9 @@ async fn test_ssv_public_network_fetch() -> Result<()> {
     let url =
         Url::parse(&format!("http://localhost:{port}/api/v4/test_chain/validators/in_operator/1"))
             .unwrap();
-    let node_operator_id = U256::from(0);
-    let response = request_ssv_pubkeys_from_public_api(
-        url,
-        node_operator_id,
-        Duration::from_secs(HTTP_TIMEOUT_SECONDS_DEFAULT),
-    )
-    .await?;
+    let response =
+        request_ssv_pubkeys_from_public_api(url, Duration::from_secs(HTTP_TIMEOUT_SECONDS_DEFAULT))
+            .await?;
 
     // Make sure the response is correct
     // NOTE: requires that ssv_valid_public.json doesn't change
@@ -82,30 +78,18 @@ async fn test_ssv_network_fetch_big_data() -> Result<()> {
     let server_handle =
         cb_tests::mock_ssv_public::create_mock_public_ssv_server(port, None).await?;
     let url = Url::parse(&format!("http://localhost:{port}/big_data")).unwrap();
-    let node_operator_id = U256::from(0);
-    let response = request_ssv_pubkeys_from_public_api(
-        url.clone(),
-        node_operator_id,
-        Duration::from_secs(120),
-    )
-    .await;
+    let response = request_ssv_pubkeys_from_public_api(url.clone(), Duration::from_secs(120)).await;
 
     // The response should fail due to content length being too big
     match response {
         Ok(_) => {
             panic!("Expected an error due to big content length, but got a successful response")
         }
         Err(e) => match e.downcast_ref::<ResponseReadError>() {
-            Some(ResponseReadError::PayloadTooLarge {
-                max,
-                content_length,
-                request_url,
-                request_context,
-            }) => {
+            Some(ResponseReadError::PayloadTooLarge { max, content_length, request_url }) => {
                 assert_eq!(*max, MUXER_HTTP_MAX_LENGTH);
                 assert!(*content_length > MUXER_HTTP_MAX_LENGTH);
                 assert_eq!(url.as_str(), request_url.as_str());
-                assert_eq!(request_context.as_str(), node_operator_id.to_string());
             }
             _ => panic!("Expected PayloadTooLarge error, got: {}", e),
         },
@@ -131,13 +115,8 @@ async fn test_ssv_network_fetch_timeout() -> Result<()> {
     let url =
         Url::parse(&format!("http://localhost:{port}/api/v4/test_chain/validators/in_operator/1"))
             .unwrap();
-    let node_operator_id = U256::from(0);
-    let response = request_ssv_pubkeys_from_public_api(
-        url,
-        node_operator_id,
-        Duration::from_secs(TEST_HTTP_TIMEOUT),
-    )
-    .await;
+    let response =
+        request_ssv_pubkeys_from_public_api(url, Duration::from_secs(TEST_HTTP_TIMEOUT)).await;
 
     // The response should fail due to timeout
     assert!(response.is_err(), "Expected timeout error, but got success");
@@ -160,30 +139,18 @@ async fn test_ssv_network_fetch_big_data_without_content_length() -> Result<()>
     set_ignore_content_length(true);
     let server_handle = create_mock_public_ssv_server(port, None).await?;
     let url = Url::parse(&format!("http://localhost:{port}/big_data")).unwrap();
-    let node_operator_id = U256::from(0);
-    let response = request_ssv_pubkeys_from_public_api(
-        url.clone(),
-        node_operator_id,
-        Duration::from_secs(120),
-    )
-    .await;
+    let response = request_ssv_pubkeys_from_public_api(url.clone(), Duration::from_secs(120)).await;
 
     // The response should fail due to the body being too big
     match response {
         Ok(_) => {
             panic!("Expected an error due to excessive data, but got a successful response")
         }
         Err(e) => match e.downcast_ref::<ResponseReadError>() {
-            Some(ResponseReadError::PayloadTooLarge {
-                max,
-                content_length,
-                request_url,
-                request_context,
-            }) => {
+            Some(ResponseReadError::PayloadTooLarge { max, content_length, request_url }) => {
                 assert_eq!(*max, MUXER_HTTP_MAX_LENGTH);
                 assert_eq!(*content_length, 0);
                 assert_eq!(url.as_str(), request_url.as_str());
-                assert_eq!(request_context.as_str(), node_operator_id.to_string());
             }
             _ => panic!("Expected PayloadTooLarge error, got: {}", e),
         },
