Revert "Rebuild from finalized state if get_head fails"

This reverts commit 17cf507.

Author: paulhauner

beacon_node/beacon_chain/src/builder.rs

@@ -355,7 +355,7 @@ where
         let fc_store = BeaconForkChoiceStore::get_forkchoice_store(store, &genesis);
         let current_slot = None;
 
-        let fork_choice = ForkChoice::from_anchor_state(
+        let fork_choice = ForkChoice::from_anchor(
             fc_store,
             genesis.beacon_block_root,
             &genesis.beacon_block,
@@ -466,7 +466,7 @@ where
         let fc_store = BeaconForkChoiceStore::get_forkchoice_store(store, &snapshot);
 
         let current_slot = Some(snapshot.beacon_block.slot());
-        let fork_choice = ForkChoice::from_anchor_state(
+        let fork_choice = ForkChoice::from_anchor(
             fc_store,
             snapshot.beacon_block_root,
             &snapshot.beacon_block,

beacon_node/beacon_chain/src/fork_revert.rs

@@ -145,7 +145,7 @@ pub fn reset_fork_choice_to_finalization<E: EthSpec, Hot: ItemStore<E>, Cold: It
 
     let fc_store = BeaconForkChoiceStore::get_forkchoice_store(store.clone(), &finalized_snapshot);
 
-    let mut fork_choice = ForkChoice::from_anchor_state(
+    let mut fork_choice = ForkChoice::from_anchor(
         fc_store,
         finalized_block_root,
         &finalized_snapshot.beacon_block,

beacon_node/beacon_chain/src/schema_change/migration_schema_v7.rs

@@ -44,7 +44,7 @@ pub(crate) fn update_with_reinitialized_fork_choice<T: BeaconChainTypes>(
         beacon_state: anchor_state,
     };
     let store = BeaconForkChoiceStore::get_forkchoice_store(db, &snapshot);
-    let fork_choice = ForkChoice::from_anchor_state(
+    let fork_choice = ForkChoice::from_anchor(
         store,
         anchor_block_root,
         &snapshot.beacon_block,

consensus/fork_choice/src/fork_choice.rs

@@ -51,7 +51,6 @@ pub enum Error<T> {
     MissingFinalizedBlock {
         finalized_checkpoint: Checkpoint,
     },
-    CannotCreateAnchorFromState(BeaconStateError),
 }
 
 impl<T> From<InvalidAttestation> for Error<T> {
@@ -60,59 +59,6 @@ impl<T> From<InvalidAttestation> for Error<T> {
     }
 }
 
-#[derive(Debug)]
-pub struct Anchor {
-    finalized_block_slot: Slot,
-    finalized_block_state_root: Hash256,
-    finalized_block_execution_status: ExecutionStatus,
-    current_epoch_shuffling_id: AttestationShufflingId,
-    next_epoch_shuffling_id: AttestationShufflingId,
-}
-
-impl Anchor {
-    pub fn from_state<E: EthSpec>(
-        anchor_state: &BeaconState<E>,
-        anchor_state_root: Hash256,
-    ) -> Result<Self, BeaconStateError> {
-        let finalized_block_slot = anchor_state.latest_block_header().slot;
-        let finalized_block_root = anchor_state.latest_block_header().canonical_root();
-        let finalized_block_state_root = if finalized_block_slot == anchor_state.slot() {
-            anchor_state_root
-        } else {
-            anchor_state.latest_block_header().state_root
-        };
-        let finalized_block_execution_status =
-            anchor_state.latest_execution_payload_header().map_or_else(
-                |_| ExecutionStatus::irrelevant(),
-                |payload_header| {
-                    if payload_header == &<_>::default() {
-                        // A default payload does not have execution enabled.
-                        ExecutionStatus::irrelevant()
-                    } else {
-                        // Assume that this payload is valid, since the anchor should be a trusted block and
-                        // state.
-                        ExecutionStatus::Valid(payload_header.block_hash)
-                    }
-                },
-            );
-        let current_epoch_shuffling_id = AttestationShufflingId::new(
-            finalized_block_root,
-            anchor_state,
-            RelativeEpoch::Current,
-        )?;
-        let next_epoch_shuffling_id =
-            AttestationShufflingId::new(finalized_block_root, anchor_state, RelativeEpoch::Next)?;
-
-        Ok(Anchor {
-            finalized_block_slot,
-            finalized_block_state_root,
-            finalized_block_execution_status,
-            current_epoch_shuffling_id,
-            next_epoch_shuffling_id,
-        })
-    }
-}
-
 #[derive(Debug)]
 pub enum InvalidBlock {
     UnknownParent(Hash256),
@@ -365,8 +311,8 @@ where
     T: ForkChoiceStore<E>,
     E: EthSpec,
 {
-    /// Instantiates `Self` from an anchor state (genesis or another finalized checkpoint).
-    pub fn from_anchor_state(
+    /// Instantiates `Self` from an anchor (genesis or another finalized checkpoint).
+    pub fn from_anchor(
         fc_store: T,
         anchor_block_root: Hash256,
         anchor_block: &SignedBeaconBlock<E>,
@@ -407,32 +353,6 @@ where
             },
         );
 
-        let anchor = Anchor {
-            finalized_block_slot,
-            finalized_block_state_root,
-            finalized_block_execution_status: execution_status,
-            current_epoch_shuffling_id,
-            next_epoch_shuffling_id,
-        };
-
-        Self::from_anchor(fc_store, anchor, current_slot, spec)
-    }
-
-    /// Instantiates `Self` from an `Anchor`.
-    pub fn from_anchor(
-        fc_store: T,
-        anchor: Anchor,
-        current_slot: Option<Slot>,
-        spec: &ChainSpec,
-    ) -> Result<Self, Error<T::Error>> {
-        let Anchor {
-            finalized_block_slot,
-            finalized_block_state_root,
-            finalized_block_execution_status,
-            current_epoch_shuffling_id,
-            next_epoch_shuffling_id,
-        } = anchor;
-
         // If the current slot is not provided, use the value that was last provided to the store.
         let current_slot = current_slot.unwrap_or_else(|| fc_store.get_current_slot());
 
@@ -443,7 +363,7 @@ where
             *fc_store.finalized_checkpoint(),
             current_epoch_shuffling_id,
             next_epoch_shuffling_id,
-            finalized_block_execution_status,
+            execution_status,
         )?;
 
         let mut fork_choice = Self {
@@ -463,16 +383,31 @@ where
         };
 
         // Ensure that `fork_choice.head_block_root` is updated.
-        //
-        // It's possible that this function will return an error if the only valid head with regard
-        // to FFG checkpoints is invalid. When starting from an anchor state, this would mean that
-        // we've started from an invalid anchor which should be impossible and is fundamentally
-        // flawed.
         fork_choice.get_head(current_slot, spec)?;
 
         Ok(fork_choice)
     }
 
+    /*
+    /// Instantiates `Self` from some existing components.
+    ///
+    /// This is useful if the existing components have been loaded from disk after a process
+    /// restart.
+    pub fn from_components(
+        fc_store: T,
+        proto_array: ProtoArrayForkChoice,
+        queued_attestations: Vec<QueuedAttestation>,
+    ) -> Self {
+        Self {
+            fc_store,
+            proto_array,
+            queued_attestations,
+            forkchoice_update_parameters: None,
+            _phantom: PhantomData,
+        }
+    }
+    */
+
     /// Returns cached information that can be used to issue a `forkchoiceUpdated` message to an
     /// execution engine.
     ///
@@ -1292,34 +1227,9 @@ where
             _phantom: PhantomData,
         };
 
-        if fork_choice.get_head(current_slot, spec).is_ok() {
-            // We were successful in finding a head block, use the `fork_choice` we have already
-            // constructed.
-            Ok(fork_choice)
-        } else {
-            // Fork choice returned an error whilst getting the head, therefore there are no
-            // valid candidates for the head. Rebuild fork choice from the current finalized
-            // checkpoint, potentially losing some history for the sake of having a functioning
-            // client.
-            let fc_store = fork_choice.fc_store;
-            let proto_array = fork_choice.proto_array;
-
-            let finalized_checkpoint = *fc_store.finalized_checkpoint();
-            let finalized_block = proto_array.get_block(&finalized_checkpoint.root).ok_or(
-                Error::MissingFinalizedBlock {
-                    finalized_checkpoint,
-                },
-            )?;
-
-            let anchor = Anchor {
-                finalized_block_slot: finalized_block.slot,
-                finalized_block_state_root: finalized_block.state_root,
-                finalized_block_execution_status: finalized_block.execution_status,
-                current_epoch_shuffling_id: finalized_block.current_epoch_shuffling_id,
-                next_epoch_shuffling_id: finalized_block.next_epoch_shuffling_id,
-            };
-            Self::from_anchor(fc_store, anchor, None, spec)
-        }
+        fork_choice.get_head(current_slot, spec)?;
+
+        Ok(fork_choice)
     }
 
     /// Takes a snapshot of `Self` and stores it in `PersistedForkChoice`, allowing this struct to