remove get_uninitialized_ptc_validators

Author: shane-moore

common/eth2/src/lib.rs

@@ -2889,6 +2889,8 @@ impl BeaconNodeHttpClient {
             .await
     }
 
+    // TODO(EIP-7732): Create corresponding beacon node response endpoint per spec
+    // https://github.com/ethereum/beacon-APIs/pull/552
     /// `POST validator/duties/ptc/{epoch}`
     pub async fn post_validator_duties_ptc(
         &self,

common/eth2/src/types.rs

@@ -4,12 +4,12 @@
 pub use types::*;
 
 use crate::{
-    Error as ServerError, CONSENSUS_BLOCK_VALUE_HEADER, CONSENSUS_VERSION_HEADER,
-    EXECUTION_PAYLOAD_BLINDED_HEADER, EXECUTION_PAYLOAD_VALUE_HEADER,
+    CONSENSUS_BLOCK_VALUE_HEADER, CONSENSUS_VERSION_HEADER, EXECUTION_PAYLOAD_BLINDED_HEADER,
+    EXECUTION_PAYLOAD_VALUE_HEADER, Error as ServerError,
 };
 use bls::{PublicKeyBytes, SecretKey, Signature, SignatureBytes};
 use context_deserialize::ContextDeserialize;
-use mediatype::{names, MediaType, MediaTypeList};
+use mediatype::{MediaType, MediaTypeList, names};
 use reqwest::header::HeaderMap;
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_utils::quoted_u64::Quoted;
@@ -1604,7 +1604,7 @@ pub struct BroadcastValidationQuery {
 
 pub mod serde_status_code {
     use crate::StatusCode;
-    use serde::{de::Error, Deserialize, Serialize};
+    use serde::{Deserialize, Serialize, de::Error};
 
     pub fn serialize<S>(status_code: &StatusCode, ser: S) -> Result<S::Ok, S::Error>
     where

validator_client/http_metrics/src/lib.rs

@@ -197,6 +197,16 @@ pub fn gather_prometheus_metrics<E: EthSpec>(
                 &[NEXT_EPOCH],
                 duties_service.attester_count(next_epoch) as i64,
             );
+            set_int_gauge(
+                &PTC_COUNT,
+                &[CURRENT_EPOCH],
+                duties_service.ptc_count(current_epoch) as i64,
+            );
+            set_int_gauge(
+                &PTC_COUNT,
+                &[NEXT_EPOCH],
+                duties_service.ptc_count(next_epoch) as i64,
+            );
         }
     }
 

validator_client/validator_services/src/duties_service.rs

@@ -411,7 +411,7 @@ pub struct DutiesService<S, T> {
     pub proposers: RwLock<ProposerMap>,
     /// Map from validator index to sync committee duties.
     pub sync_duties: SyncDutiesMap,
-    /// Maps an epoch to all *local* PTC duties for that epoch with their dependent root.
+    /// Maps an epoch to PTC duties for locally-managed validators.
     pub ptc_duties: RwLock<PtcMap>,
     /// Provides the canonical list of locally-managed validators.
     pub validator_store: Arc<S>,
@@ -1243,25 +1243,6 @@ fn get_uninitialized_validators<S: ValidatorStore, T: SlotClock + 'static>(
         .collect::<Vec<_>>()
 }
 
-/// Get a filtered list of local validators for which we don't already know their PTC duties for that epoch
-fn get_uninitialized_ptc_validators<S: ValidatorStore, T: SlotClock + 'static>(
-    duties_service: &Arc<DutiesService<S, T>>,
-    epoch: &Epoch,
-    local_pubkeys: &HashSet<PublicKeyBytes>,
-) -> Vec<u64> {
-    let ptc_duties = duties_service.ptc_duties.read();
-
-    local_pubkeys
-        .iter()
-        .filter(|pubkey| {
-            ptc_duties
-                .get(epoch)
-                .map_or(true, |(_, duties)| !duties.contains_key(pubkey))
-        })
-        .filter_map(|pubkey| duties_service.validator_store.validator_index(pubkey))
-        .collect::<Vec<_>>()
-}
-
 fn update_per_validator_duty_metrics<S: ValidatorStore, T: SlotClock + 'static>(
     duties_service: &Arc<DutiesService<S, T>>,
     epoch: Epoch,
@@ -1807,17 +1788,12 @@ async fn poll_beacon_ptc_attesters_for_epoch<
         &[validator_metrics::UPDATE_PTC_FETCH],
     );
 
-    // Request duties for all uninitialized validators. If there isn't any, we will just request for
-    // `INITIAL_PTC_DUTIES_QUERY_SIZE` validators. We use the `dependent_root` in the response to
-    // determine whether validator duties need to be updated. This is to ensure that we don't
-    // request for extra data unless necessary in order to save on network bandwidth.
-    let uninitialized_validators =
-        get_uninitialized_ptc_validators(duties_service, &epoch, local_pubkeys);
-    let initial_indices_to_request = if !uninitialized_validators.is_empty() {
-        uninitialized_validators.as_slice()
-    } else {
-        &local_indices[0..min(INITIAL_PTC_DUTIES_QUERY_SIZE, local_indices.len())]
-    };
+    // Make a small initial request to check the dependent_root and determine if we need to fetch
+    // all duties. We use the `dependent_root` in the response to determine whether validator
+    // duties need to be updated. This is to ensure that we don't request for extra data unless
+    // necessary in order to save on network bandwidth.
+    let initial_indices_to_request =
+        &local_indices[0..min(INITIAL_PTC_DUTIES_QUERY_SIZE, local_indices.len())];
 
     let response =
         post_validator_duties_ptc(duties_service, epoch, initial_indices_to_request).await?;
@@ -1830,7 +1806,7 @@ async fn poll_beacon_ptc_attesters_for_epoch<
         let ptc_duties = duties_service.ptc_duties.read();
         let needs_update = ptc_duties
             .get(&epoch)
-            .map_or(true, |(prior_root, _duties)| {
+            .is_none_or(|(prior_root, _duties)| {
                 // Update if dependent_root changed
                 *prior_root != dependent_root
             });

validator_client/validator_services/src/notifier_service.rs

@@ -109,6 +109,7 @@ pub async fn notify<S: ValidatorStore, T: SlotClock + 'static>(
         let total_validators = duties_service.total_validator_count();
         let proposing_validators = duties_service.proposer_count(epoch);
         let attesting_validators = duties_service.attester_count(epoch);
+        let ptc_validators = duties_service.ptc_count(epoch);
         let doppelganger_detecting_validators = duties_service.doppelganger_detecting_count();
 
         if doppelganger_detecting_validators > 0 {
@@ -126,6 +127,7 @@ pub async fn notify<S: ValidatorStore, T: SlotClock + 'static>(
         } else if total_validators == attesting_validators {
             info!(
                 current_epoch_proposers = proposing_validators,
+                current_epoch_ptc = ptc_validators,
                 active_validators = attesting_validators,
                 total_validators = total_validators,
                 %epoch,
@@ -135,6 +137,7 @@ pub async fn notify<S: ValidatorStore, T: SlotClock + 'static>(
         } else if attesting_validators > 0 {
             info!(
                 current_epoch_proposers = proposing_validators,
+                current_epoch_ptc = ptc_validators,
                 active_validators = attesting_validators,
                 total_validators = total_validators,
                 %epoch,