Merge remote-tracking branch 'michael/delete-fork-revert' into gloas-replay-blocks

beacon_node/beacon_chain/src/builder.rs

@@ -7,7 +7,6 @@ use crate::beacon_proposer_cache::BeaconProposerCache;
 use crate::custody_context::NodeCustodyType;
 use crate::data_availability_checker::DataAvailabilityChecker;
 use crate::fork_choice_signal::ForkChoiceSignalTx;
-use crate::fork_revert::{reset_fork_choice_to_finalization, revert_to_fork_boundary};
 use crate::graffiti_calculator::{GraffitiCalculator, GraffitiOrigin};
 use crate::kzg_utils::{build_data_column_sidecars_fulu, build_data_column_sidecars_gloas};
 use crate::light_client_server_cache::LightClientServerCache;
@@ -778,49 +777,17 @@ where
             .get_head(current_slot, &self.spec)
             .map_err(|e| format!("Unable to get fork choice head: {:?}", e))?;
 
-        // Try to decode the head block according to the current fork, if that fails, try
-        // to backtrack to before the most recent fork.
-        let (head_block_root, head_block, head_reverted) =
-            match store.get_full_block(&initial_head_block_root) {
-                Ok(Some(block)) => (initial_head_block_root, block, false),
-                Ok(None) => return Err("Head block not found in store".into()),
-                Err(StoreError::SszDecodeError(_)) => {
-                    error!(
-                        message = "This node has likely missed a hard fork. \
-                        It will try to revert the invalid blocks and keep running, \
-                        but any stray blocks and states will not be deleted. \
-                        Long-term you should consider re-syncing this node.",
-                        "Error decoding head block"
-                    );
-                    let (block_root, block) = revert_to_fork_boundary(
-                        current_slot,
-                        initial_head_block_root,
-                        store.clone(),
-                        &self.spec,
-                    )?;
-
-                    (block_root, block, true)
-                }
-                Err(e) => return Err(descriptive_db_error("head block", &e)),
-            };
+        let head_block_root = initial_head_block_root;
+        let head_block = store
+            .get_full_block(&initial_head_block_root)
+            .map_err(|e| descriptive_db_error("head block", &e))?
+            .ok_or("Head block not found in store")?;
 
         let (_head_state_root, head_state) = store
             .get_advanced_hot_state(head_block_root, current_slot, head_block.state_root())
             .map_err(|e| descriptive_db_error("head state", &e))?
             .ok_or("Head state not found in store")?;
 
-        // If the head reverted then we need to reset fork choice using the new head's finalized
-        // checkpoint.
-        if head_reverted {
-            fork_choice = reset_fork_choice_to_finalization(
-                head_block_root,
-                &head_state,
-                store.clone(),
-                Some(current_slot),
-                &self.spec,
-            )?;
-        }
-
         let head_shuffling_ids = BlockShufflingIds::try_from_head(head_block_root, &head_state)?;
 
         let mut head_snapshot = BeaconSnapshot {

beacon_node/beacon_chain/src/fork_revert.rs

@@ -1,96 +0,0 @@
-use crate::BeaconForkChoiceStore;
-use fork_choice::ForkChoice;
-use itertools::process_results;
-use std::sync::Arc;
-use store::{HotColdDB, ItemStore, iter::ParentRootBlockIterator};
-use tracing::{info, warn};
-use types::{BeaconState, ChainSpec, EthSpec, ForkName, Hash256, SignedBeaconBlock, Slot};
-
-const CORRUPT_DB_MESSAGE: &str = "The database could be corrupt. Check its file permissions or \
-                                  consider deleting it by running with the --purge-db flag.";
-
-/// Revert the head to the last block before the most recent hard fork.
-///
-/// This function is destructive and should only be used if there is no viable alternative. It will
-/// cause the reverted blocks and states to be completely forgotten, lying dormant in the database
-/// forever.
-///
-/// Return the `(head_block_root, head_block)` that should be used post-reversion.
-pub fn revert_to_fork_boundary<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>(
-    current_slot: Slot,
-    head_block_root: Hash256,
-    store: Arc<HotColdDB<E, Hot, Cold>>,
-    spec: &ChainSpec,
-) -> Result<(Hash256, SignedBeaconBlock<E>), String> {
-    let current_fork = spec.fork_name_at_slot::<E>(current_slot);
-    let fork_epoch = spec
-        .fork_epoch(current_fork)
-        .ok_or_else(|| format!("Current fork '{}' never activates", current_fork))?;
-
-    if current_fork == ForkName::Base {
-        return Err(format!(
-            "Cannot revert to before phase0 hard fork. {}",
-            CORRUPT_DB_MESSAGE
-        ));
-    }
-
-    warn!(
-        target_fork = %current_fork,
-        %fork_epoch,
-        "Reverting invalid head block"
-    );
-    let block_iter = ParentRootBlockIterator::fork_tolerant(&store, head_block_root);
-
-    let (block_root, blinded_block) = process_results(block_iter, |mut iter| {
-        iter.find_map(|(block_root, block)| {
-            if block.slot() < fork_epoch.start_slot(E::slots_per_epoch()) {
-                Some((block_root, block))
-            } else {
-                info!(
-                    ?block_root,
-                    slot = %block.slot(),
-                    "Reverting block"
-                );
-                None
-            }
-        })
-    })
-    .map_err(|e| {
-        format!(
-            "Error fetching blocks to revert: {:?}. {}",
-            e, CORRUPT_DB_MESSAGE
-        )
-    })?
-    .ok_or_else(|| format!("No pre-fork blocks found. {}", CORRUPT_DB_MESSAGE))?;
-
-    let block = store
-        .make_full_block(&block_root, blinded_block)
-        .map_err(|e| format!("Unable to add payload to new head block: {:?}", e))?;
-
-    Ok((block_root, block))
-}
-
-/// Reset fork choice to the finalized checkpoint of the supplied head state.
-///
-/// The supplied `head_block_root` should correspond to the most recently applied block on
-/// `head_state`.
-///
-/// This function avoids quirks of fork choice initialization by replaying all of the blocks from
-/// the checkpoint to the head.
-///
-/// See this issue for details: https://github.com/ethereum/consensus-specs/issues/2566
-///
-/// It will fail if the finalized state or any of the blocks to replay are unavailable.
-///
-/// WARNING: this function is destructive and causes fork choice to permanently forget all
-/// chains other than the chain leading to `head_block_root`. It should only be used in extreme
-/// circumstances when there is no better alternative.
-pub fn reset_fork_choice_to_finalization<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>(
-    _head_block_root: Hash256,
-    _head_state: &BeaconState<E>,
-    _store: Arc<HotColdDB<E, Hot, Cold>>,
-    _current_slot: Option<Slot>,
-    _spec: &ChainSpec,
-) -> Result<ForkChoice<BeaconForkChoiceStore<E, Hot, Cold>, E>, String> {
-    Err("broken".into())
-}

beacon_node/beacon_chain/src/lib.rs

@@ -26,7 +26,6 @@ pub mod events;
 pub mod execution_payload;
 pub mod fetch_blobs;
 pub mod fork_choice_signal;
-pub mod fork_revert;
 pub mod graffiti_calculator;
 pub mod historical_blocks;
 pub mod historical_data_columns;