Merge of #8324

Author: mergify[bot]

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -1412,10 +1412,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     ///
     /// Returns `(block_root, block_slot)`.
     pub fn heads(&self) -> Vec<(Hash256, Slot)> {
-        self.canonical_head
-            .fork_choice_read_lock()
+        let fork_choice = self.canonical_head.fork_choice_read_lock();
+        fork_choice
             .proto_array()
-            .heads_descended_from_finalization::<T::EthSpec>()
+            .heads_descended_from_finalization::<T::EthSpec>(fork_choice.finalized_checkpoint())
             .iter()
             .map(|node| (node.root, node.slot))
             .collect()

beacon_node/beacon_chain/src/schema_change/migration_schema_v23.rs

@@ -122,7 +122,7 @@ pub fn downgrade_from_v23<T: BeaconChainTypes>(
 
     let heads = fork_choice
         .proto_array()
-        .heads_descended_from_finalization::<T::EthSpec>();
+        .heads_descended_from_finalization::<T::EthSpec>(fork_choice.finalized_checkpoint());
 
     let head_roots = heads.iter().map(|node| node.root).collect();
     let head_slots = heads.iter().map(|node| node.slot).collect();

beacon_node/http_api/src/lib.rs

@@ -3037,8 +3037,8 @@ pub fn serve<T: BeaconChainTypes>(
                         })
                         .collect::<Vec<_>>();
                     Ok(ForkChoice {
-                        justified_checkpoint: proto_array.justified_checkpoint,
-                        finalized_checkpoint: proto_array.finalized_checkpoint,
+                        justified_checkpoint: beacon_fork_choice.justified_checkpoint(),
+                        finalized_checkpoint: beacon_fork_choice.finalized_checkpoint(),
                         fork_choice_nodes,
                     })
                 })

beacon_node/http_api/tests/tests.rs

@@ -3057,11 +3057,11 @@ impl ApiTester {
 
         assert_eq!(
             result.justified_checkpoint,
-            expected_proto_array.justified_checkpoint
+            beacon_fork_choice.justified_checkpoint()
         );
         assert_eq!(
             result.finalized_checkpoint,
-            expected_proto_array.finalized_checkpoint
+            beacon_fork_choice.finalized_checkpoint()
         );
 
         let expected_fork_choice_nodes: Vec<ForkChoiceNode> = expected_proto_array

consensus/fork_choice/src/fork_choice.rs

@@ -627,7 +627,7 @@ where
         op: &InvalidationOperation,
     ) -> Result<(), Error<T::Error>> {
         self.proto_array
-            .process_execution_payload_invalidation::<E>(op)
+            .process_execution_payload_invalidation::<E>(op, self.finalized_checkpoint())
             .map_err(Error::FailedToProcessInvalidExecutionPayload)
     }
 
@@ -908,6 +908,8 @@ where
                 unrealized_finalized_checkpoint: Some(unrealized_finalized_checkpoint),
             },
             current_slot,
+            self.justified_checkpoint(),
+            self.finalized_checkpoint(),
         )?;
 
         Ok(())
@@ -1288,7 +1290,7 @@ where
     /// Return `true` if `block_root` is equal to the finalized checkpoint, or a known descendant of it.
     pub fn is_finalized_checkpoint_or_descendant(&self, block_root: Hash256) -> bool {
         self.proto_array
-            .is_finalized_checkpoint_or_descendant::<E>(block_root)
+            .is_finalized_checkpoint_or_descendant::<E>(block_root, self.finalized_checkpoint())
     }
 
     pub fn is_descendant(&self, ancestor_root: Hash256, descendant_root: Hash256) -> bool {
@@ -1508,7 +1510,9 @@ where
     /// be instantiated again later.
     pub fn to_persisted(&self) -> PersistedForkChoice {
         PersistedForkChoice {
-            proto_array: self.proto_array().as_ssz_container(),
+            proto_array: self
+                .proto_array()
+                .as_ssz_container(self.justified_checkpoint(), self.finalized_checkpoint()),
             queued_attestations: self.queued_attestations().to_vec(),
         }
     }

consensus/proto_array/src/fork_choice_test_definition.rs

@@ -212,7 +212,12 @@ impl ForkChoiceTestDefinition {
                         unrealized_finalized_checkpoint: None,
                     };
                     fork_choice
-                        .process_block::<MainnetEthSpec>(block, slot)
+                        .process_block::<MainnetEthSpec>(
+                            block,
+                            slot,
+                            self.justified_checkpoint,
+                            self.finalized_checkpoint,
+                        )
                         .unwrap_or_else(|e| {
                             panic!(
                                 "process_block op at index {} returned error: {:?}",
@@ -272,7 +277,10 @@ impl ForkChoiceTestDefinition {
                         }
                     };
                     fork_choice
-                        .process_execution_payload_invalidation::<MainnetEthSpec>(&op)
+                        .process_execution_payload_invalidation::<MainnetEthSpec>(
+                            &op,
+                            self.finalized_checkpoint,
+                        )
                         .unwrap()
                 }
                 Operation::AssertWeight { block_root, weight } => assert_eq!(
@@ -305,7 +313,8 @@ fn get_checkpoint(i: u64) -> Checkpoint {
 }
 
 fn check_bytes_round_trip(original: &ProtoArrayForkChoice) {
-    let bytes = original.as_bytes();
+    // The checkpoint are ignored `ProtoArrayForkChoice::from_bytes` so any value is ok
+    let bytes = original.as_bytes(Checkpoint::default(), Checkpoint::default());
     let decoded = ProtoArrayForkChoice::from_bytes(&bytes, original.balances.clone())
         .expect("fork choice should decode from bytes");
     assert!(