Remove E from validator_client types where it's not required

testing/web3signer_tests/src/lib.rs

@@ -309,7 +309,7 @@ mod tests {
 
     /// A testing rig which holds a `ValidatorStore`.
     struct ValidatorStoreRig {
-        validator_store: Arc<ValidatorStore<TestingSlotClock, E>>,
+        validator_store: Arc<ValidatorStore<TestingSlotClock>>,
         _validator_dir: TempDir,
         runtime: Arc<tokio::runtime::Runtime>,
         _runtime_shutdown: async_channel::Sender<()>,
@@ -363,7 +363,7 @@ mod tests {
                 ..Default::default()
             };
 
-            let validator_store = ValidatorStore::<_, E>::new(
+            let validator_store = ValidatorStore::<_>::new(
                 initialized_validators,
                 slashing_protection,
                 Hash256::repeat_byte(42),
@@ -372,6 +372,7 @@ mod tests {
                 slot_clock,
                 &config,
                 executor,
+                E::slots_per_epoch(),
                 log.clone(),
             );
 
@@ -488,7 +489,7 @@ mod tests {
             generate_sig: F,
         ) -> Self
         where
-            F: Fn(PublicKeyBytes, Arc<ValidatorStore<TestingSlotClock, E>>) -> R,
+            F: Fn(PublicKeyBytes, Arc<ValidatorStore<TestingSlotClock>>) -> R,
             R: Future<Output = S>,
             // We use the `SignedObject` trait to white-list objects for comparison. This avoids
             // accidentally comparing something meaningless like a `()`.
@@ -523,7 +524,7 @@ mod tests {
             web3signer_should_sign: bool,
         ) -> Self
         where
-            F: Fn(PublicKeyBytes, Arc<ValidatorStore<TestingSlotClock, E>>) -> R,
+            F: Fn(PublicKeyBytes, Arc<ValidatorStore<TestingSlotClock>>) -> R,
             R: Future<Output = Result<(), ValidatorStoreError>>,
         {
             for validator_rig in &self.validator_rigs {
@@ -590,7 +591,7 @@ mod tests {
         .await
         .assert_signatures_match("randao_reveal", |pubkey, validator_store| async move {
             validator_store
-                .randao_reveal(pubkey, Epoch::new(0))
+                .randao_reveal::<E>(pubkey, Epoch::new(0))
                 .await
                 .unwrap()
         })
@@ -631,7 +632,7 @@ mod tests {
         .await
         .assert_signatures_match("selection_proof", |pubkey, validator_store| async move {
             validator_store
-                .produce_selection_proof(pubkey, Slot::new(0))
+                .produce_selection_proof::<E>(pubkey, Slot::new(0))
                 .await
                 .unwrap()
         })
@@ -641,7 +642,7 @@ mod tests {
             |pubkey, validator_store| async move {
                 let val_reg_data = get_validator_registration(pubkey);
                 validator_store
-                    .sign_validator_registration_data(val_reg_data)
+                    .sign_validator_registration_data::<E>(val_reg_data)
                     .await
                     .unwrap()
             },
@@ -681,7 +682,11 @@ mod tests {
             "sync_selection_proof",
             |pubkey, validator_store| async move {
                 validator_store
-                    .produce_sync_selection_proof(&pubkey, altair_fork_slot, SyncSubnetId::from(0))
+                    .produce_sync_selection_proof::<E>(
+                        &pubkey,
+                        altair_fork_slot,
+                        SyncSubnetId::from(0),
+                    )
                     .await
                     .unwrap()
             },
@@ -691,7 +696,12 @@ mod tests {
             "sync_committee_signature",
             |pubkey, validator_store| async move {
                 validator_store
-                    .produce_sync_committee_signature(altair_fork_slot, Hash256::zero(), 0, &pubkey)
+                    .produce_sync_committee_signature::<E>(
+                        altair_fork_slot,
+                        Hash256::zero(),
+                        0,
+                        &pubkey,
+                    )
                     .await
                     .unwrap()
             },
@@ -724,7 +734,7 @@ mod tests {
             |pubkey, validator_store| async move {
                 let val_reg_data = get_validator_registration(pubkey);
                 validator_store
-                    .sign_validator_registration_data(val_reg_data)
+                    .sign_validator_registration_data::<E>(val_reg_data)
                     .await
                     .unwrap()
             },

validator_client/beacon_node_fallback/src/lib.rs

@@ -17,7 +17,6 @@ use std::cmp::Ordering;
 use std::fmt;
 use std::fmt::Debug;
 use std::future::Future;
-use std::marker::PhantomData;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use strum::{EnumString, EnumVariantNames};
@@ -60,7 +59,7 @@ pub struct LatencyMeasurement {
 /// See `SLOT_LOOKAHEAD` for information about when this should run.
 pub fn start_fallback_updater_service<T: SlotClock + 'static, E: EthSpec>(
     context: RuntimeContext<E>,
-    beacon_nodes: Arc<BeaconNodeFallback<T, E>>,
+    beacon_nodes: Arc<BeaconNodeFallback<T>>,
 ) -> Result<(), &'static str> {
     let executor = context.executor;
     if beacon_nodes.slot_clock.is_none() {
@@ -69,7 +68,7 @@ pub fn start_fallback_updater_service<T: SlotClock + 'static, E: EthSpec>(
 
     let future = async move {
         loop {
-            beacon_nodes.update_all_candidates().await;
+            beacon_nodes.update_all_candidates::<E>().await;
 
             let sleep_time = beacon_nodes
                 .slot_clock
@@ -184,29 +183,27 @@ impl Serialize for CandidateInfo {
 /// Represents a `BeaconNodeHttpClient` inside a `BeaconNodeFallback` that may or may not be used
 /// for a query.
 #[derive(Clone, Debug)]
-pub struct CandidateBeaconNode<E> {
+pub struct CandidateBeaconNode {
     pub index: usize,
     pub beacon_node: BeaconNodeHttpClient,
     pub health: Arc<RwLock<Result<BeaconNodeHealth, CandidateError>>>,
-    _phantom: PhantomData<E>,
 }
 
-impl<E: EthSpec> PartialEq for CandidateBeaconNode<E> {
+impl PartialEq for CandidateBeaconNode {
     fn eq(&self, other: &Self) -> bool {
         self.index == other.index && self.beacon_node == other.beacon_node
     }
 }
 
-impl<E: EthSpec> Eq for CandidateBeaconNode<E> {}
+impl Eq for CandidateBeaconNode {}
 
-impl<E: EthSpec> CandidateBeaconNode<E> {
+impl CandidateBeaconNode {
     /// Instantiate a new node.
     pub fn new(beacon_node: BeaconNodeHttpClient, index: usize) -> Self {
         Self {
             index,
             beacon_node,
             health: Arc::new(RwLock::new(Err(CandidateError::Uninitialized))),
-            _phantom: PhantomData,
         }
     }
 
@@ -215,14 +212,14 @@ impl<E: EthSpec> CandidateBeaconNode<E> {
         *self.health.read().await
     }
 
-    pub async fn refresh_health<T: SlotClock>(
+    pub async fn refresh_health<E: EthSpec, T: SlotClock>(
         &self,
         distance_tiers: &BeaconNodeSyncDistanceTiers,
         slot_clock: Option<&T>,
         spec: &ChainSpec,
         log: &Logger,
     ) -> Result<(), CandidateError> {
-        if let Err(e) = self.is_compatible(spec, log).await {
+        if let Err(e) = self.is_compatible::<E>(spec, log).await {
             *self.health.write().await = Err(e);
             return Err(e);
         }
@@ -286,7 +283,11 @@ impl<E: EthSpec> CandidateBeaconNode<E> {
     }
 
     /// Checks if the node has the correct specification.
-    async fn is_compatible(&self, spec: &ChainSpec, log: &Logger) -> Result<(), CandidateError> {
+    async fn is_compatible<E: EthSpec>(
+        &self,
+        spec: &ChainSpec,
+        log: &Logger,
+    ) -> Result<(), CandidateError> {
         let config = self
             .beacon_node
             .get_config_spec::<ConfigSpec>()
@@ -371,18 +372,18 @@ impl<E: EthSpec> CandidateBeaconNode<E> {
 /// behaviour, where the failure of one candidate results in the next candidate receiving an
 /// identical query.
 #[derive(Clone, Debug)]
-pub struct BeaconNodeFallback<T, E> {
-    pub candidates: Arc<RwLock<Vec<CandidateBeaconNode<E>>>>,
+pub struct BeaconNodeFallback<T> {
+    pub candidates: Arc<RwLock<Vec<CandidateBeaconNode>>>,
     distance_tiers: BeaconNodeSyncDistanceTiers,
     slot_clock: Option<T>,
     broadcast_topics: Vec<ApiTopic>,
     spec: Arc<ChainSpec>,
     log: Logger,
 }
 
-impl<T: SlotClock, E: EthSpec> BeaconNodeFallback<T, E> {
+impl<T: SlotClock> BeaconNodeFallback<T> {
     pub fn new(
-        candidates: Vec<CandidateBeaconNode<E>>,
+        candidates: Vec<CandidateBeaconNode>,
         config: Config,
         broadcast_topics: Vec<ApiTopic>,
         spec: Arc<ChainSpec>,
@@ -466,15 +467,15 @@ impl<T: SlotClock, E: EthSpec> BeaconNodeFallback<T, E> {
     /// It is possible for a node to return an unsynced status while continuing to serve
     /// low quality responses. To route around this it's best to poll all connected beacon nodes.
     /// A previous implementation of this function polled only the unavailable BNs.
-    pub async fn update_all_candidates(&self) {
+    pub async fn update_all_candidates<E: EthSpec>(&self) {
         // Clone the vec, so we release the read lock immediately.
         // `candidate.health` is behind an Arc<RwLock>, so this would still allow us to mutate the values.
         let candidates = self.candidates.read().await.clone();
         let mut futures = Vec::with_capacity(candidates.len());
         let mut nodes = Vec::with_capacity(candidates.len());
 
         for candidate in candidates.iter() {
-            futures.push(candidate.refresh_health(
+            futures.push(candidate.refresh_health::<E, T>(
                 &self.distance_tiers,
                 self.slot_clock.as_ref(),
                 &self.spec,
@@ -693,7 +694,7 @@ impl<T: SlotClock, E: EthSpec> BeaconNodeFallback<T, E> {
 }
 
 /// Helper functions to allow sorting candidate nodes by health.
-async fn sort_nodes_by_health<E: EthSpec>(nodes: &mut Vec<CandidateBeaconNode<E>>) {
+async fn sort_nodes_by_health(nodes: &mut Vec<CandidateBeaconNode>) {
     // Fetch all health values.
     let health_results: Vec<Result<BeaconNodeHealth, CandidateError>> =
         future::join_all(nodes.iter().map(|node| node.health())).await;
@@ -711,7 +712,7 @@ async fn sort_nodes_by_health<E: EthSpec>(nodes: &mut Vec<CandidateBeaconNode<E>
     });
 
     // Reorder candidates based on the sorted indices.
-    let sorted_nodes: Vec<CandidateBeaconNode<E>> = indices_with_health
+    let sorted_nodes: Vec<CandidateBeaconNode> = indices_with_health
         .into_iter()
         .map(|(index, _)| nodes[index].clone())
         .collect();
@@ -743,9 +744,7 @@ mod tests {
     use eth2::Timeouts;
     use std::str::FromStr;
     use strum::VariantNames;
-    use types::{MainnetEthSpec, Slot};
-
-    type E = MainnetEthSpec;
+    use types::Slot;
 
     #[test]
     fn api_topic_all() {
@@ -764,7 +763,7 @@ mod tests {
         let optimistic_status = IsOptimistic::No;
         let execution_status = ExecutionEngineHealth::Healthy;
 
-        fn new_candidate(index: usize) -> CandidateBeaconNode<E> {
+        fn new_candidate(index: usize) -> CandidateBeaconNode {
             let beacon_node = BeaconNodeHttpClient::new(
                 SensitiveUrl::parse(&format!("http://example_{index}.com")).unwrap(),
                 Timeouts::set_all(Duration::from_secs(index as u64)),

validator_client/doppelganger_service/src/lib.rs

@@ -162,8 +162,8 @@ impl DoppelgangerState {
 /// If the BN fails to respond to either of these requests, simply return an empty response.
 /// This behaviour is to help prevent spurious failures on the BN from needlessly preventing
 /// doppelganger progression.
-async fn beacon_node_liveness<'a, T: 'static + SlotClock, E: EthSpec>(
-    beacon_nodes: Arc<BeaconNodeFallback<T, E>>,
+async fn beacon_node_liveness<'a, T: 'static + SlotClock>(
+    beacon_nodes: Arc<BeaconNodeFallback<T>>,
     log: Logger,
     current_epoch: Epoch,
     validator_indices: Vec<u64>,
@@ -290,7 +290,7 @@ impl DoppelgangerService {
         service: Arc<Self>,
         context: RuntimeContext<E>,
         validator_store: Arc<V>,
-        beacon_nodes: Arc<BeaconNodeFallback<T, E>>,
+        beacon_nodes: Arc<BeaconNodeFallback<T>>,
         slot_clock: T,
     ) -> Result<(), String>
     where
@@ -400,7 +400,7 @@ impl DoppelgangerService {
     ///
     /// Validators added during the genesis epoch will not have doppelganger protection applied to
     /// them.
-    pub fn register_new_validator<E: EthSpec, T: SlotClock>(
+    pub fn register_new_validator<T: SlotClock, E: EthSpec>(
         &self,
         validator: PublicKeyBytes,
         slot_clock: &T,
@@ -805,7 +805,7 @@ mod test {
                 .expect("index should exist");
 
             self.doppelganger
-                .register_new_validator::<E, _>(pubkey, &self.slot_clock)
+                .register_new_validator::<_, E>(pubkey, &self.slot_clock)
                 .unwrap();
             self.doppelganger
                 .doppelganger_states

validator_client/http_api/src/create_signed_voluntary_exit.rs

@@ -9,7 +9,7 @@ use validator_store::ValidatorStore;
 pub async fn create_signed_voluntary_exit<T: 'static + SlotClock + Clone, E: EthSpec>(
     pubkey: PublicKey,
     maybe_epoch: Option<Epoch>,
-    validator_store: Arc<ValidatorStore<T, E>>,
+    validator_store: Arc<ValidatorStore<T>>,
     slot_clock: T,
     log: Logger,
 ) -> Result<GenericResponse<SignedVoluntaryExit>, warp::Rejection> {
@@ -52,7 +52,7 @@ pub async fn create_signed_voluntary_exit<T: 'static + SlotClock + Clone, E: Eth
     );
 
     let signed_voluntary_exit = validator_store
-        .sign_voluntary_exit(pubkey_bytes, voluntary_exit)
+        .sign_voluntary_exit::<E>(pubkey_bytes, voluntary_exit)
         .await
         .map_err(|e| {
             warp_utils::reject::custom_server_error(format!(

validator_client/http_api/src/create_validator.rs

@@ -7,8 +7,7 @@ use account_utils::{
 use eth2::lighthouse_vc::types::{self as api_types};
 use slot_clock::SlotClock;
 use std::path::{Path, PathBuf};
-use types::ChainSpec;
-use types::EthSpec;
+use types::{ChainSpec, EthSpec};
 use validator_dir::{keystore_password_path, Builder as ValidatorDirBuilder};
 use validator_store::ValidatorStore;
 use zeroize::Zeroizing;
@@ -30,7 +29,7 @@ pub async fn create_validators_mnemonic<P: AsRef<Path>, T: 'static + SlotClock,
     validator_requests: &[api_types::ValidatorRequest],
     validator_dir: P,
     secrets_dir: Option<PathBuf>,
-    validator_store: &ValidatorStore<T, E>,
+    validator_store: &ValidatorStore<T>,
     spec: &ChainSpec,
 ) -> Result<(Vec<api_types::CreatedValidator>, Mnemonic), warp::Rejection> {
     let mnemonic = mnemonic_opt.unwrap_or_else(random_mnemonic);
@@ -141,7 +140,7 @@ pub async fn create_validators_mnemonic<P: AsRef<Path>, T: 'static + SlotClock,
         drop(validator_dir);
 
         validator_store
-            .add_validator_keystore(
+            .add_validator_keystore::<_, E>(
                 voting_keystore_path,
                 voting_password_storage,
                 request.enable,
@@ -178,11 +177,11 @@ pub async fn create_validators_mnemonic<P: AsRef<Path>, T: 'static + SlotClock,
 
 pub async fn create_validators_web3signer<T: 'static + SlotClock, E: EthSpec>(
     validators: Vec<ValidatorDefinition>,
-    validator_store: &ValidatorStore<T, E>,
+    validator_store: &ValidatorStore<T>,
 ) -> Result<(), warp::Rejection> {
     for validator in validators {
         validator_store
-            .add_validator(validator)
+            .add_validator::<E>(validator)
             .await
             .map_err(|e| {
                 warp_utils::reject::custom_server_error(format!(