remove PhantomData from SyncDutiesMap

validator_client/validator_services/src/duties_service.rs

@@ -213,7 +213,7 @@ pub struct DutiesService<T, E: EthSpec> {
     /// proposals for any validators which are not registered locally.
     pub proposers: RwLock<ProposerMap>,
     /// Map from validator index to sync committee duties.
-    pub sync_duties: SyncDutiesMap<E>,
+    pub sync_duties: SyncDutiesMap,
     /// Provides the canonical list of locally-managed validators.
     pub validator_store: Arc<ValidatorStore<T>>,
     /// Maps unknown validator pubkeys to the next slot time when a poll should be conducted again.

validator_client/validator_services/src/sync.rs

@@ -5,7 +5,6 @@ use parking_lot::{MappedRwLockReadGuard, RwLock, RwLockReadGuard, RwLockWriteGua
 use slog::{crit, debug, info, warn};
 use slot_clock::SlotClock;
 use std::collections::{HashMap, HashSet};
-use std::marker::PhantomData;
 use std::sync::Arc;
 use types::{ChainSpec, EthSpec, PublicKeyBytes, Slot, SyncDuty, SyncSelectionProof, SyncSubnetId};
 use validator_store::Error as ValidatorStoreError;
@@ -27,12 +26,11 @@ pub const AGGREGATION_PRE_COMPUTE_SLOTS_DISTRIBUTED: u64 = 1;
 /// 2. One-at-a-time locking. For the innermost locks on the aggregator duties, all of the functions
 ///    in this file take care to only lock one validator at a time. We never hold a lock while
 ///    trying to obtain another one (hence no lock ordering issues).
-pub struct SyncDutiesMap<E: EthSpec> {
+pub struct SyncDutiesMap {
     /// Map from sync committee period to duties for members of that sync committee.
     committees: RwLock<HashMap<u64, CommitteeDuties>>,
     /// Whether we are in `distributed` mode and using reduced lookahead for aggregate pre-compute.
     distributed: bool,
-    _phantom: PhantomData<E>,
 }
 
 /// Duties for a single sync committee period.
@@ -80,12 +78,11 @@ pub struct SlotDuties {
     pub aggregators: HashMap<SyncSubnetId, Vec<(u64, PublicKeyBytes, SyncSelectionProof)>>,
 }
 
-impl<E: EthSpec> SyncDutiesMap<E> {
+impl SyncDutiesMap {
     pub fn new(distributed: bool) -> Self {
         Self {
             committees: RwLock::new(HashMap::new()),
             distributed,
-            _phantom: PhantomData,
         }
     }
 
@@ -103,7 +100,7 @@ impl<E: EthSpec> SyncDutiesMap<E> {
     }
 
     /// Number of slots in advance to compute selection proofs
-    fn aggregation_pre_compute_slots(&self) -> u64 {
+    fn aggregation_pre_compute_slots<E: EthSpec>(&self) -> u64 {
         if self.distributed {
             AGGREGATION_PRE_COMPUTE_SLOTS_DISTRIBUTED
         } else {
@@ -116,7 +113,7 @@ impl<E: EthSpec> SyncDutiesMap<E> {
     /// Return the slot up to which proofs should be pre-computed, as well as a vec of
     /// `(previous_pre_compute_slot, sync_duty)` pairs for all validators which need to have proofs
     /// computed. See `fill_in_aggregation_proofs` for the actual calculation.
-    fn prepare_for_aggregator_pre_compute(
+    fn prepare_for_aggregator_pre_compute<E: EthSpec>(
         &self,
         committee_period: u64,
         current_slot: Slot,
@@ -126,7 +123,7 @@ impl<E: EthSpec> SyncDutiesMap<E> {
             current_slot,
             first_slot_of_period::<E>(committee_period, spec),
         );
-        let pre_compute_lookahead_slots = self.aggregation_pre_compute_slots();
+        let pre_compute_lookahead_slots = self.aggregation_pre_compute_slots::<E>();
         let pre_compute_slot = std::cmp::min(
             current_slot + pre_compute_lookahead_slots,
             last_slot_of_period::<E>(committee_period, spec),
@@ -186,7 +183,7 @@ impl<E: EthSpec> SyncDutiesMap<E> {
     /// Get duties for all validators for the given `wall_clock_slot`.
     ///
     /// This is the entry-point for the sync committee service.
-    pub fn get_duties_for_slot(
+    pub fn get_duties_for_slot<E: EthSpec>(
         &self,
         wall_clock_slot: Slot,
         spec: &ChainSpec,
@@ -328,7 +325,7 @@ pub async fn poll_sync_committee_duties<T: SlotClock + 'static, E: EthSpec>(
 
     // If duties aren't known for the current period, poll for them.
     if !sync_duties.all_duties_known(current_sync_committee_period, &local_indices) {
-        poll_sync_committee_duties_for_period(
+        poll_sync_committee_duties_for_period::<_, E>(
             duties_service,
             &local_indices,
             current_sync_committee_period,
@@ -341,7 +338,7 @@ pub async fn poll_sync_committee_duties<T: SlotClock + 'static, E: EthSpec>(
 
     // Pre-compute aggregator selection proofs for the current period.
     let (current_pre_compute_slot, new_pre_compute_duties) = sync_duties
-        .prepare_for_aggregator_pre_compute(current_sync_committee_period, current_slot, spec);
+        .prepare_for_aggregator_pre_compute::<E>(current_sync_committee_period, current_slot, spec);
 
     if !new_pre_compute_duties.is_empty() {
         let sub_duties_service = duties_service.clone();
@@ -378,14 +375,18 @@ pub async fn poll_sync_committee_duties<T: SlotClock + 'static, E: EthSpec>(
     }
 
     // Pre-compute aggregator selection proofs for the next period.
-    let aggregate_pre_compute_lookahead_slots = sync_duties.aggregation_pre_compute_slots();
+    let aggregate_pre_compute_lookahead_slots = sync_duties.aggregation_pre_compute_slots::<E>();
     if (current_slot + aggregate_pre_compute_lookahead_slots)
         .epoch(E::slots_per_epoch())
         .sync_committee_period(spec)?
         == next_sync_committee_period
     {
         let (pre_compute_slot, new_pre_compute_duties) = sync_duties
-            .prepare_for_aggregator_pre_compute(next_sync_committee_period, current_slot, spec);
+            .prepare_for_aggregator_pre_compute::<E>(
+                next_sync_committee_period,
+                current_slot,
+                spec,
+            );
 
         if !new_pre_compute_duties.is_empty() {
             let sub_duties_service = duties_service.clone();

validator_client/validator_services/src/sync_committee_service.rs

@@ -158,7 +158,7 @@ impl<T: SlotClock + 'static, E: EthSpec> SyncCommitteeService<T, E> {
         let Some(slot_duties) = self
             .duties_service
             .sync_duties
-            .get_duties_for_slot(slot, &self.duties_service.spec)
+            .get_duties_for_slot::<E>(slot, &self.duties_service.spec)
         else {
             debug!(log, "No duties known for slot {}", slot);
             return Ok(());
@@ -530,7 +530,7 @@ impl<T: SlotClock + 'static, E: EthSpec> SyncCommitteeService<T, E> {
             match self
                 .duties_service
                 .sync_duties
-                .get_duties_for_slot(duty_slot, spec)
+                .get_duties_for_slot::<E>(duty_slot, spec)
             {
                 Some(duties) => subscriptions.extend(subscriptions_from_sync_duties(
                     duties.duties,