Merge branch 'main' into mb/add_num_registrations

ManuelBilbao · ManuelBilbao · commit 49586764431d · 2025-01-22T17:46:28.000-03:00
diff --git a/api/signer-api.yml b/api/signer-api.yml
@@ -5,6 +5,7 @@ info:
   description: API that allows commit modules to request generic signatures from validators
 tags:
   - name: Signer
+  - name: Management
 paths:
   /signer/v1/get_pubkeys:
     get:
@@ -254,6 +255,20 @@ paths:
                     type: string
                     example: "Internal error"
 
+  /status:
+    get:
+      summary: Get the status of the Signer API module
+      tags:
+        - Management
+      responses:
+        "200":
+          description: Success
+          content:
+            text/plain:
+              schema:
+                type: string
+                example: "OK"
+
 components:
   securitySchemes:
     BearerAuth:
diff --git a/benches/pbs/src/main.rs b/benches/pbs/src/main.rs
@@ -160,6 +160,7 @@ fn get_mock_validator(bench: BenchConfig) -> RelayClient {
         enable_timing_games: false,
         target_first_request_ms: None,
         frequency_get_header_ms: None,
+        validator_registration_batch_size: None,
     };
 
     RelayClient::new(config).unwrap()
diff --git a/bin/src/lib.rs b/bin/src/lib.rs
@@ -20,7 +20,7 @@ pub mod prelude {
     pub use cb_metrics::provider::MetricsProvider;
     pub use cb_pbs::{
         get_header, get_status, register_validator, submit_block, BuilderApi, BuilderApiState,
-        DefaultBuilderApi, PbsService, PbsState,
+        DefaultBuilderApi, PbsService, PbsState, PbsStateGuard,
     };
     // The TreeHash derive macro requires tree_hash as import
     pub mod tree_hash {
diff --git a/config.example.toml b/config.example.toml
@@ -96,6 +96,9 @@ target_first_request_ms = 200
 # Frequency in ms to send get_header requests
 # OPTIONAL
 frequency_get_header_ms = 300
+# Maximum number of validators to register in a single request.
+# OPTIONAL, DEFAULT: "" (unlimited)
+validator_registration_batch_size = ""
 
 # Configuration for the PBS multiplexers, which enable different configs to be used for get header requests, depending on validator pubkey
 # Note that:
diff --git a/crates/common/src/commit/constants.rs b/crates/common/src/commit/constants.rs
@@ -2,3 +2,4 @@ pub const GET_PUBKEYS_PATH: &str = "/signer/v1/get_pubkeys";
 pub const REQUEST_SIGNATURE_PATH: &str = "/signer/v1/request_signature";
 pub const GENERATE_PROXY_KEY_PATH: &str = "/signer/v1/generate_proxy_key";
 pub const STATUS_PATH: &str = "/status";
+pub const RELOAD_PATH: &str = "/reload";
diff --git a/crates/common/src/config/pbs.rs b/crates/common/src/config/pbs.rs
@@ -50,6 +50,30 @@ pub struct RelayConfig {
     pub target_first_request_ms: Option<u64>,
     /// Frequency in ms to send get_header requests
     pub frequency_get_header_ms: Option<u64>,
+    /// Maximum number of validators to send to relays in one registration
+    /// request
+    #[serde(deserialize_with = "empty_string_as_none", default)]
+    pub validator_registration_batch_size: Option<usize>,
+}
+
+fn empty_string_as_none<'de, D>(deserializer: D) -> Result<Option<usize>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    enum Helper {
+        Str(String),
+        Number(usize),
+    }
+
+    match Helper::deserialize(deserializer)? {
+        Helper::Str(str) if str.is_empty() => Ok(None),
+        Helper::Str(str) => Ok(Some(str.parse().map_err(|_| {
+            serde::de::Error::custom("Expected empty string or number".to_string())
+        })?)),
+        Helper::Number(number) => Ok(Some(number)),
+    }
 }
 
 impl RelayConfig {
diff --git a/crates/common/src/pbs/constants.rs b/crates/common/src/pbs/constants.rs
@@ -6,6 +6,7 @@ pub const GET_HEADER_PATH: &str = "/header/{slot}/{parent_hash}/{pubkey}";
 pub const GET_STATUS_PATH: &str = "/status";
 pub const REGISTER_VALIDATOR_PATH: &str = "/validators";
 pub const SUBMIT_BLOCK_PATH: &str = "/blinded_blocks";
+pub const RELOAD_PATH: &str = "/reload";
 
 // https://ethereum.github.io/builder-specs/#/Builder
 
diff --git a/crates/common/src/pbs/error.rs b/crates/common/src/pbs/error.rs
@@ -17,7 +17,7 @@ pub enum PbsError {
     #[error("json decode error: {err:?}, raw: {raw}")]
     JsonDecode { err: serde_json::Error, raw: String },
 
-    #[error("relay response error. Code: {code}, err: {error_msg}")]
+    #[error("relay response error. Code: {code}, err: {error_msg:?}")]
     RelayResponse { error_msg: String, code: u16 },
 
     #[error("response size exceeds max size: max: {max} raw: {raw}")]
diff --git a/crates/common/src/pbs/event.rs b/crates/common/src/pbs/event.rs
@@ -37,6 +37,8 @@ pub enum BuilderEvent {
     },
     RegisterValidatorRequest(Vec<ValidatorRegistration>),
     RegisterValidatorResponse,
+    ReloadEvent,
+    ReloadResponse,
 }
 
 #[derive(Debug, Clone)]
diff --git a/crates/pbs/src/api.rs b/crates/pbs/src/api.rs
@@ -7,13 +7,13 @@ use cb_common::pbs::{
 
 use crate::{
     mev_boost,
-    state::{BuilderApiState, PbsState},
+    state::{BuilderApiState, PbsState, PbsStateGuard},
 };
 
 #[async_trait]
 pub trait BuilderApi<S: BuilderApiState>: 'static {
     /// Use to extend the BuilderApi
-    fn extra_routes() -> Option<Router<PbsState<S>>> {
+    fn extra_routes() -> Option<Router<PbsStateGuard<S>>> {
         None
     }
 
@@ -48,6 +48,10 @@ pub trait BuilderApi<S: BuilderApiState>: 'static {
     ) -> eyre::Result<()> {
         mev_boost::register_validator(registrations, req_headers, state).await
     }
+
+    async fn reload(state: PbsState<S>) -> eyre::Result<PbsState<S>> {
+        mev_boost::reload(state).await
+    }
 }
 
 pub struct DefaultBuilderApi;
diff --git a/crates/pbs/src/constants.rs b/crates/pbs/src/constants.rs
@@ -2,6 +2,7 @@ pub const STATUS_ENDPOINT_TAG: &str = "status";
 pub const REGISTER_VALIDATOR_ENDPOINT_TAG: &str = "register_validator";
 pub const SUBMIT_BLINDED_BLOCK_ENDPOINT_TAG: &str = "submit_blinded_block";
 pub const GET_HEADER_ENDPOINT_TAG: &str = "get_header";
+pub const RELOAD_ENDPOINT_TAG: &str = "reload";
 
 /// For metrics recorded when a request times out
 pub const TIMEOUT_ERROR_CODE: u16 = 555;
diff --git a/crates/pbs/src/error.rs b/crates/pbs/src/error.rs
@@ -5,22 +5,25 @@ use axum::{http::StatusCode, response::IntoResponse};
 pub enum PbsClientError {
     NoResponse,
     NoPayload,
+    Internal,
 }
 
 impl PbsClientError {
     pub fn status_code(&self) -> StatusCode {
         match self {
             PbsClientError::NoResponse => StatusCode::BAD_GATEWAY,
             PbsClientError::NoPayload => StatusCode::BAD_GATEWAY,
+            PbsClientError::Internal => StatusCode::INTERNAL_SERVER_ERROR,
         }
     }
 }
 
 impl IntoResponse for PbsClientError {
     fn into_response(self) -> axum::response::Response {
-        let msg = match self {
-            PbsClientError::NoResponse => "no response from relays",
-            PbsClientError::NoPayload => "no payload from relays",
+        let msg = match &self {
+            PbsClientError::NoResponse => "no response from relays".to_string(),
+            PbsClientError::NoPayload => "no payload from relays".to_string(),
+            PbsClientError::Internal => "internal server error".to_string(),
         };
 
         (self.status_code(), msg).into_response()
diff --git a/crates/pbs/src/lib.rs b/crates/pbs/src/lib.rs
@@ -12,4 +12,4 @@ pub use api::*;
 pub use constants::*;
 pub use mev_boost::*;
 pub use service::PbsService;
-pub use state::{BuilderApiState, PbsState};
+pub use state::{BuilderApiState, PbsState, PbsStateGuard};
diff --git a/crates/pbs/src/mev_boost/mod.rs b/crates/pbs/src/mev_boost/mod.rs
@@ -1,9 +1,11 @@
 mod get_header;
 mod register_validator;
+mod reload;
 mod status;
 mod submit_block;
 
 pub use get_header::get_header;
 pub use register_validator::register_validator;
+pub use reload::reload;
 pub use status::get_status;
 pub use submit_block::submit_block;
diff --git a/crates/pbs/src/mev_boost/register_validator.rs b/crates/pbs/src/mev_boost/register_validator.rs
@@ -45,16 +45,30 @@ pub async fn register_validator<S: BuilderApiState>(
     let mut handles = Vec::with_capacity(relays.len());
     let start_register = Instant::now();
 
-    for relay in relays {
-        handles.push(tokio::spawn(
-            send_register_validator_with_timeout(
-                registrations.clone(),
-                relay,
-                send_headers.clone(),
-                state.pbs_config().timeout_register_validator_ms,
-            )
-            .in_current_span(),
-        ));
+    for relay in relays.clone() {
+        if let Some(batch_size) = relay.config.validator_registration_batch_size {
+            for batch in registrations.chunks(batch_size) {
+                handles.push(tokio::spawn(
+                    send_register_validator_with_timeout(
+                        batch.to_vec(),
+                        relay.clone(),
+                        send_headers.clone(),
+                        state.pbs_config().timeout_register_validator_ms,
+                    )
+                    .in_current_span(),
+                ));
+            }
+        } else {
+            handles.push(tokio::spawn(
+                send_register_validator_with_timeout(
+                    registrations.clone(),
+                    relay.clone(),
+                    send_headers.clone(),
+                    state.pbs_config().timeout_register_validator_ms,
+                )
+                .in_current_span(),
+            ));
+        }
     }
 
     if state.pbs_config().wait_all_registrations {
diff --git a/crates/pbs/src/mev_boost/reload.rs b/crates/pbs/src/mev_boost/reload.rs
@@ -0,0 +1,27 @@
+use cb_common::config::load_pbs_config;
+use tracing::warn;
+
+use crate::{BuilderApiState, PbsState};
+
+/// Reload the PBS state with the latest configuration in the config file
+/// Returns 200 if successful or 500 if failed
+pub async fn reload<S: BuilderApiState>(state: PbsState<S>) -> eyre::Result<PbsState<S>> {
+    let pbs_config = load_pbs_config().await?;
+    let new_state = PbsState::new(pbs_config).with_data(state.data);
+
+    if state.config.pbs_config.host != new_state.config.pbs_config.host {
+        warn!(
+            "Host change for PBS module require a full restart. Old: {}, New: {}",
+            state.config.pbs_config.host, new_state.config.pbs_config.host
+        );
+    }
+
+    if state.config.pbs_config.port != new_state.config.pbs_config.port {
+        warn!(
+            "Port change for PBS module require a full restart. Old: {}, New: {}",
+            state.config.pbs_config.port, new_state.config.pbs_config.port
+        );
+    }
+
+    Ok(new_state)
+}
diff --git a/crates/pbs/src/routes/get_header.rs b/crates/pbs/src/routes/get_header.rs
@@ -17,15 +17,17 @@ use crate::{
     constants::GET_HEADER_ENDPOINT_TAG,
     error::PbsClientError,
     metrics::BEACON_NODE_STATUS,
-    state::{BuilderApiState, PbsState},
+    state::{BuilderApiState, PbsStateGuard},
 };
 
 #[tracing::instrument(skip_all, name = "get_header", fields(req_id = %Uuid::new_v4(), slot = params.slot))]
 pub async fn handle_get_header<S: BuilderApiState, A: BuilderApi<S>>(
-    State(state): State<PbsState<S>>,
+    State(state): State<PbsStateGuard<S>>,
     req_headers: HeaderMap,
     Path(params): Path<GetHeaderParams>,
 ) -> Result<impl IntoResponse, PbsClientError> {
+    let state = state.read().clone();
+
     state.publish_event(BuilderEvent::GetHeaderRequest(params));
 
     let ua = get_user_agent(&req_headers);
diff --git a/crates/pbs/src/routes/mod.rs b/crates/pbs/src/routes/mod.rs
@@ -1,5 +1,6 @@
 mod get_header;
 mod register_validator;
+mod reload;
 mod router;
 mod status;
 mod submit_block;
diff --git a/crates/pbs/src/routes/register_validator.rs b/crates/pbs/src/routes/register_validator.rs
@@ -16,15 +16,17 @@ use crate::{
     constants::REGISTER_VALIDATOR_ENDPOINT_TAG,
     error::PbsClientError,
     metrics::BEACON_NODE_STATUS,
-    state::{BuilderApiState, PbsState},
+    state::{BuilderApiState, PbsStateGuard},
 };
 
 #[tracing::instrument(skip_all, name = "register_validators", fields(req_id = %Uuid::new_v4()))]
 pub async fn handle_register_validator<S: BuilderApiState, A: BuilderApi<S>>(
-    State(state): State<PbsState<S>>,
+    State(state): State<PbsStateGuard<S>>,
     req_headers: HeaderMap,
     Json(registrations): Json<Vec<ValidatorRegistration>>,
 ) -> Result<impl IntoResponse, PbsClientError> {
+    let state = state.read().clone();
+
     trace!(?registrations);
     state.publish_event(BuilderEvent::RegisterValidatorRequest(registrations.clone()));
 
diff --git a/crates/pbs/src/routes/reload.rs b/crates/pbs/src/routes/reload.rs
@@ -0,0 +1,47 @@
+use axum::{extract::State, http::HeaderMap, response::IntoResponse};
+use cb_common::{pbs::BuilderEvent, utils::get_user_agent};
+use reqwest::StatusCode;
+use tracing::{error, info};
+use uuid::Uuid;
+
+use crate::{
+    error::PbsClientError,
+    metrics::BEACON_NODE_STATUS,
+    state::{BuilderApiState, PbsStateGuard},
+    BuilderApi, RELOAD_ENDPOINT_TAG,
+};
+
+#[tracing::instrument(skip_all, name = "reload", fields(req_id = %Uuid::new_v4()))]
+pub async fn handle_reload<S: BuilderApiState, A: BuilderApi<S>>(
+    req_headers: HeaderMap,
+    State(state): State<PbsStateGuard<S>>,
+) -> Result<impl IntoResponse, PbsClientError> {
+    let prev_state = state.read().clone();
+
+    prev_state.publish_event(BuilderEvent::ReloadEvent);
+
+    let ua = get_user_agent(&req_headers);
+
+    info!(ua, relay_check = prev_state.config.pbs_config.relay_check);
+
+    match A::reload(prev_state.clone()).await {
+        Ok(new_state) => {
+            prev_state.publish_event(BuilderEvent::ReloadResponse);
+            info!("config reload successful");
+
+            *state.write() = new_state;
+
+            BEACON_NODE_STATUS.with_label_values(&["200", RELOAD_ENDPOINT_TAG]).inc();
+            Ok((StatusCode::OK, "OK"))
+        }
+        Err(err) => {
+            error!(%err, "config reload failed");
+
+            let err = PbsClientError::Internal;
+            BEACON_NODE_STATUS
+                .with_label_values(&[err.status_code().as_str(), RELOAD_ENDPOINT_TAG])
+                .inc();
+            Err(err)
+        }
+    }
+}
diff --git a/crates/pbs/src/routes/router.rs b/crates/pbs/src/routes/router.rs
@@ -3,23 +3,28 @@ use axum::{
     Router,
 };
 use cb_common::pbs::{
-    BUILDER_API_PATH, GET_HEADER_PATH, GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, SUBMIT_BLOCK_PATH,
+    BUILDER_API_PATH, GET_HEADER_PATH, GET_STATUS_PATH, REGISTER_VALIDATOR_PATH, RELOAD_PATH,
+    SUBMIT_BLOCK_PATH,
 };
 
-use super::{handle_get_header, handle_get_status, handle_register_validator, handle_submit_block};
+use super::{
+    handle_get_header, handle_get_status, handle_register_validator, handle_submit_block,
+    reload::handle_reload,
+};
 use crate::{
     api::BuilderApi,
-    state::{BuilderApiState, PbsState},
+    state::{BuilderApiState, PbsStateGuard},
 };
 
-pub fn create_app_router<S: BuilderApiState, A: BuilderApi<S>>(state: PbsState<S>) -> Router {
+pub fn create_app_router<S: BuilderApiState, A: BuilderApi<S>>(state: PbsStateGuard<S>) -> Router {
     let 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(REGISTER_VALIDATOR_PATH, post(handle_register_validator::<S, A>))
         .route(SUBMIT_BLOCK_PATH, post(handle_submit_block::<S, A>));
+    let reload_router = Router::new().route(RELOAD_PATH, post(handle_reload::<S, A>));
 
-    let builder_api = Router::new().nest(BUILDER_API_PATH, builder_routes);
+    let builder_api = Router::new().nest(BUILDER_API_PATH, builder_routes).merge(reload_router);
 
     let app = if let Some(extra_routes) = A::extra_routes() {
         builder_api.merge(extra_routes)
diff --git a/crates/pbs/src/routes/status.rs b/crates/pbs/src/routes/status.rs
diff --git a/crates/pbs/src/routes/submit_block.rs b/crates/pbs/src/routes/submit_block.rs
diff --git a/crates/pbs/src/service.rs b/crates/pbs/src/service.rs
diff --git a/crates/pbs/src/state.rs b/crates/pbs/src/state.rs
diff --git a/crates/signer/src/service.rs b/crates/signer/src/service.rs
diff --git a/docs/docs/get_started/configuration.md b/docs/docs/get_started/configuration.md
diff --git a/examples/status_api/src/main.rs b/examples/status_api/src/main.rs
diff --git a/tests/src/mock_validator.rs b/tests/src/mock_validator.rs
diff --git a/tests/src/utils.rs b/tests/src/utils.rs
diff --git a/tests/tests/pbs_integration.rs b/tests/tests/pbs_integration.rs

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,8 @@ pub enum BuilderEvent {`
`37`	`37`	`},`
`38`	`38`	`RegisterValidatorRequest(Vec<ValidatorRegistration>),`
`39`	`39`	`RegisterValidatorResponse,`
	`40`	`+ ReloadEvent,`
	`41`	`+ ReloadResponse,`
`40`	`42`	`}`
`41`	`43`
`42`	`44`	`#[derive(Debug, Clone)]`