The Verge working branch

Cargo.toml

@@ -222,6 +222,10 @@ validator_client = { path = "validator_client/" }
 validator_dir = { path = "common/validator_dir" }
 warp_utils = { path = "common/warp_utils" }
 
+[patch]
+[patch.crates-io]
+ssz_types = { git = "https://github.com/macladson/ssz_types.git", branch = "optional" }
+
 [profile.maxperf]
 inherits = "release"
 lto = "fat"

Makefile

@@ -36,7 +36,7 @@ PROFILE ?= release
 
 # List of all hard forks. This list is used to set env variables for several tests so that
 # they run for different forks.
-FORKS=phase0 altair merge capella
+FORKS=phase0 altair merge capella electra
 
 # Extra flags for Cargo
 CARGO_INSTALL_EXTRA_FLAGS?=

beacon_node/beacon_chain/src/attestation_rewards.rs

@@ -50,9 +50,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         match state {
             BeaconState::Base(_) => self.compute_attestation_rewards_base(state, validators),
-            BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Capella(_) => {
-                self.compute_attestation_rewards_altair(state, validators)
-            }
+            BeaconState::Altair(_)
+            | BeaconState::Merge(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Electra(_) => self.compute_attestation_rewards_altair(state, validators),
         }
     }
 

beacon_node/beacon_chain/src/beacon_block_streamer.rs

@@ -15,7 +15,8 @@ use types::{
     SignedBlindedBeaconBlock, Slot,
 };
 use types::{
-    ExecutionPayload, ExecutionPayloadCapella, ExecutionPayloadHeader, ExecutionPayloadMerge,
+    ExecutionPayload, ExecutionPayloadCapella, ExecutionPayloadElectra, ExecutionPayloadHeader,
+    ExecutionPayloadMerge,
 };
 
 #[derive(PartialEq)]
@@ -97,6 +98,7 @@ fn reconstruct_default_header_block<E: EthSpec>(
     let payload: ExecutionPayload<E> = match fork {
         ForkName::Merge => ExecutionPayloadMerge::default().into(),
         ForkName::Capella => ExecutionPayloadCapella::default().into(),
+        ForkName::Electra => ExecutionPayloadElectra::default().into(),
         ForkName::Base | ForkName::Altair => {
             return Err(Error::PayloadReconstruction(format!(
                 "Block with fork variant {} has execution payload",
@@ -714,17 +716,19 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn check_all_blocks_from_altair_to_capella() {
+    async fn check_all_blocks_from_altair_to_electra() {
         let slots_per_epoch = MinimalEthSpec::slots_per_epoch() as usize;
-        let num_epochs = 8;
+        let num_epochs = 10;
         let bellatrix_fork_epoch = 2usize;
         let capella_fork_epoch = 4usize;
+        let electra_fork_epoch = 6usize;
         let num_blocks_produced = num_epochs * slots_per_epoch;
 
         let mut spec = test_spec::<MinimalEthSpec>();
         spec.altair_fork_epoch = Some(Epoch::new(0));
         spec.bellatrix_fork_epoch = Some(Epoch::new(bellatrix_fork_epoch as u64));
         spec.capella_fork_epoch = Some(Epoch::new(capella_fork_epoch as u64));
+        spec.electra_fork_epoch = Some(Epoch::new(electra_fork_epoch as u64));
 
         let harness = get_harness(VALIDATOR_COUNT, spec);
         // go to bellatrix fork
@@ -833,17 +837,19 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn check_fallback_altair_to_capella() {
+    async fn check_fallback_altair_to_electra() {
         let slots_per_epoch = MinimalEthSpec::slots_per_epoch() as usize;
-        let num_epochs = 8;
+        let num_epochs = 10;
         let bellatrix_fork_epoch = 2usize;
         let capella_fork_epoch = 4usize;
+        let electra_fork_epoch = 6usize;
         let num_blocks_produced = num_epochs * slots_per_epoch;
 
         let mut spec = test_spec::<MinimalEthSpec>();
         spec.altair_fork_epoch = Some(Epoch::new(0));
         spec.bellatrix_fork_epoch = Some(Epoch::new(bellatrix_fork_epoch as u64));
         spec.capella_fork_epoch = Some(Epoch::new(capella_fork_epoch as u64));
+        spec.electra_fork_epoch = Some(Epoch::new(electra_fork_epoch as u64));
 
         let harness = get_harness(VALIDATOR_COUNT, spec);
 

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -4353,7 +4353,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // allows it to run concurrently with things like attestation packing.
         let prepare_payload_handle = match &state {
             BeaconState::Base(_) | BeaconState::Altair(_) => None,
-            BeaconState::Merge(_) | BeaconState::Capella(_) => {
+            BeaconState::Merge(_) | BeaconState::Capella(_) | BeaconState::Electra(_) => {
                 let prepare_payload_handle =
                     get_execution_payload(self.clone(), &state, proposer_index, builder_params)?;
                 Some(prepare_payload_handle)
@@ -4643,6 +4643,30 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     bls_to_execution_changes: bls_to_execution_changes.into(),
                 },
             }),
+            BeaconState::Electra(_) => BeaconBlock::Electra(BeaconBlockElectra {
+                slot,
+                proposer_index,
+                parent_root,
+                state_root: Hash256::zero(),
+                body: BeaconBlockBodyElectra {
+                    randao_reveal,
+                    eth1_data,
+                    graffiti,
+                    proposer_slashings: proposer_slashings.into(),
+                    attester_slashings: attester_slashings.into(),
+                    attestations: attestations.into(),
+                    deposits: deposits.into(),
+                    voluntary_exits: voluntary_exits.into(),
+                    sync_aggregate: sync_aggregate
+                        .ok_or(BlockProductionError::MissingSyncAggregate)?,
+                    execution_payload: block_contents
+                        .ok_or(BlockProductionError::MissingExecutionPayload)?
+                        .to_payload()
+                        .try_into()
+                        .map_err(|_| BlockProductionError::InvalidPayloadFork)?,
+                    bls_to_execution_changes: bls_to_execution_changes.into(),
+                },
+            }),
         };
 
         let block = SignedBeaconBlock::from_block(
@@ -4912,7 +4936,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         } else {
             let withdrawals = match self.spec.fork_name_at_slot::<T::EthSpec>(prepare_slot) {
                 ForkName::Base | ForkName::Altair | ForkName::Merge => None,
-                ForkName::Capella => {
+                ForkName::Capella | ForkName::Electra => {
                     let chain = self.clone();
                     self.spawn_blocking_handle(
                         move || {

beacon_node/beacon_chain/src/electra_readiness.rs

@@ -0,0 +1,122 @@
+//! Provides tools for checking if a node is ready for the Electra upgrade and following merge
+//! transition.
+
+use crate::{BeaconChain, BeaconChainTypes};
+use execution_layer::http::{
+    ENGINE_FORKCHOICE_UPDATED_V2, ENGINE_GET_PAYLOAD_V2, ENGINE_NEW_PAYLOAD_V2,
+};
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::time::Duration;
+use types::*;
+
+/// The time before the Electra fork when we will start issuing warnings about preparation.
+use super::merge_readiness::SECONDS_IN_A_WEEK;
+pub const ELECTRA_READINESS_PREPARATION_SECONDS: u64 = SECONDS_IN_A_WEEK * 2;
+pub const ENGINE_CAPABILITIES_REFRESH_INTERVAL: u64 = 300;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(tag = "type")]
+pub enum ElectraReadiness {
+    /// The execution engine is electra-enabled (as far as we can tell)
+    Ready,
+    /// We are connected to an execution engine which doesn't support the V2 engine api methods
+    V2MethodsNotSupported { error: String },
+    /// The transition configuration with the EL failed, there might be a problem with
+    /// connectivity, authentication or a difference in configuration.
+    ExchangeCapabilitiesFailed { error: String },
+    /// The user has not configured an execution endpoint
+    NoExecutionEndpoint,
+}
+
+impl fmt::Display for ElectraReadiness {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ElectraReadiness::Ready => {
+                write!(f, "This node appears ready for Electra.")
+            }
+            ElectraReadiness::ExchangeCapabilitiesFailed { error } => write!(
+                f,
+                "Could not exchange capabilities with the \
+                    execution endpoint: {}",
+                error
+            ),
+            ElectraReadiness::NoExecutionEndpoint => write!(
+                f,
+                "The --execution-endpoint flag is not specified, this is a \
+                    requirement post-merge"
+            ),
+            ElectraReadiness::V2MethodsNotSupported { error } => write!(
+                f,
+                "Execution endpoint does not support Electra methods: {}",
+                error
+            ),
+        }
+    }
+}
+
+impl<T: BeaconChainTypes> BeaconChain<T> {
+    /// Returns `true` if electra epoch is set and Electra fork has occurred or will
+    /// occur within `ELECTRA_READINESS_PREPARATION_SECONDS`
+    pub fn is_time_to_prepare_for_electra(&self, current_slot: Slot) -> bool {
+        if let Some(electra_epoch) = self.spec.electra_fork_epoch {
+            let electra_slot = electra_epoch.start_slot(T::EthSpec::slots_per_epoch());
+            let electra_readiness_preparation_slots =
+                ELECTRA_READINESS_PREPARATION_SECONDS / self.spec.seconds_per_slot;
+            // Return `true` if Electra has happened or is within the preparation time.
+            current_slot + electra_readiness_preparation_slots > electra_slot
+        } else {
+            // The Electra fork epoch has not been defined yet, no need to prepare.
+            false
+        }
+    }
+
+    /// Attempts to connect to the EL and confirm that it is ready for electra.
+    pub async fn check_electra_readiness(&self) -> ElectraReadiness {
+        if let Some(el) = self.execution_layer.as_ref() {
+            match el
+                .get_engine_capabilities(Some(Duration::from_secs(
+                    ENGINE_CAPABILITIES_REFRESH_INTERVAL,
+                )))
+                .await
+            {
+                Err(e) => {
+                    // The EL was either unreachable or responded with an error
+                    ElectraReadiness::ExchangeCapabilitiesFailed {
+                        error: format!("{:?}", e),
+                    }
+                }
+                Ok(capabilities) => {
+                    let mut missing_methods = String::from("Required Methods Unsupported:");
+                    let mut all_good = true;
+                    if !capabilities.get_payload_v2 {
+                        missing_methods.push(' ');
+                        missing_methods.push_str(ENGINE_GET_PAYLOAD_V2);
+                        all_good = false;
+                    }
+                    if !capabilities.forkchoice_updated_v2 {
+                        missing_methods.push(' ');
+                        missing_methods.push_str(ENGINE_FORKCHOICE_UPDATED_V2);
+                        all_good = false;
+                    }
+                    if !capabilities.new_payload_v2 {
+                        missing_methods.push(' ');
+                        missing_methods.push_str(ENGINE_NEW_PAYLOAD_V2);
+                        all_good = false;
+                    }
+
+                    if all_good {
+                        ElectraReadiness::Ready
+                    } else {
+                        ElectraReadiness::V2MethodsNotSupported {
+                            error: missing_methods,
+                        }
+                    }
+                }
+            }
+        } else {
+            ElectraReadiness::NoExecutionEndpoint
+        }
+    }
+}

beacon_node/beacon_chain/src/execution_payload.rs

@@ -419,7 +419,9 @@ pub fn get_execution_payload<
     let latest_execution_payload_header_block_hash =
         state.latest_execution_payload_header()?.block_hash();
     let withdrawals = match state {
-        &BeaconState::Capella(_) => Some(get_expected_withdrawals(state, spec)?.into()),
+        &BeaconState::Capella(_) | &BeaconState::Electra(_) => {
+            Some(get_expected_withdrawals(state, spec)?.into())
+        }
         &BeaconState::Merge(_) => None,
         // These shouldn't happen but they're here to make the pattern irrefutable
         &BeaconState::Base(_) | &BeaconState::Altair(_) => None,

beacon_node/beacon_chain/src/lib.rs

@@ -15,6 +15,7 @@ pub mod canonical_head;
 pub mod capella_readiness;
 pub mod chain_config;
 mod early_attester_cache;
+pub mod electra_readiness;
 mod errors;
 pub mod eth1_chain;
 mod eth1_finalization_cache;

beacon_node/beacon_chain/src/test_utils.rs

@@ -440,10 +440,14 @@ where
         let shanghai_time = spec.capella_fork_epoch.map(|epoch| {
             HARNESS_GENESIS_TIME + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
         });
+        let prague_time = spec.electra_fork_epoch.map(|epoch| {
+            HARNESS_GENESIS_TIME + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
+        });
         let mock = MockExecutionLayer::new(
             self.runtime.task_executor.clone(),
             DEFAULT_TERMINAL_BLOCK,
             shanghai_time,
+            prague_time,
             builder_threshold,
             Some(JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap()),
             spec,

beacon_node/beacon_chain/tests/store_tests.rs

@@ -1893,9 +1893,9 @@ async fn pruning_test(
     };
 
     let start_slot = Slot::new(1);
-    let divergence_slot = start_slot + num_initial_blocks;
+    let dielectrance_slot = start_slot + num_initial_blocks;
     let (state, state_root) = harness.get_current_state_and_root();
-    let (_, _, _, divergence_state) = harness
+    let (_, _, _, dielectrance_state) = harness
         .add_attested_blocks_at_slots(
             state,
             state_root,
@@ -1908,25 +1908,25 @@ async fn pruning_test(
         .add_blocks_on_multiple_chains(vec![
             // Canonical chain
             (
-                divergence_state.clone(),
+                dielectrance_state.clone(),
                 slots(
-                    divergence_slot + num_canonical_skips,
+                    dielectrance_slot + num_canonical_skips,
                     num_canonical_middle_blocks,
                 ),
                 honest_validators.clone(),
             ),
             // Fork chain
             (
-                divergence_state.clone(),
-                slots(divergence_slot + num_fork_skips, num_fork_blocks),
+                dielectrance_state.clone(),
+                slots(dielectrance_slot + num_fork_skips, num_fork_blocks),
                 faulty_validators,
             ),
         ])
         .await;
     let (_, _, _, mut canonical_state) = chains.remove(0);
     let (stray_blocks, stray_states, _, stray_head_state) = chains.remove(0);
 
-    let stray_head_slot = divergence_slot + num_fork_skips + num_fork_blocks - 1;
+    let stray_head_slot = dielectrance_slot + num_fork_skips + num_fork_blocks - 1;
     let stray_head_state_root = stray_states[&stray_head_slot];
     let stray_states = harness
         .chain
@@ -1946,7 +1946,7 @@ async fn pruning_test(
 
     // Trigger finalization
     let num_finalization_blocks = 4 * E::slots_per_epoch();
-    let canonical_slot = divergence_slot + num_canonical_skips + num_canonical_middle_blocks;
+    let canonical_slot = dielectrance_slot + num_canonical_skips + num_canonical_middle_blocks;
     let canonical_state_root = canonical_state.update_tree_hash_cache().unwrap();
     harness
         .add_attested_blocks_at_slots(
@@ -1957,13 +1957,13 @@ async fn pruning_test(
         )
         .await;
 
-    // Check that finalization has advanced past the divergence slot.
+    // Check that finalization has advanced past the dielectrance slot.
     assert!(
         harness
             .finalized_checkpoint()
             .epoch
             .start_slot(E::slots_per_epoch())
-            > divergence_slot
+            > dielectrance_slot
     );
     check_chain_dump(
         &harness,