address review comment on pruned blocks

Author: bomanaps

lean_client/fork_choice/src/handlers.rs

@@ -7,7 +7,9 @@ use metrics::METRICS;
 use ssz::{H256, SszHash};
 use tracing::warn;
 
-use crate::store::{INTERVALS_PER_SLOT, MILLIS_PER_INTERVAL, Store, tick_interval, update_head};
+use crate::store::{
+    INTERVALS_PER_SLOT, MILLIS_PER_INTERVAL, STATE_PRUNE_BUFFER, Store, tick_interval, update_head,
+};
 
 #[inline]
 pub fn on_tick(store: &mut Store, time_millis: u64, has_proposal: bool) {
@@ -463,11 +465,8 @@ fn process_block_internal(
         "Block processed - new state info"
     );
 
-    // Store block and state, store the plain Block (not SignedBlockWithAttestation)
     store.blocks.insert(block_root, block.clone());
     store.states.insert(block_root, new_state.clone());
-    // Also store signed block for serving BlocksByRoot requests (checkpoint sync backfill)
-    store.signed_blocks.insert(block_root, signed_block.clone());
 
     // Retry attestations that arrived before this block was known.
     // Drain the queue for this root and re-process each attestation.
@@ -525,6 +524,13 @@ fn process_block_internal(
             };
             metrics.lean_latest_finalized_slot.set(slot);
         });
+
+        let keep_from = store
+            .latest_finalized
+            .slot
+            .0
+            .saturating_sub(STATE_PRUNE_BUFFER);
+        store.states.retain(|_, state| state.slot.0 >= keep_from);
     }
 
     if !justified_updated && !finalized_updated {

lean_client/fork_choice/src/store.rs

@@ -63,14 +63,10 @@ pub struct Store {
     pub latest_new_aggregated_payloads: HashMap<SignatureKey, Vec<AggregatedSignatureProof>>,
 
     /// Attestation data indexed by hash (data_root).
-    /// Used to look up the exact attestation data that was signed,
-    /// matching ream's attestation_data_by_root_provider design.
+    /// Used to look up the exact attestation data that was signed when
+    /// processing aggregated payloads for safe target computation.
     pub attestation_data_by_root: HashMap<H256, AttestationData>,
 
-    /// Signed blocks indexed by block root.
-    /// Used to serve BlocksByRoot requests to peers for checkpoint sync backfill.
-    pub signed_blocks: HashMap<H256, SignedBlockWithAttestation>,
-
     /// Gossip attestations waiting for referenced blocks to arrive.
     /// Keyed by the missing block root. Drained when that block is processed.
     pub pending_attestations: HashMap<H256, Vec<SignedAttestation>>,
@@ -86,6 +82,13 @@ pub struct Store {
 
 const JUSTIFICATION_LOOKBACK_SLOTS: u64 = 3;
 
+/// Number of slots before the finalized slot for which states are retained.
+/// States older than (finalized_slot - STATE_PRUNE_BUFFER) are pruned after
+/// each finalization advance. The buffer covers late-arriving blocks and rapid
+/// finalization jumps without risk of evicting a parent state still needed
+/// for an in-flight state transition.
+pub const STATE_PRUNE_BUFFER: u64 = 128;
+
 impl Store {
     pub fn produce_attestation_data(&self, slot: Slot) -> Result<AttestationData> {
         let head_checkpoint = Checkpoint {
@@ -226,7 +229,6 @@ pub fn get_forkchoice_store(
         latest_known_aggregated_payloads: HashMap::new(),
         latest_new_aggregated_payloads: HashMap::new(),
         attestation_data_by_root: HashMap::new(),
-        signed_blocks: [(block_root, anchor_block)].into(),
         pending_attestations: HashMap::new(),
         pending_aggregated_attestations: HashMap::new(),
         pending_fetch_roots: HashSet::new(),

lean_client/networking/src/network/service.rs

@@ -771,9 +771,6 @@ where
                                     let root = block.message.block.hash_tree_root();
                                     provider.insert(root, block.clone());
                                 }
-                                // Prune finalized blocks — they can never be processed.
-                                let finalized_slot = self.status_provider.read().finalized.slot.0;
-                                provider.retain(|_, b| b.message.block.slot.0 > finalized_slot);
                                 // Hard cap: evict lowest-slot blocks if still over limit.
                                 if provider.len() > MAX_BLOCK_CACHE_SIZE {
                                     let to_remove = provider.len() - MAX_BLOCK_CACHE_SIZE;

lean_client/src/main.rs

@@ -877,9 +877,6 @@ async fn main() -> Result<()> {
                             {
                                 let mut provider = signed_block_provider.write();
                                 provider.insert(block_root, signed_block_with_attestation.clone());
-                                // Prune finalized blocks — they can never be processed.
-                                let finalized_slot = status_provider.read().finalized.slot.0;
-                                provider.retain(|_, b| b.message.block.slot.0 > finalized_slot);
                                 // Hard cap: evict lowest-slot blocks if still over limit.
                                 if provider.len() > MAX_BLOCK_CACHE_SIZE {
                                     let to_remove = provider.len() - MAX_BLOCK_CACHE_SIZE;