Merge remote-tracking branch 'origin/gloas-head-block-number' into glamsterdam-devnet-6

consensus/fork_choice/src/fork_choice.rs

@@ -1661,6 +1661,22 @@ where
         }
     }
 
+    /// Returns the latest ancestor of `block_root` whose `PayloadStatus` is `Full`.
+    pub fn latest_parent_full_block(
+        &self,
+        block_root: Hash256,
+        spec: &ChainSpec,
+    ) -> Result<Option<Hash256>, Error<T::Error>> {
+        if self.is_finalized_checkpoint_or_descendant(block_root) {
+            let proposer_boost_root = self.fc_store.proposer_boost_root();
+            self.proto_array
+                .latest_parent_full_block::<E>(block_root, proposer_boost_root, spec)
+                .map_err(Error::ProtoArrayError)
+        } else {
+            Err(Error::DoesNotDescendFromFinalizedCheckpoint)
+        }
+    }
+
     /// Returns the canonical payload status of a block. See
     /// `ProtoArrayForkChoice::get_canonical_payload_status`.
     pub fn get_canonical_payload_status(

consensus/proto_array/src/fork_choice_test_definition.rs

@@ -124,6 +124,14 @@ pub enum Operation {
         #[serde(default)]
         proposer_boost_root: Option<Hash256>,
     },
+    /// Assert the root returned by `latest_parent_full_block` for `block_root`.
+    AssertLatestFullPayloadBlock {
+        block_root: Hash256,
+        expected: Option<Hash256>,
+        /// Override the proposer boost root. Defaults to `Hash256::zero()`.
+        #[serde(default)]
+        proposer_boost_root: Option<Hash256>,
+    },
     /// Assert the result of `should_build_on_full` for the parent `block_root`, where
     /// `parent_payload_status` is the status the proposer would build on and `proposal_slot`
     /// is the slot being proposed.
@@ -616,6 +624,24 @@ impl ForkChoiceTestDefinition {
                         op_index
                     );
                 }
+                Operation::AssertLatestFullPayloadBlock {
+                    block_root,
+                    expected,
+                    proposer_boost_root,
+                } => {
+                    let actual = fork_choice
+                        .latest_parent_full_block::<MainnetEthSpec>(
+                            block_root,
+                            proposer_boost_root.unwrap_or_else(Hash256::zero),
+                            &spec,
+                        )
+                        .unwrap();
+                    assert_eq!(
+                        actual, expected,
+                        "latest_parent_full_block mismatch at op index {}",
+                        op_index,
+                    );
+                }
                 Operation::AssertShouldBuildOnFull {
                     block_root,
                     parent_payload_status,

consensus/proto_array/src/fork_choice_test_definition/gloas_payload.rs

@@ -1325,4 +1325,158 @@ mod tests {
         }
         .run();
     }
+
+    /// `latest_parent_full_block` returns the block itself when its own payload is Full.
+    #[test]
+    fn latest_full_payload_block_returns_head_when_full() {
+        let mut ops = vec![];
+
+        // Gloas block with a received payload, so it is Full at its own slot.
+        ops.push(Operation::ProcessBlock {
+            slot: Slot::new(1),
+            root: get_root(1),
+            parent_root: get_root(0),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            execution_payload_parent_hash: Some(get_hash(0)),
+            execution_payload_block_hash: Some(get_hash(1)),
+        });
+        ops.push(Operation::ProcessExecutionPayloadEnvelope {
+            block_root: get_root(1),
+        });
+
+        ops.push(Operation::AssertLatestFullPayloadBlock {
+            block_root: get_root(1),
+            expected: Some(get_root(1)),
+            proposer_boost_root: None,
+        });
+
+        ForkChoiceTestDefinition {
+            finalized_block_slot: Slot::new(0),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            operations: ops,
+            execution_payload_parent_hash: Some(get_hash(42)),
+            execution_payload_block_hash: Some(get_hash(0)),
+            spec: Some(gloas_spec()),
+        }
+        .run();
+    }
+
+    /// `latest_parent_full_block` walks back past Empty descendants to the latest Full ancestor.
+    ///
+    ///   root_1 (Full) -> root_2 (Empty) -> root_3 (Empty)
+    #[test]
+    fn latest_full_payload_block_walks_back_to_full_ancestor() {
+        let mut ops = vec![];
+
+        // root_1: payload received -> Full.
+        ops.push(Operation::ProcessBlock {
+            slot: Slot::new(1),
+            root: get_root(1),
+            parent_root: get_root(0),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            execution_payload_parent_hash: Some(get_hash(0)),
+            execution_payload_block_hash: Some(get_hash(1)),
+        });
+        ops.push(Operation::ProcessExecutionPayloadEnvelope {
+            block_root: get_root(1),
+        });
+
+        // root_2 and root_3: no payload received -> Empty.
+        ops.push(Operation::ProcessBlock {
+            slot: Slot::new(2),
+            root: get_root(2),
+            parent_root: get_root(1),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            execution_payload_parent_hash: Some(get_hash(1)),
+            execution_payload_block_hash: Some(get_hash(2)),
+        });
+        ops.push(Operation::ProcessBlock {
+            slot: Slot::new(3),
+            root: get_root(3),
+            parent_root: get_root(2),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            execution_payload_parent_hash: Some(get_hash(2)),
+            execution_payload_block_hash: Some(get_hash(3)),
+        });
+
+        ops.push(Operation::AssertLatestFullPayloadBlock {
+            block_root: get_root(3),
+            expected: Some(get_root(1)),
+            proposer_boost_root: None,
+        });
+
+        ForkChoiceTestDefinition {
+            finalized_block_slot: Slot::new(0),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            operations: ops,
+            execution_payload_parent_hash: Some(get_hash(42)),
+            execution_payload_block_hash: Some(get_hash(0)),
+            spec: Some(gloas_spec()),
+        }
+        .run();
+    }
+
+    /// `latest_parent_full_block` returns `None` when the walk reaches the pre-Gloas boundary
+    /// without finding a Full payload (the documented TODO case).
+    ///
+    ///   root_1 (V17, slot 31) -> root_2 (V29 Empty) -> root_3 (V29 Empty)
+    #[test]
+    fn latest_full_payload_block_none_at_pre_gloas_boundary() {
+        let mut ops = vec![];
+
+        // Pre-Gloas (V17) block at the last pre-Gloas slot.
+        ops.push(Operation::ProcessBlock {
+            slot: Slot::new(31),
+            root: get_root(1),
+            parent_root: get_root(0),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: None,
+        });
+
+        // Two Gloas (V29) blocks with no payload received -> Empty.
+        ops.push(Operation::ProcessBlock {
+            slot: Slot::new(32),
+            root: get_root(2),
+            parent_root: get_root(1),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            execution_payload_parent_hash: Some(get_hash(1)),
+            execution_payload_block_hash: Some(get_hash(2)),
+        });
+        ops.push(Operation::ProcessBlock {
+            slot: Slot::new(33),
+            root: get_root(3),
+            parent_root: get_root(2),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            execution_payload_parent_hash: Some(get_hash(2)),
+            execution_payload_block_hash: Some(get_hash(3)),
+        });
+
+        // The walk hits the V17 boundary block before any Full payload, so returns `None`.
+        ops.push(Operation::AssertLatestFullPayloadBlock {
+            block_root: get_root(3),
+            expected: None,
+            proposer_boost_root: None,
+        });
+
+        ForkChoiceTestDefinition {
+            finalized_block_slot: Slot::new(0),
+            justified_checkpoint: get_checkpoint(0),
+            finalized_checkpoint: get_checkpoint(0),
+            operations: ops,
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: None,
+            spec: Some(gloas_fork_boundary_spec()),
+        }
+        .run();
+    }
 }

consensus/proto_array/src/proto_array.rs

@@ -1302,6 +1302,33 @@ impl ProtoArray {
         }
     }
 
+    /// Returns the latest ancestor of `block_root` whose `PayloadStatus` is `Full`.
+    pub(crate) fn latest_parent_full_block<E: EthSpec>(
+        &self,
+        block_root: Hash256,
+        proposer_boost_root: Hash256,
+        justified_balances: &JustifiedBalances,
+        spec: &ChainSpec,
+    ) -> Result<Option<Hash256>, Error> {
+        for node in self.iter_nodes(&block_root) {
+            if node.as_v29().is_err() {
+                return Ok(None);
+            }
+
+            if self.get_canonical_payload_status::<E>(
+                node.root(),
+                node.slot(),
+                proposer_boost_root,
+                justified_balances,
+                spec,
+            )? == PayloadStatus::Full
+            {
+                return Ok(Some(node.root()));
+            }
+        }
+        Ok(None)
+    }
+
     /// Returns the canonical payload status of a block, matching the decision
     /// `get_head` would make between `(root, FULL)` and `(root, EMPTY)`.
     pub(crate) fn get_canonical_payload_status<E: EthSpec>(

consensus/proto_array/src/proto_array_fork_choice.rs

@@ -1041,6 +1041,21 @@ impl ProtoArrayForkChoice {
             .unwrap_or(false)
     }
 
+    /// Returns the latest ancestor of `block_root` whose `PayloadStatus` is `Full`.
+    pub fn latest_parent_full_block<E: EthSpec>(
+        &self,
+        block_root: Hash256,
+        proposer_boost_root: Hash256,
+        spec: &ChainSpec,
+    ) -> Result<Option<Hash256>, Error> {
+        self.proto_array.latest_parent_full_block::<E>(
+            block_root,
+            proposer_boost_root,
+            &self.balances,
+            spec,
+        )
+    }
+
     /// Returns the canonical payload status of a block, matching the decision
     /// `get_head` would make between `(root, FULL)` and `(root, EMPTY)`.
     pub fn get_canonical_payload_status<E: EthSpec>(