Safe non-finalized checkpoint sync

beacon_node/Cargo.toml

@@ -27,6 +27,7 @@ client = { path = "client" }
 directory = { workspace = true }
 dirs = { workspace = true }
 environment = { workspace = true }
+eth2 = { workspace = true }
 eth2_config = { workspace = true }
 execution_layer = { workspace = true }
 genesis = { workspace = true }

beacon_node/beacon_chain/src/attestation_verification.rs

@@ -1436,6 +1436,7 @@ fn verify_attestation_is_finalized_checkpoint_or_descendant<T: BeaconChainTypes>
     let attestation_block_root = attestation_data.beacon_block_root;
     let finalized_slot = fork_choice
         .finalized_checkpoint()
+        .local()
         .epoch
         .start_slot(T::EthSpec::slots_per_epoch());
     let split = chain.store.get_split_info();

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -41,7 +41,7 @@ use crate::light_client_optimistic_update_verification::{
     Error as LightClientOptimisticUpdateError, VerifiedLightClientOptimisticUpdate,
 };
 use crate::light_client_server_cache::LightClientServerCache;
-use crate::migrate::{BackgroundMigrator, ManualFinalizationNotification};
+use crate::migrate::BackgroundMigrator;
 use crate::naive_aggregation_pool::{
     AggregatedAttestationMap, Error as NaiveAggregationError, NaiveAggregationPool,
     SyncContributionAggregateMap,
@@ -125,8 +125,8 @@ use std::sync::Arc;
 use std::time::Duration;
 use store::iter::{BlockRootsIterator, ParentRootBlockIterator, StateRootsIterator};
 use store::{
-    BlobSidecarListFromRoot, DBColumn, DatabaseBlock, Error as DBError, HotColdDB, HotStateSummary,
-    KeyValueStore, KeyValueStoreOp, StoreItem, StoreOp,
+    BlobSidecarListFromRoot, DBColumn, DatabaseBlock, Error as DBError, HotColdDB, KeyValueStore,
+    KeyValueStoreOp, StoreItem, StoreOp,
 };
 use task_executor::{RayonPoolType, ShutdownReason, TaskExecutor};
 use tokio_stream::Stream;
@@ -550,10 +550,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         block_root: &Hash256,
         block_slot: Slot,
     ) -> Result<bool, Error> {
+        // Used by the API: finalized if prior to the network finality not the local view
         let finalized_slot = self
             .canonical_head
             .cached_head()
             .finalized_checkpoint()
+            .on_chain()
             .epoch
             .start_slot(T::EthSpec::slots_per_epoch());
         let is_canonical = self
@@ -580,10 +582,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         state_root: &Hash256,
         state_slot: Slot,
     ) -> Result<FinalizationAndCanonicity, Error> {
+        // Used by the API: finalized if prior to the network finality not the local view
         let finalized_slot = self
             .canonical_head
             .cached_head()
             .finalized_checkpoint()
+            .on_chain()
             .epoch
             .start_slot(T::EthSpec::slots_per_epoch());
         let slot_is_finalized = state_slot <= finalized_slot;
@@ -1210,6 +1214,26 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .map(Some)
     }
 
+    pub fn get_execution_hash(
+        &self,
+        block_root: &Hash256,
+    ) -> Result<Option<ExecutionBlockHash>, Error> {
+        if let Some(execution_hash) = self
+            .canonical_head
+            .fork_choice_read_lock()
+            .execution_hash(*block_root)
+        {
+            return Ok(Some(execution_hash));
+        }
+        Ok(self.store.get_blinded_block(block_root)?.and_then(|block| {
+            if let Ok(payload) = block.message().execution_payload() {
+                Some(payload.block_hash())
+            } else {
+                None
+            }
+        }))
+    }
+
     /// Returns the blobs at the given root, if any.
     ///
     /// ## Errors
@@ -1435,7 +1459,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let fork_choice = self.canonical_head.fork_choice_read_lock();
         fork_choice
             .proto_array()
-            .heads_descended_from_finalization::<T::EthSpec>(fork_choice.finalized_checkpoint())
+            .heads_descended_from_finalization::<T::EthSpec>(
+                fork_choice.finalized_checkpoint().as_local(),
+            )
             .iter()
             .map(|node| (node.root, node.slot))
             .collect()
@@ -1692,39 +1718,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         self.store_migrator.process_manual_compaction();
     }
 
-    pub fn manually_finalize_state(
-        &self,
-        state_root: Hash256,
-        checkpoint: Checkpoint,
-    ) -> Result<(), Error> {
-        let HotStateSummary {
-            slot,
-            latest_block_root,
-            ..
-        } = self
-            .store
-            .load_hot_state_summary(&state_root)
-            .map_err(BeaconChainError::DBError)?
-            .ok_or(BeaconChainError::MissingHotStateSummary(state_root))?;
-
-        if slot != checkpoint.epoch.start_slot(T::EthSpec::slots_per_epoch())
-            || latest_block_root != *checkpoint.root
-        {
-            return Err(BeaconChainError::InvalidCheckpoint {
-                state_root,
-                checkpoint,
-            });
-        }
-
-        let notif = ManualFinalizationNotification {
-            state_root: state_root.into(),
-            checkpoint,
-        };
-
-        self.store_migrator.process_manual_finalization(notif);
-        Ok(())
-    }
-
     /// Returns an aggregated `Attestation`, if any, that has a matching `attestation.data`.
     ///
     /// The attestation will be obtained from `self.naive_aggregation_pool`.
@@ -4173,8 +4166,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // We are doing this to ensure that we detect changes in finalization. It's possible
         // that fork choice has already been updated to the finalized checkpoint in the block
         // we're importing.
-        let current_head_finalized_checkpoint =
-            self.canonical_head.cached_head().finalized_checkpoint();
+        let current_head_finalized_checkpoint = self
+            .canonical_head
+            .cached_head()
+            .finalized_checkpoint_from_head_state();
         // Compare the existing finalized checkpoint with the incoming block's finalized checkpoint.
         let new_finalized_checkpoint = state.finalized_checkpoint();
 
@@ -6003,16 +5998,16 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let justified_block = self
             .spawn_blocking_handle(
                 move || {
-                    chain
-                        .canonical_head
-                        .fork_choice_read_lock()
-                        .get_justified_block()
+                    let fork_choice = chain.canonical_head.fork_choice_read_lock();
+                    fork_choice.get_block(&fork_choice.justified_checkpoint().on_chain().root)
                 },
                 "invalid_payload_fork_choice_get_justified",
             )
-            .await??;
+            .await?;
 
-        if justified_block.execution_status.is_invalid() {
+        if let Some(justified_block) = justified_block
+            && justified_block.execution_status.is_invalid()
+        {
             crit!(
                 msg = "ensure you are not connected to a malicious network. This error is not \
                 recoverable, please reach out to the lighthouse developers for assistance.",
@@ -7230,7 +7225,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // Check if finalization is advancing.
         let current_epoch = current_slot.epoch(T::EthSpec::slots_per_epoch());
         let epochs_since_finalization =
-            current_epoch.saturating_sub(cached_head.finalized_checkpoint().epoch);
+            current_epoch.saturating_sub(cached_head.finalized_checkpoint().on_chain().epoch);
         let finalization_check = epochs_since_finalization.as_usize()
             <= self.config.builder_fallback_epochs_since_finalization;