Capella eip 4844 cleanup (#3652)

* add capella gossip boiler plate

* get everything compiling

Co-authored-by: realbigsean <sean@sigmaprime.io
Co-authored-by: Mark Mackey <mark@sigmaprime.io>

* small cleanup

* small cleanup

* cargo fix + some test cleanup

* improve block production

* add fixme for potential panic

Co-authored-by: Mark Mackey <mark@sigmaprime.io>

testing/ef_tests/src/cases/common.rs

@@ -78,6 +78,7 @@ pub fn previous_fork(fork_name: ForkName) -> ForkName {
         ForkName::Base => ForkName::Base,
         ForkName::Altair => ForkName::Base,
         ForkName::Merge => ForkName::Altair, // TODO: Check this when tests are released..
-        ForkName::Eip4844 => ForkName::Merge, // TODO: Check this when tests are released..
+        ForkName::Capella => ForkName::Merge, // TODO: Check this when tests are released..
+        ForkName::Eip4844 => ForkName::Capella, // TODO: Check this when tests are released..
     }
 }

testing/ef_tests/src/cases/epoch_processing.rs

@@ -97,7 +97,10 @@ impl<E: EthSpec> EpochTransition<E> for JustificationAndFinalization {
                 justification_and_finalization_state.apply_changes_to_state(state);
                 Ok(())
             }
-            BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Eip4844(_) => {
+            BeaconState::Altair(_)
+            | BeaconState::Merge(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Eip4844(_) => {
                 let justification_and_finalization_state =
                     altair::process_justification_and_finalization(
                         state,
@@ -118,13 +121,14 @@ impl<E: EthSpec> EpochTransition<E> for RewardsAndPenalties {
                 validator_statuses.process_attestations(state)?;
                 base::process_rewards_and_penalties(state, &mut validator_statuses, spec)
             }
-            BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Eip4844(_) => {
-                altair::process_rewards_and_penalties(
-                    state,
-                    &altair::ParticipationCache::new(state, spec).unwrap(),
-                    spec,
-                )
-            }
+            BeaconState::Altair(_)
+            | BeaconState::Merge(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Eip4844(_) => altair::process_rewards_and_penalties(
+                state,
+                &altair::ParticipationCache::new(state, spec).unwrap(),
+                spec,
+            ),
         }
     }
 }
@@ -147,7 +151,10 @@ impl<E: EthSpec> EpochTransition<E> for Slashings {
                     spec,
                 )?;
             }
-            BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Eip4844(_) => {
+            BeaconState::Altair(_)
+            | BeaconState::Merge(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Eip4844(_) => {
                 process_slashings(
                     state,
                     altair::ParticipationCache::new(state, spec)
@@ -205,9 +212,10 @@ impl<E: EthSpec> EpochTransition<E> for SyncCommitteeUpdates {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
         match state {
             BeaconState::Base(_) => Ok(()),
-            BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Eip4844(_) => {
-                altair::process_sync_committee_updates(state, spec)
-            }
+            BeaconState::Altair(_)
+            | BeaconState::Merge(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Eip4844(_) => altair::process_sync_committee_updates(state, spec),
         }
     }
 }
@@ -216,13 +224,14 @@ impl<E: EthSpec> EpochTransition<E> for InactivityUpdates {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
         match state {
             BeaconState::Base(_) => Ok(()),
-            BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Eip4844(_) => {
-                altair::process_inactivity_updates(
-                    state,
-                    &altair::ParticipationCache::new(state, spec).unwrap(),
-                    spec,
-                )
-            }
+            BeaconState::Altair(_)
+            | BeaconState::Merge(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Eip4844(_) => altair::process_inactivity_updates(
+                state,
+                &altair::ParticipationCache::new(state, spec).unwrap(),
+                spec,
+            ),
         }
     }
 }
@@ -231,9 +240,10 @@ impl<E: EthSpec> EpochTransition<E> for ParticipationFlagUpdates {
     fn run(state: &mut BeaconState<E>, _: &ChainSpec) -> Result<(), EpochProcessingError> {
         match state {
             BeaconState::Base(_) => Ok(()),
-            BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Eip4844(_) => {
-                altair::process_participation_flag_updates(state)
-            }
+            BeaconState::Altair(_)
+            | BeaconState::Merge(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Eip4844(_) => altair::process_participation_flag_updates(state),
         }
     }
 }
@@ -280,6 +290,7 @@ impl<E: EthSpec, T: EpochTransition<E>> Case for EpochProcessing<E, T> {
             }
             // No phase0 tests for Altair and later.
             ForkName::Altair | ForkName::Merge => T::name() != "participation_record_updates",
+            ForkName::Capella => false, // TODO: revisit when tests are out
             ForkName::Eip4844 => false, // TODO: revisit when tests are out
         }
     }

testing/ef_tests/src/cases/fork.rs

@@ -62,6 +62,7 @@ impl<E: EthSpec> Case for ForkTest<E> {
             ForkName::Altair => upgrade_to_altair(&mut result_state, spec).map(|_| result_state),
             ForkName::Merge => upgrade_to_bellatrix(&mut result_state, spec).map(|_| result_state),
             ForkName::Eip4844 => panic!("eip4844 not supported"),
+            ForkName::Capella => panic!("capella not supported"),
         };
 
         compare_beacon_state_results_without_caches(&mut result, &mut expected)

testing/ef_tests/src/cases/genesis_initialization.rs

@@ -4,7 +4,10 @@ use crate::decode::{ssz_decode_file, ssz_decode_state, yaml_decode_file};
 use serde_derive::Deserialize;
 use state_processing::initialize_beacon_state_from_eth1;
 use std::path::PathBuf;
-use types::{BeaconState, Deposit, EthSpec, ExecutionPayloadHeader, ForkName, Hash256};
+use types::{
+    BeaconState, Deposit, EthSpec, ExecutionPayloadHeader, ExecutionPayloadHeaderMerge, ForkName,
+    Hash256,
+};
 
 #[derive(Debug, Clone, Deserialize)]
 struct Metadata {
@@ -38,9 +41,14 @@ impl<E: EthSpec> LoadCase for GenesisInitialization<E> {
         let meta: Metadata = yaml_decode_file(&path.join("meta.yaml"))?;
         let execution_payload_header: Option<ExecutionPayloadHeader<E>> =
             if meta.execution_payload_header.unwrap_or(false) {
-                Some(ssz_decode_file(
+                //FIXME(sean) we could decode based on timestamp - we probably don't do decode a payload
+                // without a block this elsewhere at presetn. But when we support SSZ in the builder api we may need to.
+                // Although that API should include fork info. Hardcoding this for now
+                Some(ExecutionPayloadHeader::Merge(ssz_decode_file::<
+                    ExecutionPayloadHeaderMerge<E>,
+                >(
                     &path.join("execution_payload_header.ssz_snappy"),
-                )?)
+                )?))
             } else {
                 None
             };

testing/ef_tests/src/cases/operations.rs

@@ -5,6 +5,7 @@ use crate::decode::{ssz_decode_file, ssz_decode_file_with, ssz_decode_state, yam
 use crate::testing_spec;
 use crate::type_name::TypeName;
 use serde_derive::Deserialize;
+use ssz::Decode;
 use state_processing::per_block_processing::{
     errors::BlockProcessingError,
     process_block_header, process_execution_payload,
@@ -18,8 +19,8 @@ use std::fmt::Debug;
 use std::path::Path;
 use types::{
     Attestation, AttesterSlashing, BeaconBlock, BeaconState, BlindedPayload, ChainSpec, Deposit,
-    EthSpec, ExecutionPayload, ForkName, FullPayload, ProposerSlashing, SignedVoluntaryExit,
-    SyncAggregate,
+    EthSpec, ExecutionPayload, ExecutionPayloadMerge, ForkName, FullPayload, ProposerSlashing,
+    SignedVoluntaryExit, SyncAggregate,
 };
 
 #[derive(Debug, Clone, Default, Deserialize)]
@@ -81,16 +82,17 @@ impl<E: EthSpec> Operation<E> for Attestation<E> {
             BeaconState::Base(_) => {
                 base::process_attestations(state, &[self.clone()], VerifySignatures::True, spec)
             }
-            BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Eip4844(_) => {
-                altair::process_attestation(
-                    state,
-                    self,
-                    0,
-                    proposer_index,
-                    VerifySignatures::True,
-                    spec,
-                )
-            }
+            BeaconState::Altair(_)
+            | BeaconState::Merge(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Eip4844(_) => altair::process_attestation(
+                state,
+                self,
+                0,
+                proposer_index,
+                VerifySignatures::True,
+                spec,
+            ),
         }
     }
 }
@@ -237,8 +239,13 @@ impl<E: EthSpec> Operation<E> for FullPayload<E> {
         fork_name != ForkName::Base && fork_name != ForkName::Altair
     }
 
+    //FIXME(sean) we could decode based on timestamp - we probably don't do decode a payload
+    // without a block this elsewhere at presetn. But when we support SSZ in the builder api we may need to.
+    // Although that API should include fork info. Hardcoding this for now
     fn decode(path: &Path, _spec: &ChainSpec) -> Result<Self, Error> {
-        ssz_decode_file(path)
+        ssz_decode_file::<ExecutionPayloadMerge<E>>(path)
+            .map(ExecutionPayload::Merge)
+            .map(Into::into)
     }
 
     fn apply_to(
@@ -252,7 +259,7 @@ impl<E: EthSpec> Operation<E> for FullPayload<E> {
             .as_ref()
             .map_or(false, |e| e.execution_valid);
         if valid {
-            process_execution_payload(state, self, spec)
+            process_execution_payload::<E, FullPayload<E>>(state, self.to_ref(), spec)
         } else {
             Err(BlockProcessingError::ExecutionInvalid)
         }
@@ -272,7 +279,12 @@ impl<E: EthSpec> Operation<E> for BlindedPayload<E> {
     }
 
     fn decode(path: &Path, _spec: &ChainSpec) -> Result<Self, Error> {
-        ssz_decode_file::<ExecutionPayload<E>>(path).map(Into::into)
+        //FIXME(sean) we could decode based on timestamp - we probably don't do decode a payload
+        // without a block this elsewhere at presetn. But when we support SSZ in the builder api we may need to.
+        // Although that API should include fork info. Hardcoding this for now
+        let payload: Result<ExecutionPayload<E>, Error> =
+            ssz_decode_file::<ExecutionPayloadMerge<E>>(path).map(Into::into);
+        payload.map(Into::into)
     }
 
     fn apply_to(
@@ -286,7 +298,7 @@ impl<E: EthSpec> Operation<E> for BlindedPayload<E> {
             .as_ref()
             .map_or(false, |e| e.execution_valid);
         if valid {
-            process_execution_payload(state, self, spec)
+            process_execution_payload::<E, BlindedPayload<E>>(state, self.to_ref(), spec)
         } else {
             Err(BlockProcessingError::ExecutionInvalid)
         }

testing/ef_tests/src/cases/transition.rs

@@ -46,6 +46,10 @@ impl<E: EthSpec> LoadCase for TransitionTest<E> {
                 spec.bellatrix_fork_epoch = Some(Epoch::new(0));
                 spec.eip4844_fork_epoch = Some(metadata.fork_epoch);
             }
+            ForkName::Capella => {
+                spec.capella_fork_epoch = Some(Epoch::new(0));
+                spec.capella_fork_epoch = Some(metadata.fork_epoch);
+            }
         }
 
         // Load blocks