Merge branch 'sigp-audit-fixes' into prevent-cross-module-sigs

Author: jclapis

crates/cli/src/docker_init.rs

@@ -17,7 +17,7 @@ use cb_common::{
         SIGNER_DIR_SECRETS_DEFAULT, SIGNER_DIR_SECRETS_ENV, SIGNER_ENDPOINT_ENV, SIGNER_KEYS_ENV,
         SIGNER_MODULE_NAME, SIGNER_PORT_DEFAULT, SIGNER_URL_ENV,
     },
-    pbs::{BUILDER_API_PATH, GET_STATUS_PATH},
+    pbs::{BUILDER_V1_API_PATH, GET_STATUS_PATH},
     signer::{ProxyStore, SignerLoader},
     types::ModuleId,
     utils::random_jwt_secret,
@@ -308,7 +308,7 @@ pub async fn handle_docker_init(config_path: PathBuf, output_dir: PathBuf) -> Re
         healthcheck: Some(Healthcheck {
             test: Some(HealthcheckTest::Single(format!(
                 "curl -f http://localhost:{}{}{}",
-                cb_config.pbs.pbs_config.port, BUILDER_API_PATH, GET_STATUS_PATH
+                cb_config.pbs.pbs_config.port, BUILDER_V1_API_PATH, GET_STATUS_PATH
             ))),
             interval: Some("30s".into()),
             timeout: Some("5s".into()),

crates/common/src/pbs/builder.rs

@@ -0,0 +1,30 @@
+use std::fmt::{Display, Formatter, Result};
+
+use serde::{Deserialize, Serialize};
+
+use crate::pbs::{BUILDER_V1_API_PATH, BUILDER_V2_API_PATH};
+
+// Version of the builder API for various routes
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum BuilderApiVersion {
+    V1 = 1,
+    V2,
+}
+impl BuilderApiVersion {
+    pub const fn path(&self) -> &'static str {
+        match self {
+            BuilderApiVersion::V1 => BUILDER_V1_API_PATH,
+            BuilderApiVersion::V2 => BUILDER_V2_API_PATH,
+        }
+    }
+}
+impl Display for BuilderApiVersion {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        let s = match self {
+            BuilderApiVersion::V1 => "v1",
+            BuilderApiVersion::V2 => "v2",
+        };
+        write!(f, "{}", s)
+    }
+}

crates/common/src/pbs/constants.rs

@@ -1,6 +1,7 @@
 use crate::constants::COMMIT_BOOST_VERSION;
 
-pub const BUILDER_API_PATH: &str = "/eth/v1/builder";
+pub const BUILDER_V1_API_PATH: &str = "/eth/v1/builder";
+pub const BUILDER_V2_API_PATH: &str = "/eth/v2/builder";
 
 pub const GET_HEADER_PATH: &str = "/header/{slot}/{parent_hash}/{pubkey}";
 pub const GET_STATUS_PATH: &str = "/status";

crates/common/src/pbs/event.rs

@@ -20,7 +20,7 @@ use super::{
 };
 use crate::{
     config::{load_optional_env_var, BUILDER_URLS_ENV, HTTP_TIMEOUT_SECONDS_DEFAULT},
-    pbs::BUILDER_EVENTS_PATH,
+    pbs::{BuilderApiVersion, BUILDER_EVENTS_PATH},
 };
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -29,8 +29,9 @@ pub enum BuilderEvent {
     GetHeaderResponse(Box<Option<GetHeaderResponse>>),
     GetStatusEvent,
     GetStatusResponse,
-    SubmitBlockRequest(Box<SignedBlindedBeaconBlock>),
-    SubmitBlockResponse(Box<SubmitBlindedBlockResponse>),
+    SubmitBlockRequest(Box<SignedBlindedBeaconBlock>, BuilderApiVersion),
+    SubmitBlockResponseV1(Box<SubmitBlindedBlockResponse>),
+    SubmitBlockResponseV2,
     MissedPayload {
         /// Hash for the block for which no payload was received
         block_hash: B256,

crates/common/src/pbs/mod.rs

@@ -1,9 +1,11 @@
+mod builder;
 mod constants;
 pub mod error;
 mod event;
 mod relay;
 mod types;
 
+pub use builder::*;
 pub use constants::*;
 pub use event::*;
 pub use relay::*;

crates/common/src/pbs/relay.rs

@@ -10,11 +10,11 @@ use serde::{Deserialize, Serialize};
 use url::Url;
 
 use super::{
-    constants::{BUILDER_API_PATH, GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, SUBMIT_BLOCK_PATH},
+    constants::{GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, SUBMIT_BLOCK_PATH},
     error::PbsError,
     HEADER_VERSION_KEY, HEADER_VERSION_VALUE,
 };
-use crate::{config::RelayConfig, DEFAULT_REQUEST_TIMEOUT};
+use crate::{config::RelayConfig, pbs::BuilderApiVersion, DEFAULT_REQUEST_TIMEOUT};
 
 /// A parsed entry of the relay url in the format: scheme://pubkey@host
 #[derive(Debug, Clone)]
@@ -101,8 +101,12 @@ impl RelayClient {
 
         Ok(url)
     }
-    pub fn builder_api_url(&self, path: &str) -> Result<Url, PbsError> {
-        self.get_url(&format!("{BUILDER_API_PATH}{path}"))
+    pub fn builder_api_url(
+        &self,
+        path: &str,
+        api_version: BuilderApiVersion,
+    ) -> Result<Url, PbsError> {
+        self.get_url(&format!("{}{path}", api_version.path()))
     }
 
     pub fn get_header_url(
@@ -111,19 +115,22 @@ impl RelayClient {
         parent_hash: B256,
         validator_pubkey: BlsPublicKey,
     ) -> Result<Url, PbsError> {
-        self.builder_api_url(&format!("/header/{slot}/{parent_hash}/{validator_pubkey}"))
+        self.builder_api_url(
+            &format!("/header/{slot}/{parent_hash}/{validator_pubkey}"),
+            BuilderApiVersion::V1,
+        )
     }
 
     pub fn get_status_url(&self) -> Result<Url, PbsError> {
-        self.builder_api_url(GET_STATUS_PATH)
+        self.builder_api_url(GET_STATUS_PATH, BuilderApiVersion::V1)
     }
 
     pub fn register_validator_url(&self) -> Result<Url, PbsError> {
-        self.builder_api_url(REGISTER_VALIDATOR_PATH)
+        self.builder_api_url(REGISTER_VALIDATOR_PATH, BuilderApiVersion::V1)
     }
 
-    pub fn submit_block_url(&self) -> Result<Url, PbsError> {
-        self.builder_api_url(SUBMIT_BLOCK_PATH)
+    pub fn submit_block_url(&self, api_version: BuilderApiVersion) -> Result<Url, PbsError> {
+        self.builder_api_url(SUBMIT_BLOCK_PATH, api_version)
     }
 }
 

crates/pbs/src/api.rs

@@ -2,7 +2,8 @@ use alloy::rpc::types::beacon::relay::ValidatorRegistration;
 use async_trait::async_trait;
 use axum::{http::HeaderMap, Router};
 use cb_common::pbs::{
-    GetHeaderParams, GetHeaderResponse, SignedBlindedBeaconBlock, SubmitBlindedBlockResponse,
+    BuilderApiVersion, GetHeaderParams, GetHeaderResponse, SignedBlindedBeaconBlock,
+    SubmitBlindedBlockResponse,
 };
 
 use crate::{
@@ -31,13 +32,15 @@ pub trait BuilderApi<S: BuilderApiState>: 'static {
         mev_boost::get_status(req_headers, state).await
     }
 
-    /// https://ethereum.github.io/builder-specs/#/Builder/submitBlindedBlock
+    /// https://ethereum.github.io/builder-specs/#/Builder/submitBlindedBlock and
+    /// https://ethereum.github.io/builder-specs/#/Builder/submitBlindedBlockV2
     async fn submit_block(
         signed_blinded_block: SignedBlindedBeaconBlock,
         req_headers: HeaderMap,
         state: PbsState<S>,
-    ) -> eyre::Result<SubmitBlindedBlockResponse> {
-        mev_boost::submit_block(signed_blinded_block, req_headers, state).await
+        api_version: &BuilderApiVersion,
+    ) -> eyre::Result<Option<SubmitBlindedBlockResponse>> {
+        mev_boost::submit_block(signed_blinded_block, req_headers, state, api_version).await
     }
 
     /// https://ethereum.github.io/builder-specs/#/Builder/registerValidator

crates/pbs/src/mev_boost/submit_block.rs

@@ -4,8 +4,8 @@ use axum::http::{HeaderMap, HeaderValue};
 use cb_common::{
     pbs::{
         error::{PbsError, ValidationError},
-        BlindedBeaconBlock, BlindedBeaconBlockElectra, PayloadAndBlobsElectra, RelayClient,
-        SignedBlindedBeaconBlock, SubmitBlindedBlockResponse, VersionedResponse,
+        BlindedBeaconBlock, BlindedBeaconBlockElectra, BuilderApiVersion, PayloadAndBlobsElectra,
+        RelayClient, SignedBlindedBeaconBlock, SubmitBlindedBlockResponse, VersionedResponse,
         HEADER_START_TIME_UNIX_MS,
     },
     utils::{get_user_agent_with_version, read_chunked_body_with_max, utcnow_ms},
@@ -23,12 +23,15 @@ use crate::{
     state::{BuilderApiState, PbsState},
 };
 
-/// Implements https://ethereum.github.io/builder-specs/#/Builder/submitBlindedBlock
+/// Implements https://ethereum.github.io/builder-specs/#/Builder/submitBlindedBlock and
+/// https://ethereum.github.io/builder-specs/#/Builder/submitBlindedBlockV2. Use `api_version` to
+/// distinguish between the two.
 pub async fn submit_block<S: BuilderApiState>(
     signed_blinded_block: SignedBlindedBeaconBlock,
     req_headers: HeaderMap,
     state: PbsState<S>,
-) -> eyre::Result<SubmitBlindedBlockResponse> {
+    api_version: &BuilderApiVersion,
+) -> eyre::Result<Option<SubmitBlindedBlockResponse>> {
     // prepare headers
     let mut send_headers = HeaderMap::new();
     send_headers.insert(HEADER_START_TIME_UNIX_MS, HeaderValue::from(utcnow_ms()));
@@ -42,6 +45,7 @@ pub async fn submit_block<S: BuilderApiState>(
             relay,
             send_headers.clone(),
             state.pbs_config().timeout_get_payload_ms,
+            api_version,
         )));
     }
 
@@ -59,8 +63,9 @@ async fn submit_block_with_timeout(
     relay: &RelayClient,
     headers: HeaderMap,
     timeout_ms: u64,
-) -> Result<SubmitBlindedBlockResponse, PbsError> {
-    let url = relay.submit_block_url()?;
+    api_version: &BuilderApiVersion,
+) -> Result<Option<SubmitBlindedBlockResponse>, PbsError> {
+    let url = relay.submit_block_url(*api_version)?;
     let mut remaining_timeout_ms = timeout_ms;
     let mut retry = 0;
     let mut backoff = Duration::from_millis(250);
@@ -74,6 +79,7 @@ async fn submit_block_with_timeout(
             headers.clone(),
             remaining_timeout_ms,
             retry,
+            api_version,
         )
         .await
         {
@@ -107,7 +113,8 @@ async fn send_submit_block(
     headers: HeaderMap,
     timeout_ms: u64,
     retry: u32,
-) -> Result<SubmitBlindedBlockResponse, PbsError> {
+    api_version: &BuilderApiVersion,
+) -> Result<Option<SubmitBlindedBlockResponse>, PbsError> {
     let start_request = Instant::now();
     let res = match relay
         .client
@@ -151,6 +158,10 @@ async fn send_submit_block(
         warn!(relay_id = relay.id.as_ref(), retry, %err, "failed to get payload (this might be ok if other relays have it)");
         return Err(err);
     };
+    if api_version != &BuilderApiVersion::V1 {
+        // v2 response is going to be empty, so just break here
+        return Ok(None);
+    }
 
     let block_response = match serde_json::from_slice::<SubmitBlindedBlockResponse>(&response_bytes)
     {
@@ -187,7 +198,7 @@ async fn send_submit_block(
         ) => validate_unblinded_block_electra(signed_blinded_block, block_response),
     }?;
 
-    Ok(block_response)
+    Ok(Some(block_response))
 }
 
 fn validate_unblinded_block_electra(

crates/pbs/src/routes/mod.rs

@@ -9,4 +9,4 @@ use get_header::handle_get_header;
 use register_validator::handle_register_validator;
 pub use router::create_app_router;
 use status::handle_get_status;
-use submit_block::handle_submit_block;
+use submit_block::handle_submit_block_v1;

crates/pbs/src/routes/router.rs

@@ -7,18 +7,19 @@ use axum::{
 };
 use axum_extra::headers::{ContentType, HeaderMapExt, UserAgent};
 use cb_common::pbs::{
-    BUILDER_API_PATH, GET_HEADER_PATH, GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, RELOAD_PATH,
-    SUBMIT_BLOCK_PATH,
+    BUILDER_V1_API_PATH, BUILDER_V2_API_PATH, GET_HEADER_PATH, GET_STATUS_PATH,
+    REGISTER_VALIDATOR_PATH, RELOAD_PATH, SUBMIT_BLOCK_PATH,
 };
 use tracing::trace;
 use uuid::Uuid;
 
 use super::{
-    handle_get_header, handle_get_status, handle_register_validator, handle_submit_block,
+    handle_get_header, handle_get_status, handle_register_validator, handle_submit_block_v1,
     reload::handle_reload,
 };
 use crate::{
     api::BuilderApi,
+    routes::submit_block::handle_submit_block_v2,
     state::{BuilderApiState, PbsStateGuard},
     MAX_SIZE_REGISTER_VALIDATOR_REQUEST, MAX_SIZE_SUBMIT_BLOCK_RESPONSE,
 };
@@ -27,7 +28,7 @@ pub fn create_app_router<S: BuilderApiState, A: BuilderApi<S>>(state: PbsStateGu
     // DefaultBodyLimit is 2Mib by default, so we only increase it for a few routes
     // thay may need more
 
-    let builder_routes = Router::new()
+    let v1_builder_routes = Router::new()
         .route(GET_HEADER_PATH, get(handle_get_header::<S, A>))
         .route(GET_STATUS_PATH, get(handle_get_status::<S, A>))
         .route(
@@ -37,11 +38,19 @@ pub fn create_app_router<S: BuilderApiState, A: BuilderApi<S>>(state: PbsStateGu
         )
         .route(
             SUBMIT_BLOCK_PATH,
-            post(handle_submit_block::<S, A>)
+            post(handle_submit_block_v1::<S, A>)
                 .route_layer(DefaultBodyLimit::max(MAX_SIZE_SUBMIT_BLOCK_RESPONSE)),
         ); // header is smaller than the response but err on the safe side
+    let v2_builder_routes = Router::new().route(
+        SUBMIT_BLOCK_PATH,
+        post(handle_submit_block_v2::<S, A>)
+            .route_layer(DefaultBodyLimit::max(MAX_SIZE_SUBMIT_BLOCK_RESPONSE)),
+    );
+    let v1_builder_router = Router::new().nest(BUILDER_V1_API_PATH, v1_builder_routes);
+    let v2_builder_router = Router::new().nest(BUILDER_V2_API_PATH, v2_builder_routes);
     let reload_router = Router::new().route(RELOAD_PATH, post(handle_reload::<S, A>));
-    let builder_api = Router::new().nest(BUILDER_API_PATH, builder_routes).merge(reload_router);
+    let builder_api =
+        Router::new().merge(v1_builder_router).merge(v2_builder_router).merge(reload_router);
 
     let app = if let Some(extra_routes) = A::extra_routes() {
         builder_api.merge(extra_routes)