refactor(blockchain): extract shared ProjectedState from block builder

Pull the round-by-round justification/finalization projection out of
select_attestations into a reusable ProjectedState with from_head_state()
and advance(), and widen entry_passes_filters, Tier, EntryScore,
OrderingKey, and EntryScore::ordering_key to pub(crate).

Block-building behavior is unchanged (the advance() body is the former
inline projection, and the current_votes update simply moves after the
trace it never fed). This exposes the projection and scoring primitives so
interval-2 aggregation can reuse them instead of duplicating the
justify/finalize logic.

Author: MegaRedHand

crates/blockchain/src/block_builder.rs

@@ -202,11 +202,7 @@ fn select_attestations(
     // Running per-target-root voter set, seeded from state and updated
     // incrementally as entries are selected. Mirrors the role of Eth2
     // participation flags in Prysm/Lighthouse-style packing.
-    let mut projected = ProjectedState {
-        justified_slots: head_state.justified_slots.clone(),
-        finalized_slot: head_state.latest_finalized.slot,
-        current_votes: build_running_votes(head_state),
-    };
+    let mut projected = ProjectedState::from_head_state(head_state);
     let mut processed_data_roots: HashSet<H256> = HashSet::new();
 
     // A block may carry at most `MAX_ATTESTATIONS_DATA` distinct entries
@@ -231,12 +227,6 @@ fn select_attestations(
         extend_proofs_greedily(proofs, &mut selected, att_data);
 
         let target_root = att_data.target.root;
-        projected
-            .current_votes
-            .entry(target_root)
-            .or_default()
-            .extend(new_voters);
-
         trace!(
             tier = ?score.tier,
             new_voters = score.new_voters,
@@ -247,29 +237,7 @@ fn select_attestations(
             "selected"
         );
 
-        // Project justification / finalization. Finalize implies Justify
-        // (target is justified, AND source is finalized).
-        if score.tier <= Tier::Justify {
-            justified_slots_ops::extend_to_slot(
-                &mut projected.justified_slots,
-                projected.finalized_slot,
-                att_data.target.slot,
-            );
-            justified_slots_ops::set_justified(
-                &mut projected.justified_slots,
-                projected.finalized_slot,
-                att_data.target.slot,
-            );
-            // Justified target's voter bucket is no longer relevant for
-            // scoring (no further entry can target it: filter rejects).
-            projected.current_votes.remove(&target_root);
-        }
-        if score.tier == Tier::Finalize {
-            let new_finalized = att_data.source.slot;
-            let delta = new_finalized.saturating_sub(projected.finalized_slot) as usize;
-            justified_slots_ops::shift_window(&mut projected.justified_slots, delta);
-            projected.finalized_slot = new_finalized;
-        }
+        projected.advance(score.tier, att_data, new_voters);
     }
 
     selected
@@ -336,13 +304,75 @@ struct ChainContext<'a> {
     validator_count: usize,
 }
 
-/// Mutable projection of the post-state that `select_attestations` maintains
-/// across rounds: which slots are justified, which slot is finalized, and the
-/// running per-target-root voter set.
-struct ProjectedState {
-    justified_slots: JustifiedSlots,
-    finalized_slot: u64,
-    current_votes: HashMap<H256, HashSet<u64>>,
+/// Mutable projection of the post-state that a tiered greedy selector
+/// maintains across rounds: which slots are justified, which slot is
+/// finalized, and the running per-target-root voter set.
+///
+/// Shared by `select_attestations` (block proposal) and
+/// `aggregation::snapshot_aggregation_inputs` (interval-2 aggregation) so the
+/// two selectors project justification/finalization identically. The
+/// aggregator's projection is optimistic (a produced proof is not a processed
+/// block), but that only affects the ordering of prover work within the
+/// deadline, never the correctness of any produced proof.
+pub(crate) struct ProjectedState {
+    pub(crate) justified_slots: JustifiedSlots,
+    pub(crate) finalized_slot: u64,
+    pub(crate) current_votes: HashMap<H256, HashSet<u64>>,
+}
+
+impl ProjectedState {
+    /// Seed the projection from the head state: justification/finalization as
+    /// of the head, and the running voter set derived from the state's
+    /// justification bitfields (see [`build_running_votes`]).
+    pub(crate) fn from_head_state(head_state: &State) -> Self {
+        Self {
+            justified_slots: head_state.justified_slots.clone(),
+            finalized_slot: head_state.latest_finalized.slot,
+            current_votes: build_running_votes(head_state),
+        }
+    }
+
+    /// Fold a selected entry into the projection: record its voters under the
+    /// entry's `target.root`, then advance justification/finalization per
+    /// `tier` (Finalize implies Justify). `new_voters` is the entry's marginal
+    /// voter set (block builder) or realized coverage (aggregator); the
+    /// resulting per-target voter set is the same union either way.
+    pub(crate) fn advance(
+        &mut self,
+        tier: Tier,
+        att_data: &AttestationData,
+        new_voters: impl IntoIterator<Item = u64>,
+    ) {
+        let target_root = att_data.target.root;
+        self.current_votes
+            .entry(target_root)
+            .or_default()
+            .extend(new_voters);
+
+        // Finalize implies Justify (target is justified, AND source is
+        // finalized).
+        if tier <= Tier::Justify {
+            justified_slots_ops::extend_to_slot(
+                &mut self.justified_slots,
+                self.finalized_slot,
+                att_data.target.slot,
+            );
+            justified_slots_ops::set_justified(
+                &mut self.justified_slots,
+                self.finalized_slot,
+                att_data.target.slot,
+            );
+            // Justified target's voter bucket is no longer relevant for
+            // scoring (no further entry can target it: filter rejects).
+            self.current_votes.remove(&target_root);
+        }
+        if tier == Tier::Finalize {
+            let new_finalized = att_data.source.slot;
+            let delta = new_finalized.saturating_sub(self.finalized_slot) as usize;
+            justified_slots_ops::shift_window(&mut self.justified_slots, delta);
+            self.finalized_slot = new_finalized;
+        }
+    }
 }
 
 /// Validate a candidate entry against the projected chain view.
@@ -355,7 +385,7 @@ struct ProjectedState {
 /// slot 0) is exempt from the `target.slot > source.slot` and
 /// `target_already_justified` checks since fork-choice bootstrapping needs
 /// it; STF will silently drop it, but it carries fork-choice signal.
-fn entry_passes_filters(
+pub(crate) fn entry_passes_filters(
     att_data: &AttestationData,
     known_block_roots: &HashSet<H256>,
     extended_historical_block_hashes: &[H256],
@@ -471,7 +501,7 @@ fn score_entry(
 /// output (`tier = Finalize` is clearer than `tier = 1`).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(u8)]
-enum Tier {
+pub(crate) enum Tier {
     /// Applying the entry crosses 2/3 on target AND finalizes the source
     /// (no slot strictly between source.slot and target.slot is still
     /// justifiable given projected finalized_slot).
@@ -499,23 +529,25 @@ enum Tier {
 ///
 /// In both tiers `data_root` (ascending) is the final deterministic tiebreak.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-struct EntryScore {
-    tier: Tier,
-    new_voters: usize,
+pub(crate) struct EntryScore {
+    pub(crate) tier: Tier,
+    pub(crate) new_voters: usize,
+    /// Read only inside [`EntryScore::ordering_key`]; kept private.
     target_slot: u64,
+    /// Read only inside [`EntryScore::ordering_key`]; kept private.
     att_slot: u64,
 }
 
 /// Total order over candidate entries; the smallest value is the best pick.
 /// `tier` leads, then three tier-dependent `Reverse`-encoded priorities, then
 /// `data_root` as the deterministic tiebreak. See [`EntryScore::ordering_key`].
-type OrderingKey = (Tier, Reverse<u64>, Reverse<u64>, Reverse<u64>, H256);
+pub(crate) type OrderingKey = (Tier, Reverse<u64>, Reverse<u64>, Reverse<u64>, H256);
 
 impl EntryScore {
     /// Sort key where the smallest tuple is the best candidate. `tier` always
     /// leads; the remaining three slots carry tier-dependent priorities (see
     /// the type-level docs), all encoded as `Reverse` so "larger is better".
-    fn ordering_key(&self, data_root: H256) -> OrderingKey {
+    pub(crate) fn ordering_key(&self, data_root: H256) -> OrderingKey {
         let more_new_voters = Reverse(self.new_voters as u64);
         let newer_target = Reverse(self.target_slot);
         let newer_att = Reverse(self.att_slot);