refactor: drop incidental churn from the heartbeat change

A pass over the branch diff for changes not required by the heartbeat work.
All are behavior-preserving; the point is to shrink what a reviewer reads.

- `build_block` keeps main's positional signature. The `BlockTarget` parameter
  object wrapped five existing arguments in order to add one, so
  `heartbeat_committee_size` moves to `ProposerConfig` instead, which every call
  site already builds. It is read once at startup: the persisted value is
  authoritative from first boot and cannot change at runtime.
- `SlotInterval::HeadUpdate` reverts to `EndOfSlot`, which was also colliding
  with the pre-existing `store::HeadUpdate` struct.
- `lean_fast_head_slot` is gone. It was set from the same expression as
  `lean_head_slot` two lines above, so it carried no information of its own;
  `lean_lagging_head_slot` stays.
- `lagging_head` drops off the fork-choice RPC response and the Hive driver
  snapshot, and `RLMD_LOOKBACK_LIMIT` off `/config/spec`; nothing read them.
  `HEARTBEAT_COMMITTEE_SIZE` stays, being the cross-client agreement check.
- The `DEFAULT_`/`MAX_HEARTBEAT_COMMITTEE_SIZE` re-export from
  `ethlambda-state-transition` is gone. `MAX_` was never reached through it and
  `DEFAULT_` only by two tests, both in crates already depending on
  `ethlambda-types`.
- Dead `seed_covered` parameter on `select_fold_children`, whose sole caller
  passed an empty set.
- An `on_stopped` doc comment reflowed to identical text, a stray blank line,
  and a `try_finalize` test covering logic this branch does not touch.

`JobSource` stays despite looking like more of the same: it is the only thing
routing prover time into `lean_heartbeat_fold_time_seconds`, the metric that
says whether a chosen `K` still fits inside its interval.

Author: MegaRedHand

bin/ethlambda/src/main.rs

@@ -262,6 +262,9 @@ async fn main() -> eyre::Result<()> {
         proposer_config: ProposerConfig {
             enable_proposer_aggregation: options.enable_proposer_aggregation,
             max_attestations_per_block: options.max_attestations_per_block,
+            // Read once here rather than per build: the persisted value is
+            // authoritative from first boot and cannot change at runtime.
+            heartbeat_committee_size: store.heartbeat_committee_size(),
         },
     };
 

crates/blockchain/src/block_builder.rs

@@ -56,26 +56,10 @@ pub struct ProposerConfig {
     /// Proposer-side self-limit only; clamped to `MAX_ATTESTATIONS_DATA` during
     /// selection so the block never exceeds the cap `on_block` enforces.
     pub max_attestations_per_block: usize,
-}
-
-/// Identity and chain context of the block being built: everything that names
-/// *which* block this is, as opposed to *what* goes in it (the candidate payloads)
-/// or *how much* goes in it (the [`ProposerConfig`] policy).
-///
-/// Grouped rather than passed positionally because `slot` is load-bearing in two
-/// places at once — it is the block's own slot and, minus one, the slot whose
-/// committee the heartbeat tier packs — and because the three fields describing
-/// the parent are only meaningful together.
-pub(crate) struct BlockTarget<'a> {
-    pub(crate) head_state: &'a State,
-    pub(crate) slot: u64,
-    pub(crate) proposer_index: u64,
-    pub(crate) parent_root: H256,
-    pub(crate) known_block_roots: &'a HashSet<H256>,
     /// The network's `K`. Used only to classify entries into
     /// [`Tier::Heartbeat`], never to validate anything, so a stale value builds a
     /// worse block rather than an invalid one.
-    pub(crate) heartbeat_committee_size: u64,
+    pub heartbeat_committee_size: u64,
 }
 
 /// Build a valid block on top of this state.
@@ -103,18 +87,15 @@ pub(crate) struct BlockTarget<'a> {
 /// clamped to `MAX_ATTESTATIONS_DATA` so the block never exceeds the cap
 /// `on_block` enforces on incoming blocks.
 pub(crate) fn build_block(
-    target: BlockTarget<'_>,
+    head_state: &State,
+    slot: u64,
+    proposer_index: u64,
+    parent_root: H256,
+    known_block_roots: &HashSet<H256>,
     aggregated_payloads: &HashMap<H256, (AttestationData, Vec<SingleMessageAggregate>)>,
     config: ProposerConfig,
 ) -> Result<(Block, Vec<SingleMessageAggregate>, PostBlockCheckpoints), StoreError> {
-    let BlockTarget {
-        head_state,
-        slot,
-        proposer_index,
-        parent_root,
-        known_block_roots,
-        heartbeat_committee_size,
-    } = target;
+    let heartbeat_committee_size = config.heartbeat_committee_size;
     info!(slot, proposer_index, "Building block");
 
     let select_start = Instant::now();
@@ -1065,7 +1046,7 @@ fn trace_skipped_attestation(reason: &'static str, att: &AttestationData, data_r
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ethlambda_state_transition::DEFAULT_HEARTBEAT_COMMITTEE_SIZE;
+    use ethlambda_types::constants::DEFAULT_HEARTBEAT_COMMITTEE_SIZE;
     use ethlambda_types::{
         attestation::{AggregatedAttestation, AggregationBits, AttestationData},
         block::{ByteList512KiB, MultiMessageAggregate, SignedBlock, SingleMessageAggregate},
@@ -1629,18 +1610,16 @@ mod tests {
 
         // Build the block; this should succeed (the bug: no size guard)
         let (block, signatures, _post_checkpoints) = build_block(
-            BlockTarget {
-                head_state: &head_state,
-                slot,
-                proposer_index,
-                parent_root,
-                known_block_roots: &known_block_roots,
-                heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
-            },
+            &head_state,
+            slot,
+            proposer_index,
+            parent_root,
+            &known_block_roots,
             &aggregated_payloads,
             ProposerConfig {
                 enable_proposer_aggregation: true,
                 max_attestations_per_block: MAX_ATTESTATIONS_DATA,
+                heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
             },
         )
         .expect("build_block should succeed");
@@ -1778,18 +1757,16 @@ mod tests {
 
         let build = |limit: usize| {
             build_block(
-                BlockTarget {
-                    head_state: &head_state,
-                    slot,
-                    proposer_index,
-                    parent_root,
-                    known_block_roots: &known_block_roots,
-                    heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
-                },
+                &head_state,
+                slot,
+                proposer_index,
+                parent_root,
+                &known_block_roots,
                 &aggregated_payloads,
                 ProposerConfig {
                     enable_proposer_aggregation: false,
                     max_attestations_per_block: limit,
+                    heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
                 },
             )
             .expect("build_block should succeed")
@@ -1907,18 +1884,16 @@ mod tests {
         aggregated_payloads.insert(data_root, (att_data.clone(), proofs));
 
         let (block, signatures, _post_checkpoints) = build_block(
-            BlockTarget {
-                head_state: &head_state,
-                slot,
-                proposer_index,
-                parent_root,
-                known_block_roots: &known_block_roots,
-                heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
-            },
+            &head_state,
+            slot,
+            proposer_index,
+            parent_root,
+            &known_block_roots,
             &aggregated_payloads,
             ProposerConfig {
                 enable_proposer_aggregation: false,
                 max_attestations_per_block: MAX_ATTESTATIONS_DATA,
+                heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
             },
         )
         .expect("build_block should succeed");
@@ -2216,18 +2191,16 @@ mod tests {
         known_block_roots.insert(hashes[0]);
 
         let (block, _signatures, post_checkpoints) = build_block(
-            BlockTarget {
-                head_state: &head_state,
-                slot,
-                proposer_index,
-                parent_root,
-                known_block_roots: &known_block_roots,
-                heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
-            },
+            &head_state,
+            slot,
+            proposer_index,
+            parent_root,
+            &known_block_roots,
             &aggregated_payloads,
             ProposerConfig {
                 enable_proposer_aggregation: true,
                 max_attestations_per_block: MAX_ATTESTATIONS_DATA,
+                heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
             },
         )
         .expect("build_block should succeed");
@@ -2355,18 +2328,16 @@ mod tests {
         known_block_roots.insert(hashes[0]);
 
         let (block, _signatures, post_checkpoints) = build_block(
-            BlockTarget {
-                head_state: &head_state,
-                slot,
-                proposer_index,
-                parent_root,
-                known_block_roots: &known_block_roots,
-                heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
-            },
+            &head_state,
+            slot,
+            proposer_index,
+            parent_root,
+            &known_block_roots,
             &aggregated_payloads,
             ProposerConfig {
                 enable_proposer_aggregation: true,
                 max_attestations_per_block: MAX_ATTESTATIONS_DATA,
+                heartbeat_committee_size: DEFAULT_HEARTBEAT_COMMITTEE_SIZE,
             },
         )
         .expect("build_block should succeed");

crates/blockchain/src/heartbeat_fold.rs

@@ -125,8 +125,7 @@ fn resolve_fold_job(
     known_proofs: &[SingleMessageAggregate],
     validators: &[Validator],
 ) -> Option<AggregationJob> {
-    let (children, accepted_child_ids) =
-        select_fold_children(new_proofs, known_proofs, HashSet::new(), validators);
+    let (children, accepted_child_ids) = select_fold_children(new_proofs, known_proofs, validators);
     let covered: HashSet<u64> = accepted_child_ids.iter().copied().collect();
 
     // B \ A, in ascending validator order (XMSS aggregation requires it, which
@@ -187,10 +186,9 @@ fn resolve_fold_job(
 fn select_fold_children(
     new_proofs: &[SingleMessageAggregate],
     known_proofs: &[SingleMessageAggregate],
-    seed_covered: HashSet<u64>,
     validators: &[Validator],
 ) -> (Vec<(Vec<ValidatorPublicKey>, ByteList512KiB)>, Vec<u64>) {
-    let mut covered = seed_covered;
+    let mut covered: HashSet<u64> = HashSet::new();
     let mut children = Vec::new();
     let mut child_ids: Vec<u64> = Vec::new();
 

crates/blockchain/src/lib.rs

@@ -92,10 +92,9 @@ pub const GOSSIP_DISPARITY_INTERVALS: u64 = 1;
 /// The four ticks inside a slot.
 ///
 /// Declared in wall-clock order; the discriminant is the interval index within
-/// the slot. `Aggregation` and `EndOfSlot` from the 5-interval grid are gone:
-/// committee aggregation is anchored to the interval-2 boundary rather than
-/// occupying a tick of its own, and the end-of-slot duties (promote payloads,
-/// log the tree, build the next block) fold into [`Self::HeadUpdate`].
+/// the slot. The 5-interval grid's `Aggregation` tick is gone: committee
+/// aggregation is now anchored to the interval-2 boundary rather than occupying
+/// a tick of its own, so its duties fold into [`Self::SafeTargetUpdate`].
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum SlotInterval {
     /// 0 ms. The slot's block arrives; import merges committee bits into the
@@ -109,7 +108,7 @@ pub(crate) enum SlotInterval {
     SafeTargetUpdate,
     /// 3000 ms. `lagging_head` then `fast_head`; promote payloads, log the tree,
     /// and build + publish the next slot's block aligned to its slot boundary.
-    HeadUpdate,
+    EndOfSlot,
 }
 
 impl SlotInterval {
@@ -122,7 +121,7 @@ impl SlotInterval {
             0 => Self::BlockPublication,
             1 => Self::AttestationProduction,
             2 => Self::SafeTargetUpdate,
-            3 => Self::HeadUpdate,
+            3 => Self::EndOfSlot,
             _ => unreachable!("slots only have {INTERVALS_PER_SLOT} intervals"),
         }
     }
@@ -354,7 +353,7 @@ impl BlockChainServer {
         // needs (those stragglers surface in the `late` section instead). Skip
         // empty snapshots so a missed round keeps the last set we saw. Pure
         // observability.
-        if interval == SlotInterval::HeadUpdate
+        if interval == SlotInterval::EndOfSlot
             && let Some(snapshot) = coverage::snapshot_new_payloads(&self.store)
         {
             self.pre_merge_coverage = Some(snapshot);
@@ -469,7 +468,7 @@ impl BlockChainServer {
             // `on_tick` skips the interval-0 tick whenever this build overruns
             // its interval. The head update itself runs inside `store::on_tick`
             // above, so the build sees this slot's `fast_head` as its parent.
-            SlotInterval::HeadUpdate => {
+            SlotInterval::EndOfSlot => {
                 let next_slot = slot + 1;
                 let next_proposer = self
                     .get_our_proposer(next_slot)
@@ -485,7 +484,6 @@ impl BlockChainServer {
         metrics::update_safe_target_slot(self.store.safe_target_slot());
         // Update head slot metrics (head may change when attestations are promoted at intervals 0/3)
         metrics::update_head_slot(self.store.head_slot());
-        metrics::update_fast_head_slot(self.store.head_slot());
         metrics::update_lagging_head_slot(self.store.lagging_head_slot());
 
         // Advance XMSS keys for next slot so the signing paths don't have to
@@ -1479,9 +1477,9 @@ impl BlockChainServer {
     }
 
     /// Actor lifecycle hook: wait for any in-flight aggregation worker to exit
-    /// before the actor is fully stopped. We cancel the session's token and wait up
-    /// to PRIOR_WORKER_JOIN_TIMEOUT for the worker's current `aggregate_job` call
-    /// to finish (the proof itself cannot be interrupted).
+    /// before the actor is fully stopped. We cancel the session's token and
+    /// wait up to PRIOR_WORKER_JOIN_TIMEOUT for the worker's current
+    /// `aggregate_job` call to finish (the proof itself cannot be interrupted).
     #[stopped]
     async fn on_stopped(&mut self, _ctx: &Context<Self>) {
         let Some(session) = self.current_aggregation.take() else {

crates/blockchain/src/metrics.rs

@@ -700,18 +700,6 @@ pub fn update_safe_target_slot(slot: u64) {
 
 // --- Heartbeat / two-tier fork choice ---
 
-/// Set the fast-head gauge.
-///
-/// Tracks the same value as `lean_head_slot` (the fast head *is* the store head);
-/// exported under its own name so dashboards can pair it with
-/// `lean_lagging_head_slot` without relying on that equivalence holding forever.
-pub fn update_fast_head_slot(slot: u64) {
-    static LEAN_FAST_HEAD_SLOT: std::sync::LazyLock<IntGauge> = std::sync::LazyLock::new(|| {
-        register_int_gauge!("lean_fast_head_slot", "Fast head slot (GHOST-Eph)").unwrap()
-    });
-    LEAN_FAST_HEAD_SLOT.set(slot.try_into().unwrap());
-}
-
 /// Set the lagging-head gauge: the RLMD-window tree base.
 ///
 /// A frozen lagging head under a moving fast head is the RLMD-window failure

crates/blockchain/src/store.rs

@@ -22,7 +22,7 @@ use tracing::{info, trace, warn};
 use crate::{
     GOSSIP_DISPARITY_INTERVALS, INTERVALS_PER_SLOT, MAX_ATTESTATIONS_DATA,
     MILLISECONDS_PER_INTERVAL, MILLISECONDS_PER_SLOT, RLMD_LOOKBACK_LIMIT, SlotInterval,
-    block_builder::{BlockTarget, PostBlockCheckpoints, ProposerConfig, build_block},
+    block_builder::{PostBlockCheckpoints, ProposerConfig, build_block},
     metrics,
 };
 
@@ -569,7 +569,7 @@ pub fn on_tick(store: &mut Store, timestamp_ms: u64, has_proposal: bool) {
                 // Update safe target for validators
                 update_safe_target(store);
             }
-            SlotInterval::HeadUpdate => {
+            SlotInterval::EndOfSlot => {
                 // Recompute the tree base from the RLMD window, then the fast
                 // head on top of it, before promoting this slot's payloads and
                 // logging the resulting tree.
@@ -1103,7 +1103,6 @@ pub fn get_attestation_target_with_checkpoints(
             .expect("parent block exists")
             .unwrap();
     }
-
     // Guard: clamp target to justified (not in the spec).
     //
     // The spec's walk-back has no lower bound, so it can produce attestations
@@ -1249,14 +1248,11 @@ pub fn produce_block_with_signatures(
     let (block, signatures, post_checkpoints) = {
         let _timing = metrics::time_block_building_payload_aggregation();
         build_block(
-            BlockTarget {
-                head_state: &head_state,
-                slot,
-                proposer_index: validator_index,
-                parent_root: head_root,
-                known_block_roots: &known_block_roots,
-                heartbeat_committee_size: store.heartbeat_committee_size(),
-            },
+            &head_state,
+            slot,
+            validator_index,
+            head_root,
+            &known_block_roots,
             &aggregated_payloads,
             config,
         )?