Only return viable payload-status variants from get_head

specs/bellatrix/optimistic-sync.md

@@ -371,7 +371,7 @@ verified or the block is older than `SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY`.
 These restraints are applied in order to mitigate an attack where a block which
 enables execution (a *transition block*) can reference a junk parent hash. This
 makes it impossible for honest nodes to build atop that block. If an attacker
-exploits a nuance in fork choice `filter_block_tree`, they can, in some rare
+exploits a nuance in fork choice `filter_node_tree`, they can, in some rare
 cases, produce a junk block that out-competes all locally produced blocks for
 the head. This prevents a node from producing a chain of blocks, therefore
 breaking liveness.

specs/gloas/fork-choice.md

@@ -36,6 +36,7 @@
   - [New `get_payload_status_tiebreaker`](#new-get_payload_status_tiebreaker)
   - [New `should_apply_proposer_boost`](#new-should_apply_proposer_boost)
   - [Modified `get_weight`](#modified-get_weight)
+  - [Modified `get_filtered_node_tree`](#modified-get_filtered_node_tree)
   - [Modified `get_node_children`](#modified-get_node_children)
   - [Modified `get_head`](#modified-get_head)
   - [Modified `get_latest_message_epoch`](#modified-get_latest_message_epoch)
@@ -585,15 +586,29 @@ def get_weight(store: Store, node: ForkChoiceNode) -> Gwei:
     return attestation_score + proposer_score
 ```
 
+### Modified `get_filtered_node_tree`
+
+```python
+def get_filtered_node_tree(store: Store) -> Sequence[ForkChoiceNode]:
+    """
+    Retrieve a filtered node tree from ``store``, only returning branches
+    whose leaf state's justified/finalized info agrees with that in ``store``.
+    """
+    # [Modified in Gloas:EIP7732]
+    base = ForkChoiceNode(
+        root=store.justified_checkpoint.root,
+        payload_status=PAYLOAD_STATUS_PENDING,
+    )
+    return filter_node_tree(store, base)
+```
+
 ### Modified `get_node_children`
 
 *Note*: This function is modified to introduce new type of children nodes
 representing *full* and *empty* blocks.
 
 ```python
-def get_node_children(
-    store: Store, blocks: Dict[Root, BeaconBlock], node: ForkChoiceNode
-) -> Sequence[ForkChoiceNode]:
+def get_node_children(store: Store, node: ForkChoiceNode) -> Sequence[ForkChoiceNode]:
     if node.payload_status == PAYLOAD_STATUS_PENDING:
         children = [ForkChoiceNode(root=node.root, payload_status=PAYLOAD_STATUS_EMPTY)]
         if is_payload_verified(store, node.root):
@@ -602,10 +617,10 @@ def get_node_children(
     else:
         return [
             ForkChoiceNode(root=root, payload_status=PAYLOAD_STATUS_PENDING)
-            for root in blocks
+            for root in store.blocks
             if (
-                blocks[root].parent_root == node.root
-                and node.payload_status == get_parent_payload_status(store, blocks[root])
+                store.blocks[root].parent_root == node.root
+                and node.payload_status == get_parent_payload_status(store, store.blocks[root])
             )
         ]
 ```
@@ -617,8 +632,18 @@ between *full* and *empty* nodes.
 
 ```python
 def get_head(store: Store) -> ForkChoiceNode:
-    # Get filtered block tree that only includes viable branches
-    blocks = get_filtered_block_tree(store)
+    # Get filtered node tree that only includes viable branches
+    filtered_node_tree = get_filtered_node_tree(store)
+
+    # [New in Gloas:EIP7732]
+    if not any(filtered_node_tree):
+        # Return empty node if there are no viable nodes
+        # to ensure that head is never a pending node
+        return ForkChoiceNode(
+            root=store.justified_checkpoint.root,
+            payload_status=PAYLOAD_STATUS_EMPTY,
+        )
+
     # Execute the LMD-GHOST fork-choice
     head = ForkChoiceNode(
         root=store.justified_checkpoint.root,
@@ -627,7 +652,9 @@ def get_head(store: Store) -> ForkChoiceNode:
     )
 
     while True:
-        children = get_node_children(store, blocks, head)
+        children = [
+            child for child in get_node_children(store, head) if child in filtered_node_tree
+        ]
         if len(children) == 0:
             return head
         # Sort by latest attesting balance with ties broken lexicographically

specs/phase0/fork-choice.md

@@ -26,9 +26,9 @@
     - [`get_proposer_score`](#get_proposer_score)
     - [`get_weight`](#get_weight)
     - [`get_voting_source`](#get_voting_source)
-    - [`filter_block_tree`](#filter_block_tree)
-    - [`get_filtered_block_tree`](#get_filtered_block_tree)
     - [`get_node_children`](#get_node_children)
+    - [`filter_node_tree`](#filter_node_tree)
+    - [`get_filtered_node_tree`](#get_filtered_node_tree)
     - [`get_head`](#get_head)
     - [`update_checkpoints`](#update_checkpoints)
     - [`update_unrealized_checkpoints`](#update_unrealized_checkpoints)
@@ -394,28 +394,38 @@ def get_voting_source(store: Store, block_root: Root) -> Checkpoint:
         return head_state.current_justified_checkpoint
 ```
 
-#### `filter_block_tree`
+#### `get_node_children`
+
+```python
+def get_node_children(
+    store: Store,
+    node: ForkChoiceNode,
+) -> Sequence[ForkChoiceNode]:
+    return [
+        ForkChoiceNode(root=root)
+        for root in store.blocks
+        if store.blocks[root].parent_root == node.root
+    ]
+```
 
-*Note*: External calls to `filter_block_tree` (i.e., any calls that are not made
-by the recursive logic in this function) MUST set `block_root` to
-`store.justified_checkpoint.root`.
+#### `filter_node_tree`
 
 ```python
-def filter_block_tree(store: Store, block_root: Root, blocks: Dict[Root, BeaconBlock]) -> bool:
-    block = store.blocks[block_root]
-    children = [root for root in store.blocks if store.blocks[root].parent_root == block_root]
+def filter_node_tree(store: Store, node: ForkChoiceNode) -> Sequence[ForkChoiceNode]:
+    children = get_node_children(store, node)
 
     # If any children branches contain expected finalized/justified checkpoints,
-    # add to filtered block-tree and signal viability to parent.
+    # include this node and those descendants in the filtered node tree.
     if any(children):
-        filter_block_tree_result = [filter_block_tree(store, child, blocks) for child in children]
-        if any(filter_block_tree_result):
-            blocks[block_root] = block
-            return True
-        return False
+        viable_nodes: list[ForkChoiceNode] = []
+        for child in children:
+            viable_nodes.extend(filter_node_tree(store, child))
+        if any(viable_nodes):
+            return viable_nodes + [node]
+        return []
 
     current_epoch = get_current_store_epoch(store)
-    voting_source = get_voting_source(store, block_root)
+    voting_source = get_voting_source(store, node.root)
 
     # The voting source should be either at the same height as the store's justified checkpoint or
     # not more than two epochs ago
@@ -427,7 +437,7 @@ def filter_block_tree(store: Store, block_root: Root, blocks: Dict[Root, BeaconB
 
     finalized_checkpoint_block = get_checkpoint_block(
         store,
-        block_root,
+        node.root,
         store.finalized_checkpoint.epoch,
     )
 
@@ -436,50 +446,38 @@ def filter_block_tree(store: Store, block_root: Root, blocks: Dict[Root, BeaconB
         or store.finalized_checkpoint.root == finalized_checkpoint_block
     )
 
-    # If expected finalized/justified, add to viable block-tree and signal viability to parent.
+    # If expected finalized/justified, add to viable node tree and signal viability to parent.
     if correct_justified and correct_finalized:
-        blocks[block_root] = block
-        return True
+        return [node]
 
     # Otherwise, branch not viable
-    return False
+    return []
 ```
 
-#### `get_filtered_block_tree`
+#### `get_filtered_node_tree`
 
 ```python
-def get_filtered_block_tree(store: Store) -> Dict[Root, BeaconBlock]:
+def get_filtered_node_tree(store: Store) -> Sequence[ForkChoiceNode]:
     """
-    Retrieve a filtered block tree from ``store``, only returning branches
+    Retrieve a filtered node tree from ``store``, only returning branches
     whose leaf state's justified/finalized info agrees with that in ``store``.
     """
-    base = store.justified_checkpoint.root
-    blocks: Dict[Root, BeaconBlock] = {}
-    filter_block_tree(store, base, blocks)
-    return blocks
-```
-
-#### `get_node_children`
-
-```python
-def get_node_children(
-    store: Store,  # noqa: ARG001
-    blocks: Dict[Root, BeaconBlock],
-    node: ForkChoiceNode,
-) -> Sequence[ForkChoiceNode]:
-    return [ForkChoiceNode(root=root) for root in blocks if blocks[root].parent_root == node.root]
+    base = ForkChoiceNode(root=store.justified_checkpoint.root)
+    return filter_node_tree(store, base)
 ```
 
 #### `get_head`
 
 ```python
 def get_head(store: Store) -> ForkChoiceNode:
-    # Get filtered block tree that only includes viable branches
-    blocks = get_filtered_block_tree(store)
+    # Get filtered node tree that only includes viable branches
+    filtered_node_tree = get_filtered_node_tree(store)
     # Execute the LMD-GHOST fork choice
     head = ForkChoiceNode(root=store.justified_checkpoint.root)
     while True:
-        children = get_node_children(store, blocks, head)
+        children = [
+            child for child in get_node_children(store, head) if child in filtered_node_tree
+        ]
         if len(children) == 0:
             return head
         # Sort by latest attesting balance with ties broken lexicographically