refactor(testing): derive tiebreaker weights from the spec (leanEthereum#863)

* refactor(testing): derive tiebreaker weights from the spec

The lexicographic head check re-derived per-fork attestation weights
by walking ancestors manually, duplicating the fork choice weight
rule. A spec change to weight accounting would silently diverge from
the re-derivation and the check would assert against stale logic.

The check now asks the spec for its block weights directly, so it
can never drift from the rule it validates. The unused per-fork slot
bookkeeping disappears with the manual walk.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(testing): polish store checks documentation

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: tcoratger

packages/testing/src/consensus_testing/test_types/store_checks.py

@@ -580,43 +580,24 @@ def _validate_lexicographic_head(
                 f"to test tiebreaker behavior, got {len(fork_labels)}: {fork_labels}"
             )
 
-        # Resolve all fork labels to roots and compute their weights
-        fork_data: dict[str, tuple[Bytes32, Slot, int]] = {}
+        # Resolve all fork labels to roots and compute their weights.
+        spec_block_weights = LstarSpec().compute_block_weights(store)
+
+        fork_data: dict[str, tuple[Bytes32, int]] = {}
         for label in fork_labels:
             if label not in block_registry:
                 raise ValueError(
                     f"Step {step_index}: lexicographic_head_among label '{label}' "
                     f"not found in block registry. Available: {list(block_registry.keys())}"
                 )
 
-            block = block_registry[label]
-            root = hash_tree_root(block)
-            slot = block.slot
-
-            spec = LstarSpec()
-            known_attestations = spec.extract_attestations_from_aggregated_payloads(
-                store, store.latest_known_aggregated_payloads
-            )
-            weight = 0
-            for attestation in known_attestations.values():
-                attestation_head_root = attestation.head.root
-                if attestation_head_root == root:
-                    weight += 1
-                elif attestation_head_root in store.blocks:
-                    ancestor_root = attestation_head_root
-                    while ancestor_root in store.blocks and store.blocks[ancestor_root].slot > slot:
-                        parent = store.blocks[ancestor_root].parent_root
-                        if parent == root:
-                            weight += 1
-                            break
-                        ancestor_root = parent
-
-            fork_data[label] = (root, slot, weight)
+            fork_root = hash_tree_root(block_registry[label])
+            fork_data[label] = (fork_root, spec_block_weights.get(fork_root, 0))
 
         # Verify all forks have equal weight
-        weights = [weight for _, _, weight in fork_data.values()]
+        weights = [weight for _, weight in fork_data.values()]
         if len(set(weights)) > 1:
-            weight_info = {label: weight for label, (_, _, weight) in fork_data.items()}
+            weight_info = {label: weight for label, (_, weight) in fork_data.items()}
             raise AssertionError(
                 f"Step {step_index}: lexicographic_head_among forks have "
                 f"unequal weights: {weight_info}. All forks must have equal "
@@ -625,7 +606,7 @@ def _validate_lexicographic_head(
                 f"applies when competing forks have identical weight."
             )
 
-        fork_roots = {label: root for label, (root, _, _) in fork_data.items()}
+        fork_roots = {label: root for label, (root, _) in fork_data.items()}
         expected_head_root = max(fork_roots.values())
 
         actual_head_root = store.head
@@ -639,7 +620,7 @@ def _validate_lexicographic_head(
             )
             fork_info = "\n".join(
                 f"  {label}: root=0x{root.hex()} weight={weight}"
-                for label, (root, _, weight) in sorted(fork_data.items())
+                for label, (root, weight) in sorted(fork_data.items())
             )
             raise AssertionError(
                 f"Step {step_index}: lexicographic tiebreaker failed.\n"