Properly Persist AnchorState in ForkChoice

Author: ethDreamer

beacon_node/beacon_chain/src/beacon_fork_choice_store.rs

@@ -389,9 +389,9 @@ pub struct PersistedForkChoiceStore {
     pub equivocating_indices: BTreeSet<u64>,
 }
 
-impl Into<PersistedForkChoiceStore> for PersistedForkChoiceStoreV11 {
-    fn into(self) -> PersistedForkChoiceStore {
-        PersistedForkChoiceStore {
+impl Into<PersistedForkChoiceStoreV17> for PersistedForkChoiceStoreV11 {
+    fn into(self) -> PersistedForkChoiceStoreV17 {
+        PersistedForkChoiceStoreV17 {
             balances_cache: self.balances_cache,
             time: self.time,
             finalized_checkpoint: self.finalized_checkpoint,
@@ -405,7 +405,7 @@ impl Into<PersistedForkChoiceStore> for PersistedForkChoiceStoreV11 {
     }
 }
 
-impl Into<PersistedForkChoiceStoreV11> for PersistedForkChoiceStore {
+impl Into<PersistedForkChoiceStoreV11> for PersistedForkChoiceStoreV17 {
     fn into(self) -> PersistedForkChoiceStoreV11 {
         PersistedForkChoiceStoreV11 {
             balances_cache: self.balances_cache,

beacon_node/beacon_chain/src/persisted_fork_choice.rs

@@ -5,31 +5,34 @@ use store::{DBColumn, Error, StoreItem};
 use superstruct::superstruct;
 
 // If adding a new version you should update this type alias and fix the breakages.
-pub type PersistedForkChoice = PersistedForkChoiceV17;
+pub type PersistedForkChoice = PersistedForkChoiceV20;
 
 #[superstruct(
-    variants(V11, V17),
+    variants(V11, V17, V20),
     variant_attributes(derive(Encode, Decode)),
     no_enum
 )]
 pub struct PersistedForkChoice {
-    pub fork_choice: fork_choice::PersistedForkChoice,
+    #[superstruct(only(V11, V17))]
+    pub fork_choice: fork_choice::PersistedForkChoiceV19,
+    #[superstruct(only(V20))]
+    pub fork_choice: fork_choice::PersistedForkChoiceV20,
     #[superstruct(only(V11))]
     pub fork_choice_store: PersistedForkChoiceStoreV11,
-    #[superstruct(only(V17))]
+    #[superstruct(only(V17, V20))]
     pub fork_choice_store: PersistedForkChoiceStoreV17,
 }
 
-impl Into<PersistedForkChoice> for PersistedForkChoiceV11 {
-    fn into(self) -> PersistedForkChoice {
-        PersistedForkChoice {
+impl Into<PersistedForkChoiceV17> for PersistedForkChoiceV11 {
+    fn into(self) -> PersistedForkChoiceV17 {
+        PersistedForkChoiceV17 {
             fork_choice: self.fork_choice,
             fork_choice_store: self.fork_choice_store.into(),
         }
     }
 }
 
-impl Into<PersistedForkChoiceV11> for PersistedForkChoice {
+impl Into<PersistedForkChoiceV11> for PersistedForkChoiceV17 {
     fn into(self) -> PersistedForkChoiceV11 {
         PersistedForkChoiceV11 {
             fork_choice: self.fork_choice,
@@ -38,6 +41,24 @@ impl Into<PersistedForkChoiceV11> for PersistedForkChoice {
     }
 }
 
+impl Into<PersistedForkChoiceV20> for PersistedForkChoiceV17 {
+    fn into(self) -> PersistedForkChoiceV20 {
+        PersistedForkChoiceV20 {
+            fork_choice: self.fork_choice.into(),
+            fork_choice_store: self.fork_choice_store,
+        }
+    }
+}
+
+impl Into<PersistedForkChoiceV17> for PersistedForkChoiceV20 {
+    fn into(self) -> PersistedForkChoiceV17 {
+        PersistedForkChoiceV17 {
+            fork_choice: self.fork_choice.into(),
+            fork_choice_store: self.fork_choice_store,
+        }
+    }
+}
+
 macro_rules! impl_store_item {
     ($type:ty) => {
         impl StoreItem for $type {
@@ -58,3 +79,4 @@ macro_rules! impl_store_item {
 
 impl_store_item!(PersistedForkChoiceV11);
 impl_store_item!(PersistedForkChoiceV17);
+impl_store_item!(PersistedForkChoiceV20);

beacon_node/beacon_chain/src/schema_change.rs

@@ -2,6 +2,7 @@
 mod migration_schema_v17;
 mod migration_schema_v18;
 mod migration_schema_v19;
+mod migration_schema_v20;
 
 use crate::beacon_chain::BeaconChainTypes;
 use crate::types::ChainSpec;
@@ -78,6 +79,14 @@ pub fn migrate_schema<T: BeaconChainTypes>(
             let ops = migration_schema_v19::downgrade_from_v19::<T>(db.clone(), log)?;
             db.store_schema_version_atomically(to, ops)
         }
+        (SchemaVersion(19), SchemaVersion(20)) => {
+            let ops = migration_schema_v20::upgrade_to_v20::<T>(db.clone(), log)?;
+            db.store_schema_version_atomically(to, ops)
+        }
+        (SchemaVersion(20), SchemaVersion(19)) => {
+            let ops = migration_schema_v20::downgrade_from_v20::<T>(db.clone(), log)?;
+            db.store_schema_version_atomically(to, ops)
+        }
         // Anything else is an error.
         (_, _) => Err(HotColdDBError::UnsupportedSchemaVersion {
             target_version: to,

beacon_node/beacon_chain/src/schema_change/migration_schema_v20.rs

@@ -0,0 +1,35 @@
+use crate::beacon_chain::{BeaconChainTypes, FORK_CHOICE_DB_KEY};
+use crate::persisted_fork_choice::{PersistedForkChoiceV17, PersistedForkChoiceV20};
+use slog::{debug, Logger};
+use std::sync::Arc;
+use store::{Error, HotColdDB, KeyValueStoreOp, StoreItem};
+
+pub fn upgrade_to_v20<T: BeaconChainTypes>(
+    db: Arc<HotColdDB<T::EthSpec, T::HotStore, T::ColdStore>>,
+    log: Logger,
+) -> Result<Vec<KeyValueStoreOp>, Error> {
+    let v17 = db
+        .get_item::<PersistedForkChoiceV17>(&FORK_CHOICE_DB_KEY)?
+        .ok_or_else(|| Error::SchemaMigrationError("fork choice missing from database".into()))?;
+
+    let v20: PersistedForkChoiceV20 = v17.into();
+
+    debug!(log, "Adding anchor_state to fork choice");
+
+    Ok(vec![v20.as_kv_store_op(FORK_CHOICE_DB_KEY)])
+}
+
+pub fn downgrade_from_v20<T: BeaconChainTypes>(
+    db: Arc<HotColdDB<T::EthSpec, T::HotStore, T::ColdStore>>,
+    log: Logger,
+) -> Result<Vec<KeyValueStoreOp>, Error> {
+    let v20 = db
+        .get_item::<PersistedForkChoiceV20>(&FORK_CHOICE_DB_KEY)?
+        .ok_or_else(|| Error::SchemaMigrationError("fork choice missing from database".into()))?;
+
+    let v17: PersistedForkChoiceV17 = v20.into();
+
+    debug!(log, "Dropping anchor_state from fork choice.");
+
+    Ok(vec![v17.as_kv_store_op(FORK_CHOICE_DB_KEY)])
+}

beacon_node/store/src/metadata.rs

@@ -4,7 +4,7 @@ use ssz::{Decode, Encode};
 use ssz_derive::{Decode, Encode};
 use types::{Checkpoint, Hash256, Slot};
 
-pub const CURRENT_SCHEMA_VERSION: SchemaVersion = SchemaVersion(19);
+pub const CURRENT_SCHEMA_VERSION: SchemaVersion = SchemaVersion(20);
 
 // All the keys that get stored under the `BeaconMeta` column.
 //

consensus/fork_choice/src/fork_choice.rs

@@ -17,6 +17,7 @@ use std::cmp::Ordering;
 use std::collections::BTreeSet;
 use std::marker::PhantomData;
 use std::time::Duration;
+use types::superstruct;
 use types::{
     consts::merge::INTERVALS_PER_SLOT, AbstractExecPayload, AttestationShufflingId,
     AttesterSlashing, BeaconBlockRef, BeaconState, BeaconStateError, ChainSpec, Checkpoint, Epoch,
@@ -284,7 +285,8 @@ fn dequeue_attestations(
 /// latter case only occurs when we weak subjectivity sync against a state which is not finalized.
 /// This could be necessary in extreme circumstances where finalization extends past the data
 /// availabilty boundary post-deneb.
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Encode, Decode)]
+#[ssz(enum_behaviour = "tag")]
 pub enum AnchorState {
     /// The finalized checkpoint is truly finalized
     Finalized,
@@ -1552,8 +1554,7 @@ where
                 // Will be updated in the following call to `Self::get_head`.
                 head_root: Hash256::zero(),
             },
-            // FIXME: actually persist / load anchor state!!!
-            anchor_state: AnchorState::Finalized,
+            anchor_state: persisted.anchor_state,
             _phantom: PhantomData,
         };
 
@@ -1587,6 +1588,7 @@ where
         PersistedForkChoice {
             proto_array_bytes: self.proto_array().as_bytes(),
             queued_attestations: self.queued_attestations().to_vec(),
+            anchor_state: self.anchor_state,
         }
     }
 }
@@ -1680,10 +1682,38 @@ where
 /// Helper struct that is used to encode/decode the state of the `ForkChoice` as SSZ bytes.
 ///
 /// This is used when persisting the state of the fork choice to disk.
-#[derive(Encode, Decode, Clone)]
+
+pub type PersistedForkChoice = PersistedForkChoiceV20;
+
+#[superstruct(
+    variants(V19, V20),
+    variant_attributes(derive(Encode, Decode, Clone)),
+    no_enum
+)]
 pub struct PersistedForkChoice {
     pub proto_array_bytes: Vec<u8>,
     queued_attestations: Vec<QueuedAttestation>,
+    #[superstruct(only(V20))]
+    pub anchor_state: AnchorState,
+}
+
+impl Into<PersistedForkChoiceV20> for PersistedForkChoiceV19 {
+    fn into(self) -> PersistedForkChoiceV20 {
+        PersistedForkChoiceV20 {
+            proto_array_bytes: self.proto_array_bytes,
+            queued_attestations: self.queued_attestations,
+            anchor_state: AnchorState::Finalized,
+        }
+    }
+}
+
+impl Into<PersistedForkChoiceV19> for PersistedForkChoiceV20 {
+    fn into(self) -> PersistedForkChoiceV19 {
+        PersistedForkChoiceV19 {
+            proto_array_bytes: self.proto_array_bytes,
+            queued_attestations: self.queued_attestations,
+        }
+    }
 }
 
 #[cfg(test)]

consensus/fork_choice/src/lib.rs

@@ -4,7 +4,8 @@ mod fork_choice_store;
 pub use crate::fork_choice::{
     AnchorState, AttestationFromBlock, Error, ForkChoice, ForkChoiceView,
     ForkchoiceUpdateParameters, InvalidAttestation, InvalidBlock, PayloadVerificationStatus,
-    PersistedForkChoice, QueuedAttestation, ResetPayloadStatuses,
+    PersistedForkChoice, PersistedForkChoiceV19, PersistedForkChoiceV20, QueuedAttestation,
+    ResetPayloadStatuses,
 };
 pub use fork_choice_store::ForkChoiceStore;
 pub use proto_array::{