v2: add most of the remaining changes

Author: xenowits

common/eth2/src/lighthouse_vc/types.rs

@@ -65,6 +65,10 @@ pub struct CreatedValidator {
     #[serde(default)]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub builder_proposals: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub builder_pubkey_override: Option<PublicKeyBytes>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub builder_timestamp_override: Option<u64>,
     pub eth1_deposit_tx_data: String,
     #[serde(with = "eth2_serde_utils::quoted_u64")]
     pub deposit_gwei: u64,
@@ -132,6 +136,8 @@ pub struct Web3SignerValidatorRequest {
     pub builder_proposals: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub builder_pubkey_override: Option<PublicKeyBytes>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub builder_timestamp_override: Option<u64>,
     pub voting_public_key: PublicKey,
     pub url: String,
     #[serde(default)]

validator_client/src/http_api/create_validator.rs

@@ -142,7 +142,8 @@ pub async fn create_validators_mnemonic<P: AsRef<Path>, T: 'static + SlotClock,
                 request.suggested_fee_recipient,
                 request.gas_limit,
                 request.builder_proposals,
-                request.builder_pubkey_override
+                request.builder_pubkey_override,
+                request.builder_timestamp_override
             )
             .await
             .map_err(|e| {
@@ -159,6 +160,8 @@ pub async fn create_validators_mnemonic<P: AsRef<Path>, T: 'static + SlotClock,
             suggested_fee_recipient: request.suggested_fee_recipient,
             gas_limit: request.gas_limit,
             builder_proposals: request.builder_proposals,
+            builder_pubkey_override: request.builder_pubkey_override,
+            builder_timestamp_override: request.builder_timestamp_override,
             voting_pubkey,
             eth1_deposit_tx_data: eth2_serde_utils::hex::encode(&eth1_deposit_data.rlp),
             deposit_gwei: request.deposit_gwei,

validator_client/src/http_api/keystores.rs

@@ -208,6 +208,7 @@ fn import_single_keystore<T: SlotClock + 'static, E: EthSpec>(
             None,
             None,
             None,
+            None
         ))
         .map_err(|e| format!("failed to initialize validator: {:?}", e))?;
 

validator_client/src/http_api/tests.rs

@@ -286,6 +286,7 @@ impl ApiTester {
                 gas_limit: None,
                 builder_proposals: None,
                 builder_pubkey_override: None,
+                builder_timestamp_override: None,
                 deposit_gwei: E::default_spec().max_effective_balance,
             })
             .collect::<Vec<_>>();
@@ -480,6 +481,7 @@ impl ApiTester {
                     gas_limit: None,
                     builder_proposals: None,
                     builder_pubkey_override: None,
+                    builder_timestamp_override: None,
                     voting_public_key: kp.pk,
                     url: format!("http://signer_{}.com/", i),
                     root_certificate_path: None,
@@ -536,7 +538,7 @@ impl ApiTester {
         let validator = &self.client.get_lighthouse_validators().await.unwrap().data[index];
 
         self.client
-            .patch_lighthouse_validators(&validator.voting_pubkey, Some(enabled), None, None)
+            .patch_lighthouse_validators(&validator.voting_pubkey, Some(enabled), None, None, None, None)
             .await
             .unwrap();
 
@@ -578,7 +580,7 @@ impl ApiTester {
         let validator = &self.client.get_lighthouse_validators().await.unwrap().data[index];
 
         self.client
-            .patch_lighthouse_validators(&validator.voting_pubkey, None, Some(gas_limit), None)
+            .patch_lighthouse_validators(&validator.voting_pubkey, None, Some(gas_limit), None, None, None)
             .await
             .unwrap();
 
@@ -605,6 +607,7 @@ impl ApiTester {
                 None,
                 None,
                 Some(builder_proposals),
+                None,
                 None
             )
             .await
@@ -634,7 +637,8 @@ impl ApiTester {
                 None,
                 None,
                 None,
-                builder_pubkey_override
+                Some(builder_pubkey_override),
+                None
             )
             .await
             .unwrap();
@@ -647,9 +651,38 @@ impl ApiTester {
 
         assert_eq!(
             self.validator_store
-                .get
-            //     .get_builder_proposals(&validator.voting_pubkey),
-            // builder_proposals
+                .get_builder_pubkey_override(&validator.voting_pubkey),
+            builder_pubkey_override
+        );
+
+        self
+    }
+
+    pub async fn set_builder_timestamp_override(self, index: usize, builder_timestamp_override: u64) -> Self {
+        let validator = &self.client.get_lighthouse_validators().await.unwrap().data[index];
+
+        self.client
+            .patch_lighthouse_validators(
+                &validator.voting_pubkey,
+                None,
+                None,
+                None,
+                None,
+                Some(builder_timestamp_override)
+            )
+            .await
+            .unwrap();
+
+        self
+    }
+
+    pub async fn assert_builder_timestamp_override(self, index: usize, builder_timestamp_override: u64) -> Self {
+        let validator = &self.client.get_lighthouse_validators().await.unwrap().data[index];
+
+        assert_eq!(
+            self.validator_store
+                .get_builder_timestamp_override(&validator.voting_pubkey),
+            builder_timestamp_override
         );
 
         self
@@ -720,6 +753,8 @@ fn routes_with_invalid_auth() {
                         suggested_fee_recipient: <_>::default(),
                         gas_limit: <_>::default(),
                         builder_proposals: <_>::default(),
+                        builder_pubkey_override: <_>::default(),
+                        builder_timestamp_override: <_>::default(),
                         deposit_gwei: <_>::default(),
                     }])
                     .await

validator_client/src/http_api/tests/keystores.rs

@@ -43,6 +43,7 @@ fn web3signer_validator_with_pubkey(pubkey: PublicKey) -> Web3SignerValidatorReq
         gas_limit: None,
         builder_proposals: None,
         builder_pubkey_override: None,
+        builder_timestamp_override: None,
         voting_public_key: pubkey,
         url: web3_signer_url(),
         root_certificate_path: None,

validator_client/src/initialized_validators.rs

@@ -113,6 +113,7 @@ pub struct InitializedValidator {
     gas_limit: Option<u64>,
     builder_proposals: Option<bool>,
     builder_pubkey_override: Option<PublicKeyBytes>,
+    builder_timestamp_override: Option<u64>,
     /// The validators index in `state.validators`, to be updated by an external service.
     index: Option<u64>,
 }
@@ -147,6 +148,8 @@ impl InitializedValidator {
 
     pub fn get_builder_pubkey_override(&self) -> Option<PublicKeyBytes> { self.builder_pubkey_override }
 
+    pub fn get_builder_timestamp_override(&self) -> Option<u64> { self.builder_timestamp_override }
+
     pub fn get_index(&self) -> Option<u64> {
         self.index
     }
@@ -316,6 +319,7 @@ impl InitializedValidator {
             gas_limit: def.gas_limit,
             builder_proposals: def.builder_proposals,
             builder_pubkey_override: def.builder_pubkey_override,
+            builder_timestamp_override: def.builder_timestamp_override,
             index: None,
         })
     }
@@ -677,6 +681,14 @@ impl InitializedValidators {
             .and_then(|v| v.builder_pubkey_override)
     }
 
+    /// Returns the `builder_timestamp_override` for a given public key specified in the
+    /// `ValidatorDefinitions`.
+    pub fn builder_timestamp_override(&self, public_key: &PublicKeyBytes) -> Option<u64> {
+        self.validators
+            .get(public_key)
+            .and_then(|v| v.builder_timestamp_override)
+    }
+
     /// Returns an `Option` of a reference to an `InitializedValidator` for a given public key specified in the
     /// `ValidatorDefinitions`.
     pub fn validator(&self, public_key: &PublicKeyBytes) -> Option<&InitializedValidator> {

validator_client/src/preparation_service.rs

@@ -113,23 +113,7 @@ pub struct Inner<T, E: EthSpec> {
 pub struct ValidatorRegistrationKey {
     pub fee_recipient: Address,
     pub gas_limit: u64,
-    pub pubkey: PublicKeyBytes,
-}
-
-impl From<ValidatorRegistrationData> for ValidatorRegistrationKey {
-    fn from(data: ValidatorRegistrationData) -> Self {
-        let ValidatorRegistrationData {
-            fee_recipient,
-            gas_limit,
-            timestamp: _,
-            pubkey,
-        } = data;
-        Self {
-            fee_recipient,
-            gas_limit,
-            pubkey,
-        }
-    }
+    pub signing_pubkey: PublicKeyBytes,
 }
 
 /// Attempts to produce proposer preparations for all known validators at the beginning of each epoch.
@@ -284,21 +268,31 @@ impl<T: SlotClock + 'static, E: EthSpec> PreparationService<T, E> {
         })
     }
 
-    fn collect_validator_registration_keys(&self) -> Vec<ValidatorRegistrationKey> {
-        self.collect_proposal_data(|pubkey, proposal_data| {
+    fn collect_validator_registration_keys(&self) -> Vec<(PublicKeyBytes, ValidatorRegistrationKey)> {
+        self.collect_proposal_data(|signing_pubkey, proposal_data| {
             // Ignore fee recipients for keys without indices, they are inactive.
             proposal_data.validator_index?;
 
             // We don't log for missing fee recipients here because this will be logged more
             // frequently in `collect_preparation_data`.
             proposal_data.fee_recipient.and_then(|fee_recipient| {
-                proposal_data
-                    .builder_proposals
-                    .then_some(ValidatorRegistrationKey {
-                        fee_recipient,
-                        gas_limit: proposal_data.gas_limit,
-                        pubkey,
-                    })
+                proposal_data.builder_proposals.then(|| {
+                    let registration_pubkey =
+                        if let Some(pubkey_override) = proposal_data.builder_pubkey_override {
+                            pubkey_override
+                        } else {
+                            signing_pubkey
+                        };
+
+                    (
+                        registration_pubkey,
+                        ValidatorRegistrationKey {
+                            fee_recipient,
+                            gas_limit: proposal_data.gas_limit,
+                            signing_pubkey,
+                        },
+                    )
+                })
             })
         })
     }
@@ -357,31 +351,35 @@ impl<T: SlotClock + 'static, E: EthSpec> PreparationService<T, E> {
     }
 
     /// Register validators with builders, used in the blinded block proposal flow.
+    /// This method re-publishes all messages if it's been `EPOCHS_PER_VALIDATOR_REGISTRATION_SUBMISSION`.
+    /// Otherwise it publishes any messages that have been updated since they were last published.
     async fn register_validators(&self) -> Result<(), String> {
         let registration_keys = self.collect_validator_registration_keys();
 
-        let mut changed_keys = vec![];
-
-        // Need to scope this so the read lock is not held across an await point (I don't know why
-        // but the explicit `drop` is not enough).
-        {
-            let guard = self.validator_registration_cache.read();
-            for key in registration_keys.iter() {
-                if !guard.contains_key(key) {
-                    changed_keys.push(key.clone());
-                }
-            }
-            drop(guard);
-        }
-
         // Check if any have changed or it's been `EPOCHS_PER_VALIDATOR_REGISTRATION_SUBMISSION`.
         if let Some(slot) = self.slot_clock.now() {
             if slot % (E::slots_per_epoch() * EPOCHS_PER_VALIDATOR_REGISTRATION_SUBMISSION) == 0 {
                 self.publish_validator_registration_data(registration_keys)
                     .await?;
-            } else if !changed_keys.is_empty() {
-                self.publish_validator_registration_data(changed_keys)
-                    .await?;
+            } else {
+                let mut changed_keys = vec![];
+
+                // Need to scope this so the read lock is not held across an await point (I don't know why
+                // but the explicit `drop` is not enough).
+                {
+                    let guard = self.validator_registration_cache.read();
+                    for (registration_pubkey, key) in registration_keys.into_iter() {
+                        if !guard.contains_key(&key) {
+                            changed_keys.push((registration_pubkey, key));
+                        }
+                    }
+                    drop(guard);
+                }
+
+                if !changed_keys.is_empty() {
+                    self.publish_validator_registration_data(changed_keys)
+                        .await?;
+                }
             }
         }
 
@@ -390,14 +388,14 @@ impl<T: SlotClock + 'static, E: EthSpec> PreparationService<T, E> {
 
     async fn publish_validator_registration_data(
         &self,
-        registration_keys: Vec<ValidatorRegistrationKey>,
+        registration_keys: Vec<(PublicKeyBytes, ValidatorRegistrationKey)>,
     ) -> Result<(), String> {
         let log = self.context.log();
 
         let registration_data_len = registration_keys.len();
         let mut signed = Vec::with_capacity(registration_data_len);
 
-        for key in registration_keys {
+        for (registration_pubkey, key) in registration_keys {
             let cached_registration_opt =
                 self.validator_registration_cache.read().get(&key).cloned();
 
@@ -417,22 +415,23 @@ impl<T: SlotClock + 'static, E: EthSpec> PreparationService<T, E> {
                 let ValidatorRegistrationKey {
                     fee_recipient,
                     gas_limit,
-                    pubkey,
+                    signing_pubkey,
                 } = key.clone();
 
                 let signed_data = match self
                     .validator_store
-                    .sign_validator_registration_data(ValidatorRegistrationData {
+                    .sign_validator_registration_data(signing_pubkey,
+                        ValidatorRegistrationData {
                         fee_recipient,
                         gas_limit,
                         timestamp,
-                        pubkey,
+                        pubkey: registration_pubkey,
                     })
                     .await
                 {
                     Ok(data) => data,
                     Err(e) => {
-                        error!(log, "Unable to sign validator registration data"; "error" => ?e, "pubkey" => ?pubkey);
+                        error!(log, "Unable to sign validator registration data"; "error" => ?e, "pubkey" => ?signing_pubkey);
                         continue;
                     }
                 };
@@ -482,4 +481,6 @@ pub struct ProposalData {
     pub(crate) fee_recipient: Option<Address>,
     pub(crate) gas_limit: u64,
     pub(crate) builder_proposals: bool,
+    pub(crate) builder_pubkey_override: Option<PublicKeyBytes>,
+    pub(crate) builder_timestamp_override: Option<u64>
 }