Add SSZ support to validator registration builder API

builder_api/src/api.rs

@@ -15,7 +15,7 @@ use reqwest::{
     Client, Response, StatusCode,
 };
 use serde::de::DeserializeOwned;
-use ssz::{SszHash as _, SszRead, SszWrite as _};
+use ssz::{ContiguousList, SszHash as _, SszRead, SszWrite as _};
 use thiserror::Error;
 use typenum::Unsigned as _;
 use types::{
@@ -71,7 +71,8 @@ pub struct Api {
     config: BuilderConfig,
     client: Client,
     metrics: Option<Arc<Metrics>>,
-    supports_ssz: ArcSwap<Option<bool>>,
+    supports_block_ssz: ArcSwap<Option<bool>>,
+    supports_validators_ssz: ArcSwap<Option<bool>>,
 }
 
 impl Api {
@@ -81,7 +82,8 @@ impl Api {
             config,
             client,
             metrics,
-            supports_ssz: ArcSwap::from_pointee(None),
+            supports_block_ssz: ArcSwap::from_pointee(None),
+            supports_validators_ssz: ArcSwap::from_pointee(None),
         }
     }
 
@@ -129,26 +131,75 @@ impl Api {
         Ok(())
     }
 
-    pub async fn register_validators(
+    pub async fn register_validators<P: Preset>(
         &self,
-        validator_registrations: &[SignedValidatorRegistrationV1],
+        validator_registrations: ContiguousList<
+            SignedValidatorRegistrationV1,
+            P::ValidatorRegistryLimit,
+        >,
     ) -> Result<()> {
         let _timer = self
             .metrics
             .as_ref()
             .map(|metrics| metrics.builder_register_validator_times.start_timer());
 
+        let use_json = self.config.builder_api_format == BuilderApiFormat::Json
+            || self
+                .supports_validators_ssz
+                .load()
+                .is_some_and(|supported| !supported);
+
+        let response = self
+            .post_validators::<P>(&validator_registrations, use_json)
+            .await;
+
+        // See <https://github.com/ethereum/builder-specs/pull/110>
+        if use_json {
+            response
+        } else {
+            match response {
+                Ok(()) => {
+                    self.supports_validators_ssz.store(Arc::new(Some(true)));
+                    Ok(())
+                }
+                Err(error) => {
+                    debug!(
+                        "received error in non-JSON register validators request: {error:?}, \
+                         retrying in JSON"
+                    );
+
+                    self.supports_validators_ssz.store(Arc::new(Some(false)));
+                    self.post_validators::<P>(&validator_registrations, true)
+                        .await
+                }
+            }
+        }
+    }
+
+    async fn post_validators<P: Preset>(
+        &self,
+        validator_registrations: &ContiguousList<
+            SignedValidatorRegistrationV1,
+            P::ValidatorRegistryLimit,
+        >,
+        use_json: bool,
+    ) -> Result<()> {
         debug!("registering validators: {validator_registrations:?}");
 
         let url = self.url("/eth/v1/builder/validators")?;
-        let response = self
-            .client
-            .post(url.into_url())
-            .json(validator_registrations)
-            .send()
-            .await?;
+        let request = self.client.post(url.into_url());
 
-        let response = handle_error(response).await?;
+        let request = if use_json {
+            request.json(validator_registrations)
+        } else {
+            request
+                .header(ACCEPT, APPLICATION_OCTET_STREAM.as_ref())
+                .header(CONTENT_TYPE, APPLICATION_OCTET_STREAM.as_ref())
+                .body(validator_registrations.to_ssz()?)
+        };
+
+        let response = request.send().await?;
+        let response = handle_error(response).await;
 
         debug!("register_validators response: {response:?}");
 
@@ -262,7 +313,10 @@ impl Api {
             .header(ETH_CONSENSUS_VERSION, block.phase().as_ref());
 
         let use_json = self.config.builder_api_format == BuilderApiFormat::Json
-            || self.supports_ssz.load().is_some_and(|supported| !supported);
+            || self
+                .supports_block_ssz
+                .load()
+                .is_some_and(|supported| !supported);
 
         let request = if use_json {
             request.json(block)
@@ -315,7 +369,7 @@ impl Api {
             return response
                 .json()
                 .await
-                .inspect(|_| self.supports_ssz.store(Arc::new(Some(false))))
+                .inspect(|_| self.supports_block_ssz.store(Arc::new(Some(false))))
                 .map_err(Into::into);
         }
 
@@ -324,7 +378,7 @@ impl Api {
             let bytes = response.bytes().await?;
 
             return T::from_ssz(&phase, &bytes)
-                .inspect(|_| self.supports_ssz.store(Arc::new(Some(true))))
+                .inspect(|_| self.supports_block_ssz.store(Arc::new(Some(true))))
                 .map_err(Into::into);
         }
 

builder_api/src/config.rs

@@ -6,8 +6,8 @@ pub const DEFAULT_BUILDER_MAX_SKIPPED_SLOTS: u64 = 3;
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Display, FromStr)]
 pub enum BuilderApiFormat {
-    Json,
     #[default]
+    Json,
     Ssz,
 }
 

builder_api/src/unphased/containers.rs

@@ -20,7 +20,8 @@ pub struct ValidatorRegistrationV1 {
     pub pubkey: PublicKeyBytes,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Ssz)]
+#[ssz(derive_hash = false, derive_read = false)]
 pub struct SignedValidatorRegistrationV1 {
     pub message: ValidatorRegistrationV1,
     pub signature: SignatureBytes,

validator/Cargo.toml

@@ -51,6 +51,7 @@ tap = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
 tower-http = { workspace = true }
+try_from_iterator = { workspace = true }
 tynm = { workspace = true }
 typenum = { workspace = true }
 types = { workspace = true }

validator/src/validator.rs

@@ -47,10 +47,11 @@ use rayon::iter::{IntoParallelIterator as _, ParallelIterator as _};
 use signer::{Signer, SigningMessage, SigningTriple};
 use slasher::{SlasherToValidator, ValidatorToSlasher};
 use slashing_protection::SlashingProtector;
-use ssz::{BitList, BitVector};
+use ssz::{BitList, BitVector, ContiguousList, ReadError};
 use static_assertions::assert_not_impl_any;
 use std_ext::ArcExt as _;
 use tap::{Conv as _, Pipe as _};
+use try_from_iterator::TryFromIterator as _;
 use types::{
     altair::{
         containers::{ContributionAndProof, SignedContributionAndProof, SyncCommitteeMessage},
@@ -2056,11 +2057,17 @@ impl<P: Preset, W: Wait + Sync> Validator<P, W> {
                     message,
                     signature: signature.into(),
                 })
-                .collect_vec();
+                .chunks(MAX_VALIDATORS_PER_REGISTRATION)
+                .into_iter()
+                .map(ContiguousList::<_, P::ValidatorRegistryLimit>::try_from_iter)
+                .collect::<Result<Vec<_>, ReadError>>()
+                .inspect_err(|error| {
+                    warn!("failed to collect validator registrations: {error:?}")
+                })?;
 
             // Do not submit requests in parallel. Doing so causes all of them to be timed out.
-            for registration in signed_registrations.chunks(MAX_VALIDATORS_PER_REGISTRATION) {
-                if let Err(error) = builder_api.register_validators(registration).await {
+            for registrations in signed_registrations {
+                if let Err(error) = builder_api.register_validators::<P>(registrations).await {
                     warn!("failed to register validator batch: {error}");
                 }
             }