refactor(testing): consolidate consensus_testing genesis builders (leanEthereum#1153)

* refactor(testing): consolidate consensus_testing genesis builders

Collapse the genesis/anchor construction helpers into a small, consistent
surface and remove duplication.

- Merge the keyed and zeroed validator/state builders into one
  build_genesis_state(..., keyed=...); drop generate_pre_state,
  make_genesis_state, make_validators, _build_validators.
- Rename make_genesis_store to build_genesis_store and unify the build_ verb.
- Inline the trivial genesis-block reconstruction at its call sites and
  remove reconstruct_block_from_header.
- Let build_anchor handle slot 0 as the genesis case so build_genesis_store
  delegates to it; the genesis-block construction now lives in one place.
- Inline the former module-level defaults and default fork directly in
  signatures; whitelist the immutable Uint64/ValidatorIndex/LstarSpec calls
  in ruff's flake8-bugbear config.
- Update all call sites across tests/ and packages/.

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

* refactor(testing): restore reconstruct_block_from_header helper

The inlined genesis-block construction hurt readability across the
fixtures and tests. Bring the helper back, export it, and call it
again everywhere the block is rebuilt from a state's latest header,
including inside build_anchor.

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/__init__.py

@@ -5,10 +5,8 @@
 from consensus_testing import forks
 from consensus_testing.genesis import (
     build_anchor,
-    generate_pre_state,
-    make_genesis_state,
-    make_genesis_store,
-    make_validators,
+    build_genesis_state,
+    build_genesis_store,
     reconstruct_block_from_header,
 )
 from consensus_testing.mocks import (
@@ -197,12 +195,10 @@
     "BlockSpec",
     "forks",
     "build_anchor",
-    "generate_pre_state",
+    "build_genesis_state",
     # Unit-test builders and value constructors
     "reconstruct_block_from_header",
-    "make_genesis_state",
-    "make_genesis_store",
-    "make_validators",
+    "build_genesis_store",
     "create_mock_sync_service",
     "TEST_VALIDATOR_INDEX",
     "make_signed_attestation",

packages/testing/src/consensus_testing/genesis.py

@@ -1,4 +1,4 @@
-"""Consensus layer pre-state generation."""
+"""Consensus layer genesis state, block, and anchor construction for tests."""
 
 from consensus_testing.keys import XmssKeyManager
 from lean_spec.spec.crypto.merkleization import hash_tree_root
@@ -18,111 +18,98 @@
 from lean_spec.spec.forks.lstar.spec import LstarSpec
 from lean_spec.spec.ssz import Bytes52, Uint64
 
-_DEFAULT_GENESIS_TIME = Uint64(0)
 
-_DEFAULT_VALIDATOR_INDEX = ValidatorIndex(0)
-"""Owning validator for a genesis store, unless overridden."""
-
-
-def _build_validators(num_validators: int) -> Validators:
-    """Build a validator registry with real XMSS keys from the shared key manager."""
-    key_manager = XmssKeyManager.shared()
+def build_genesis_state(
+    num_validators: int = 4,
+    *,
+    genesis_time: Uint64 = Uint64(0),
+    keyed: bool = True,
+    fork: LstarSpec = LstarSpec(),
+) -> State:
+    """
+    Build a genesis pre-state for consensus tests.
 
-    if num_validators > len(key_manager):
-        raise ValueError(
-            f"Not enough keys: need {num_validators} validators "
-            f"but the key manager has only {len(key_manager)} keys"
-        )
+    Keyed validators get real signing keys from the shared key manager.
+    Unkeyed validators get zeroed keys, for tests that never check signatures.
 
-    validators = []
-    for validator_position in range(num_validators):
-        validator_index = ValidatorIndex(validator_position)
-        attestation_public_key, proposal_public_key = key_manager.get_public_keys(validator_index)
-        validators.append(
+    Raises:
+        ValueError: If keyed and the key manager holds fewer keys than requested.
+    """
+    if keyed:
+        key_manager = XmssKeyManager.shared()
+        if num_validators > len(key_manager):
+            raise ValueError(
+                f"Not enough keys: need {num_validators} validators "
+                f"but the key manager has only {len(key_manager)} keys"
+            )
+        validators = []
+        for validator_position in range(num_validators):
+            validator_index = ValidatorIndex(validator_position)
+            attestation_public_key, proposal_public_key = key_manager.get_public_keys(
+                validator_index
+            )
+            validators.append(
+                Validator(
+                    attestation_public_key=Bytes52(attestation_public_key.encode_bytes()),
+                    proposal_public_key=Bytes52(proposal_public_key.encode_bytes()),
+                    index=validator_index,
+                )
+            )
+    else:
+        validators = [
             Validator(
-                attestation_public_key=Bytes52(attestation_public_key.encode_bytes()),
-                proposal_public_key=Bytes52(proposal_public_key.encode_bytes()),
-                index=validator_index,
+                attestation_public_key=Bytes52(b"\x00" * 52),
+                proposal_public_key=Bytes52(b"\x00" * 52),
+                index=ValidatorIndex(validator_position),
             )
-        )
+            for validator_position in range(num_validators)
+        ]
 
-    return Validators(data=validators)
+    return fork.generate_genesis(
+        genesis_time=genesis_time,
+        validators=Validators(data=validators),
+    )
 
 
-def generate_pre_state(
-    fork: LstarSpec | None = None,
-    genesis_time: Uint64 = _DEFAULT_GENESIS_TIME,
-    num_validators: int = 4,
-) -> State:
+def reconstruct_block_from_header(state: State) -> Block:
     """
-    Generate a default pre-state for consensus tests.
-
-    Args:
-        fork: Fork dispatching genesis construction. Defaults to a fresh
-            LstarSpec instance.
-        genesis_time: The genesis timestamp.
-        num_validators: Number of validators to include.
+    Rebuild the block matching a state's latest header.
 
-    Returns:
-        A properly initialized consensus state.
+    The body is empty by the genesis and empty-block convention.
+    For a genesis state this is the genesis block.
     """
-    fork = fork or LstarSpec()
-    validators = _build_validators(num_validators)
-    return fork.generate_genesis(genesis_time=genesis_time, validators=validators)
+    return Block(
+        slot=state.latest_block_header.slot,
+        proposer_index=state.latest_block_header.proposer_index,
+        parent_root=state.latest_block_header.parent_root,
+        state_root=hash_tree_root(state),
+        body=BlockBody(attestations=AggregatedAttestations(data=[])),
+    )
 
 
 def build_anchor(
     num_validators: int,
     anchor_slot: Slot,
-    fork: LstarSpec | None = None,
-    genesis_time: Uint64 = _DEFAULT_GENESIS_TIME,
+    *,
+    fork: LstarSpec = LstarSpec(),
+    genesis_time: Uint64 = Uint64(0),
+    keyed: bool = True,
     synced: bool = False,
 ) -> tuple[State, Block]:
     """
-    Build a non-genesis anchor by advancing the genesis state to a slot.
-
-    By default the anchor keeps the genesis checkpoints, modelling a mid-chain
-    state that has not finalized anything yet.
+    Build an anchor by advancing the genesis state through a slot.
 
-    With synced set, it models a checkpoint-synced node instead: both checkpoints
-    pin to the anchor slot and the justification window rebases onto that boundary.
-
-    Either way the returned pair is internally consistent.
-    The block state root equals the hash of the state.
-
-    Args:
-        num_validators: Size of the validator set in the anchor state.
-        anchor_slot: Slot at which the anchor block lives. Must be > 0.
-        fork: Fork dispatching genesis construction.
-        genesis_time: Genesis timestamp for the underlying pre-state.
-        synced: Pin both checkpoints to the anchor slot, for checkpoint-sync vectors.
-
-    Returns:
-        A tuple of (anchor_state, anchor_block).
-
-    Raises:
-        ValueError: If anchor_slot is not strictly positive.
+    At slot 0 the advance loop is empty, so this returns the genesis pair.
     """
-    if anchor_slot <= Slot(0):
-        raise ValueError(
-            f"Anchor slot must be strictly positive, got {anchor_slot}. "
-            "For a genesis anchor use generate_pre_state instead."
-        )
-
-    fork = fork or LstarSpec()
-    state = generate_pre_state(fork=fork, genesis_time=genesis_time, num_validators=num_validators)
+    state = build_genesis_state(num_validators, genesis_time=genesis_time, keyed=keyed, fork=fork)
 
-    # Reconstruct the genesis block from the state's latest header.
-    # The genesis block is fully determined by the genesis state.
     current_block = reconstruct_block_from_header(state)
     parent_root = hash_tree_root(current_block)
 
     num_validators_u64 = Uint64(num_validators)
 
-    # Advance through empty blocks, one per slot, up to and including anchor_slot.
-    # Each block is built by the spec's own builder so the resulting state
-    # carries the real chain history (historical block hashes, justified slots,
-    # justification tracking) that a real mid-chain state would have.
+    # Advance one empty block per slot, up to and including the anchor.
+    # Using the spec's own builder gives the state real mid-chain history.
     for next_slot in range(1, int(anchor_slot) + 1):
         slot = Slot(next_slot)
         proposer_index = ValidatorIndex.proposer_for_slot(slot, num_validators_u64)
@@ -139,19 +126,13 @@ def build_anchor(
     if not synced:
         return state, current_block
 
-    # Rebase the state onto the anchor as a freshly checkpoint-synced node would see it.
-    #
-    # The empty-block advance leaves both checkpoints at the genesis boundary (slot 0).
-    # A node that syncs from this anchor trusts it as finalized at the anchor slot.
-    # So both checkpoints move to the anchor block at the anchor slot.
+    # Rebase the state as a freshly checkpoint-synced node would see it.
+    # Such a node trusts the anchor as finalized, so both checkpoints move there.
     anchor_root = hash_tree_root(current_block)
     anchor_checkpoint = Checkpoint(root=anchor_root, slot=anchor_slot)
 
-    # The justified-slots window is stored relative to the finalized boundary.
-    #
-    # Its first bit is the slot just after finalization.
-    # Moving the boundary forward by the anchor slot drops that many leading bits.
-    # No slot beyond the anchor is materialized, so the rebased window is empty.
+    # The justified-slots window starts at the slot after the finalized boundary.
+    # Moving that boundary to the anchor drops the leading bits; nothing past it exists.
     rebase_distance = int(anchor_slot - state.latest_finalized.slot)
     rebased_justified_slots = JustifiedSlots(data=state.justified_slots.data[rebase_distance:])
 
@@ -172,70 +153,27 @@ def build_anchor(
     return state, current_block
 
 
-def make_validators(count: int) -> Validators:
-    """Build a validator registry of the given size with zeroed public keys."""
-    return Validators(
-        data=[
-            Validator(
-                attestation_public_key=Bytes52(b"\x00" * 52),
-                proposal_public_key=Bytes52(b"\x00" * 52),
-                index=ValidatorIndex(validator_position),
-            )
-            for validator_position in range(count)
-        ]
-    )
-
-
-def make_genesis_state(num_validators: int = 3, genesis_time: int = 0) -> State:
-    """Build a genesis state with zeroed validator keys."""
-    return LstarSpec().generate_genesis(
-        genesis_time=Uint64(genesis_time),
-        validators=make_validators(num_validators),
-    )
-
-
-def reconstruct_block_from_header(state: State) -> Block:
-    """
-    Rebuild the block matching a state's latest header.
-
-    The header pins the slot, proposer index, and parent root.
-    The state root is the hash of the state itself.
-    The body is the empty body of the genesis and empty-block convention.
-
-    For a genesis state this is the genesis block.
-    """
-    return Block(
-        slot=state.latest_block_header.slot,
-        proposer_index=state.latest_block_header.proposer_index,
-        parent_root=state.latest_block_header.parent_root,
-        state_root=hash_tree_root(state),
-        body=BlockBody(attestations=AggregatedAttestations(data=[])),
-    )
-
-
-def make_genesis_store(
+def build_genesis_store(
     num_validators: int = 4,
     *,
     genesis_time: int = 0,
-    validator_index: ValidatorIndex | None = _DEFAULT_VALIDATOR_INDEX,
+    validator_index: ValidatorIndex | None = ValidatorIndex(0),
     observer: bool = False,
     keyed: bool = True,
     time: Interval | None = None,
 ) -> Store:
     """
     Build a genesis fork-choice store.
 
-    Uses real XMSS keys when keyed, else zeroed keys for any validator count.
     Set observer for a store with no owning validator.
     """
-    state = (
-        generate_pre_state(genesis_time=Uint64(genesis_time), num_validators=num_validators)
-        if keyed
-        else make_genesis_state(num_validators=num_validators, genesis_time=genesis_time)
+    # Slot 0 makes the anchor builder produce the genesis state and block pair.
+    state, genesis_block = build_anchor(
+        num_validators, Slot(0), genesis_time=Uint64(genesis_time), keyed=keyed
     )
     store = LstarSpec().create_store(
         state,
-        reconstruct_block_from_header(state),
+        genesis_block,
         validator_index=None if observer else validator_index,
     )
     return store if time is None else store.model_copy(update={"time": time})

packages/testing/src/consensus_testing/test_fixtures/api_endpoint.py

@@ -3,11 +3,7 @@
 from collections.abc import Callable
 from typing import Any, ClassVar
 
-from consensus_testing.genesis import (
-    build_anchor,
-    generate_pre_state,
-    reconstruct_block_from_header,
-)
+from consensus_testing.genesis import build_anchor
 from consensus_testing.test_fixtures.base import BaseConsensusFixture, BaseTestSpec
 from lean_spec.base import StrictBaseModel
 from lean_spec.spec.forks import Slot
@@ -50,15 +46,8 @@ def _build_store(num_validators: int, genesis_time: int, anchor_slot: int = 0) -
     historical roots, and multi-node fork-choice trees.
     """
     fork = LstarSpec()
-    if anchor_slot == 0:
-        state = generate_pre_state(
-            fork=fork, genesis_time=Uint64(genesis_time), num_validators=num_validators
-        )
-        block = reconstruct_block_from_header(state)
-        # No validator identity — fixture only reads store data, never signs.
-        return fork.create_store(state, block, validator_index=None)
-
     # Walk the chain from genesis through anchor_slot using empty blocks.
+    # Slot 0 makes the builder return the genesis pair with no advance.
     # The returned pair (state, block) is internally consistent with the
     # historical chain the fixture wants to present to the endpoint.
     state, block = build_anchor(
@@ -67,6 +56,7 @@ def _build_store(num_validators: int, genesis_time: int, anchor_slot: int = 0) -
         anchor_slot=Slot(anchor_slot),
         genesis_time=Uint64(genesis_time),
     )
+    # No validator identity — fixture only reads store data, never signs.
     return fork.create_store(state, block, validator_index=None)
 
 

packages/testing/src/consensus_testing/test_fixtures/fork_choice.py

@@ -6,7 +6,7 @@
 
 from pydantic import Field
 
-from consensus_testing.genesis import generate_pre_state, reconstruct_block_from_header
+from consensus_testing.genesis import build_genesis_state, reconstruct_block_from_header
 from consensus_testing.keys import XmssKeyManager
 from consensus_testing.test_fixtures.base import BaseConsensusFixture, BaseTestSpec
 from consensus_testing.test_types import (
@@ -85,7 +85,7 @@ class ForkChoiceTest(BaseTestSpec):
     description: ClassVar[str] = "Tests event-driven fork choice through Store operations"
     """Human-readable summary for fixture documentation."""
 
-    anchor_state: State = Field(default_factory=generate_pre_state)
+    anchor_state: State = Field(default_factory=build_genesis_state)
     """
     Initial trusted consensus state.
 
@@ -136,10 +136,7 @@ def _resolved_anchor_block(self) -> Block:
         """
         if self.anchor_block is not None:
             return self.anchor_block
-        # Build a minimal genesis block from the state's header fields.
-        #
-        # The state already contains the block header.
-        # We extract its fields to create a matching Block.
+        # The state already carries the block header, so rebuild the matching block.
         return reconstruct_block_from_header(self.anchor_state)
 
     def _resolved_max_slot(self) -> Slot:

packages/testing/src/consensus_testing/test_fixtures/state_transition.py

@@ -4,7 +4,7 @@
 
 from pydantic import Field, model_validator
 
-from consensus_testing.genesis import generate_pre_state
+from consensus_testing.genesis import build_genesis_state
 from consensus_testing.keys import XmssKeyManager
 from consensus_testing.test_fixtures.base import BaseConsensusFixture, BaseTestSpec
 from consensus_testing.test_types import AggregatedAttestationSpec, BlockSpec, StateExpectation
@@ -74,7 +74,7 @@ class StateTransitionTest(BaseTestSpec):
         "epochs, and finality"
     )
 
-    pre: State = Field(default_factory=generate_pre_state)
+    pre: State = Field(default_factory=build_genesis_state)
     """
     The initial consensus state before processing.