Use E for EthSpec globally (#5264)

* Use `E` for `EthSpec` globally

* Fix tests

* Merge branch 'unstable' into e-ethspec

* Merge branch 'unstable' into e-ethspec

# Conflicts:
#	beacon_node/execution_layer/src/engine_api.rs
#	beacon_node/execution_layer/src/engine_api/http.rs
#	beacon_node/execution_layer/src/engine_api/json_structures.rs
#	beacon_node/execution_layer/src/test_utils/handle_rpc.rs
#	beacon_node/store/src/partial_beacon_state.rs
#	consensus/types/src/beacon_block.rs
#	consensus/types/src/beacon_block_body.rs
#	consensus/types/src/beacon_state.rs
#	consensus/types/src/config_and_preset.rs
#	consensus/types/src/execution_payload.rs
#	consensus/types/src/execution_payload_header.rs
#	consensus/types/src/light_client_optimistic_update.rs
#	consensus/types/src/payload.rs
#	lcli/src/parse_ssz.rs

testing/ef_tests/src/case_result.rs

@@ -32,9 +32,9 @@ impl CaseResult {
 
 /// Same as `compare_result_detailed`, however it drops the caches on both states before
 /// comparison.
-pub fn compare_beacon_state_results_without_caches<T: EthSpec, E: Debug>(
-    result: &mut Result<BeaconState<T>, E>,
-    expected: &mut Option<BeaconState<T>>,
+pub fn compare_beacon_state_results_without_caches<E: EthSpec, T: Debug>(
+    result: &mut Result<BeaconState<E>, T>,
+    expected: &mut Option<BeaconState<E>>,
 ) -> Result<(), Error> {
     if let (Ok(ref mut result), Some(ref mut expected)) = (result.as_mut(), expected.as_mut()) {
         result.drop_all_caches().unwrap();
@@ -46,13 +46,13 @@ pub fn compare_beacon_state_results_without_caches<T: EthSpec, E: Debug>(
 
 /// Same as `compare_result`, however utilizes the `CompareFields` trait to give a list of
 /// mismatching fields when `Ok(result) != Some(expected)`.
-pub fn compare_result_detailed<T, E>(
-    result: &Result<T, E>,
+pub fn compare_result_detailed<T, U>(
+    result: &Result<T, U>,
     expected: &Option<T>,
 ) -> Result<(), Error>
 where
     T: PartialEq<T> + Debug + CompareFields,
-    E: Debug,
+    U: Debug,
 {
     match (result, expected) {
         (Ok(result), Some(expected)) => {
@@ -84,10 +84,10 @@ where
 ///
 /// If `expected.is_none()` then `result` is expected to be `Err`. Otherwise, `T` in `result` and
 /// `expected` must be equal.
-pub fn compare_result<T, E>(result: &Result<T, E>, expected: &Option<T>) -> Result<(), Error>
+pub fn compare_result<T, U>(result: &Result<T, U>, expected: &Option<T>) -> Result<(), Error>
 where
     T: PartialEq<T> + Debug,
-    E: Debug,
+    U: Debug,
 {
     match (result, expected) {
         // Pass: The should have failed and did fail.

testing/ef_tests/src/cases/operations.rs

@@ -38,8 +38,8 @@ struct ExecutionMetadata {
 
 /// Newtype for testing withdrawals.
 #[derive(Debug, Clone, Deserialize)]
-pub struct WithdrawalsPayload<T: EthSpec> {
-    payload: FullPayload<T>,
+pub struct WithdrawalsPayload<E: EthSpec> {
+    payload: FullPayload<E>,
 }
 
 #[derive(Debug, Clone)]

testing/ef_tests/src/cases/shuffling.rs

@@ -6,26 +6,26 @@ use std::marker::PhantomData;
 use swap_or_not_shuffle::{compute_shuffled_index, shuffle_list};
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct Shuffling<T> {
+pub struct Shuffling<E> {
     pub seed: String,
     pub count: usize,
     pub mapping: Vec<usize>,
     #[serde(skip)]
-    _phantom: PhantomData<T>,
+    _phantom: PhantomData<E>,
 }
 
-impl<T: EthSpec> LoadCase for Shuffling<T> {
+impl<E: EthSpec> LoadCase for Shuffling<E> {
     fn load_from_dir(path: &Path, _fork_name: ForkName) -> Result<Self, Error> {
         yaml_decode_file(&path.join("mapping.yaml"))
     }
 }
 
-impl<T: EthSpec> Case for Shuffling<T> {
+impl<E: EthSpec> Case for Shuffling<E> {
     fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
         if self.count == 0 {
             compare_result::<_, Error>(&Ok(vec![]), &Some(self.mapping.clone()))?;
         } else {
-            let spec = T::default_spec();
+            let spec = E::default_spec();
             let seed = hex::decode(&self.seed[2..])
                 .map_err(|e| Error::FailedToParseTest(format!("{:?}", e)))?;
 

testing/execution_engine_integration/src/test_rig.rs

@@ -24,23 +24,23 @@ const EXECUTION_ENGINE_START_TIMEOUT: Duration = Duration::from_secs(60);
 
 const TEST_FORK: ForkName = ForkName::Capella;
 
-struct ExecutionPair<E, T: EthSpec> {
+struct ExecutionPair<Engine, E: EthSpec> {
     /// The Lighthouse `ExecutionLayer` struct, connected to the `execution_engine` via HTTP.
-    execution_layer: ExecutionLayer<T>,
+    execution_layer: ExecutionLayer<E>,
     /// A handle to external EE process, once this is dropped the process will be killed.
     #[allow(dead_code)]
-    execution_engine: ExecutionEngine<E>,
+    execution_engine: ExecutionEngine<Engine>,
 }
 
 /// A rig that holds two EE processes for testing.
 ///
 /// There are two EEs held here so that we can test out-of-order application of payloads, and other
 /// edge-cases.
-pub struct TestRig<E, T: EthSpec = MainnetEthSpec> {
+pub struct TestRig<Engine, E: EthSpec = MainnetEthSpec> {
     #[allow(dead_code)]
     runtime: Arc<tokio::runtime::Runtime>,
-    ee_a: ExecutionPair<E, T>,
-    ee_b: ExecutionPair<E, T>,
+    ee_a: ExecutionPair<Engine, E>,
+    ee_b: ExecutionPair<Engine, E>,
     spec: ChainSpec,
     _runtime_shutdown: async_channel::Sender<()>,
 }
@@ -102,8 +102,8 @@ async fn import_and_unlock(http_url: SensitiveUrl, priv_keys: &[&str], password:
     }
 }
 
-impl<E: GenericExecutionEngine> TestRig<E> {
-    pub fn new(generic_engine: E) -> Self {
+impl<Engine: GenericExecutionEngine> TestRig<Engine> {
+    pub fn new(generic_engine: Engine) -> Self {
         let log = logging::test_logger();
         let runtime = Arc::new(
             tokio::runtime::Builder::new_multi_thread()

testing/node_test_rig/src/lib.rs

@@ -181,8 +181,8 @@ impl ValidatorFiles {
 /// is _local_ to this process).
 ///
 /// Intended for use in testing and simulation. Not for production.
-pub struct LocalValidatorClient<T: EthSpec> {
-    pub client: ProductionValidatorClient<T>,
+pub struct LocalValidatorClient<E: EthSpec> {
+    pub client: ProductionValidatorClient<E>,
     pub files: ValidatorFiles,
 }
 

testing/simulator/src/retry.rs

@@ -4,10 +4,10 @@ use std::pin::Pin;
 
 /// Executes the function with a specified number of retries if the function returns an error.
 /// Once it exceeds `max_retries` and still fails, the error is returned.
-pub async fn with_retry<T, E, F>(max_retries: usize, mut func: F) -> Result<T, E>
+pub async fn with_retry<T, U, F>(max_retries: usize, mut func: F) -> Result<T, U>
 where
-    F: FnMut() -> Pin<Box<dyn Future<Output = Result<T, E>>>>,
-    E: Debug,
+    F: FnMut() -> Pin<Box<dyn Future<Output = Result<T, U>>>>,
+    U: Debug,
 {
     let mut retry_count = 0;
     loop {