feat(blockchain): advance XMSS preparation window preemptively (#332)

## 🗒️ Description / Motivation

This PR closes #262.

Every 65,536 slots, an XMSS signing key has to precompute its next
bottom tree via leansig's
[`advance_preparation`](https://github.com/leanEthereum/leanSig). The
two most recently computed trees form a sliding "prepared window" of
131,072 slots - the range the key can sign for without doing more work.
Once the wall-clock slot crosses out of that window, the precomputation
has to run before the next signature.

PR #261 made `advance_preparation()` run synchronously on the
`BlockChainServer` actor's tick handler. When the window has to slide
forward, the actor blocks on the hash work long enough to stall other
executions.

This PR moves that advance **off the signing path**, running it
preemptively where blocking is cheap:

- **At startup**, in `BlockChain::spawn` (before the actor starts
ticking) - catches each loaded key's prepared window up to the current
wall-clock slot. Handles long offline gaps.
- **At the end of every tick**, after the interval's duties - advances
each key's window to cover `slot + 1`, so the next tick's signing is
always inside the prepared window.

The lazy advance loop inside `sign_with_*` is kept as a safety net, with
added `elapsed_ms` timing logs so we'd see it if it ever fires.

## What Changed

**`crates/blockchain/src/key_manager.rs`**
- New `KeyManager::advance_keys_to(slot)` - iterates registered
validators and advances both attestation and proposal keys to cover
`slot`.
- New free helper `advance_key(...)` - synchronous advance loop with
`Instant::now()` timing. Emits `info!` at start, `info!` with
`elapsed_ms` at end, `warn!` on activation-interval exhaustion.
- Added matching `Instant::now()` + `elapsed_ms` `info!` to the
pre-existing advance loops in `sign_with_attestation_key` /
`sign_with_proposal_key`.

**`crates/blockchain/src/lib.rs`**
- `BlockChain::spawn`: computes current wall-clock slot and calls
`key_manager.advance_keys_to(current_slot)` before the actor starts
ticking.
- `on_tick`: at the very end, after metric updates, calls
`self.key_manager.advance_keys_to((slot + 1) as u32)`.

## Correctness / Behavior Guarantees

- Signing is never delayed by an advance - preempt runs at the idle tail
of the interval (or before any tick fires, at startup).
- Steady-state: the end-of-tick advance is a no-op in 65,535 out of
every 65,536 slots.
- After a long offline gap: startup catch-up walks the window forward
before any tick fires.
- Activation-interval exhaustion stays a hard error in the signing path;
`advance_key` logs `warn!` and breaks so the next sign attempt surfaces
the error.
- `ValidatorKeyPair` shape and the `KeyManagerError` enum are unchanged
from main.

## Tests Added / Run

- [x] `make fmt` clean
- [x] `make lint` clean
- [x] `make test` passes
- [ ] Boundary-crossing verification on devnet - only fires every 65,536
slots, deferred to operational verification. Log lines `Preparing XMSS
key for slot in background` (start) and `XMSS key advance complete`
(success) signal the path firing.

## Related Issues / PRs

- Initially linked to #262 
- Follow-up to #261

---------

Co-authored-by: Tomás Grüner <47506558+MegaRedHand@users.noreply.github.com>
Co-authored-by: Pablo Deymonnaz <pdeymon@fi.uba.ar>

Author: 3 people

crates/blockchain/src/key_manager.rs

@@ -1,11 +1,12 @@
 use std::collections::HashMap;
+use std::time::Instant;
 
 use ethlambda_types::{
     attestation::{AttestationData, XmssSignature},
     primitives::{H256, HashTreeRoot as _},
     signature::{ValidatorSecretKey, ValidatorSignature},
 };
-use tracing::info;
+use tracing::{info, warn};
 
 use crate::metrics;
 
@@ -48,6 +49,14 @@ impl KeyManager {
         self.keys.keys().copied().collect()
     }
 
+    /// Advances every validator's XMSS preparation windows to cover slot
+    pub fn advance_keys_to(&mut self, slot: u32) {
+        for (validator_id, key_pair) in self.keys.iter_mut() {
+            advance_key(*validator_id, &mut key_pair.attestation_key, slot);
+            advance_key(*validator_id, &mut key_pair.proposal_key, slot);
+        }
+    }
+
     /// Signs an attestation using the validator's attestation key.
     pub fn sign_attestation(
         &mut self,
@@ -85,6 +94,7 @@ impl KeyManager {
         // Multiple advances may be needed if the node was offline for an extended period.
         if !key_pair.attestation_key.is_prepared_for(slot) {
             info!(validator_id, slot, "Advancing XMSS key preparation window");
+            let start = Instant::now();
             while !key_pair.attestation_key.is_prepared_for(slot) {
                 let before = key_pair.attestation_key.get_prepared_interval();
                 key_pair.attestation_key.advance_preparation();
@@ -95,6 +105,12 @@ impl KeyManager {
                     )));
                 }
             }
+            info!(
+                validator_id,
+                slot,
+                elapsed_ms = start.elapsed().as_millis() as u64,
+                "Advanced XMSS key preparation window"
+            );
         }
 
         let signature: ValidatorSignature = {
@@ -130,6 +146,7 @@ impl KeyManager {
                 validator_id,
                 slot, "Advancing XMSS proposal key preparation window"
             );
+            let start = Instant::now();
             while !key_pair.proposal_key.is_prepared_for(slot) {
                 let before = key_pair.proposal_key.get_prepared_interval();
                 key_pair.proposal_key.advance_preparation();
@@ -140,6 +157,12 @@ impl KeyManager {
                     )));
                 }
             }
+            info!(
+                validator_id,
+                slot,
+                elapsed_ms = start.elapsed().as_millis() as u64,
+                "Advanced XMSS proposal key preparation window"
+            );
         }
 
         let signature: ValidatorSignature = key_pair
@@ -153,6 +176,28 @@ impl KeyManager {
     }
 }
 
+fn advance_key(validator_id: u64, key: &mut ValidatorSecretKey, slot: u32) {
+    if key.is_prepared_for(slot) {
+        return;
+    }
+    info!(validator_id, slot, "Advancing XMSS key preparation window");
+    let start = Instant::now();
+    while !key.is_prepared_for(slot) {
+        let before = key.get_prepared_interval();
+        key.advance_preparation();
+        if key.get_prepared_interval() == before {
+            warn!(validator_id, slot, "XMSS key activation interval exhausted");
+            break;
+        }
+    }
+    info!(
+        validator_id,
+        slot,
+        elapsed_ms = start.elapsed().as_millis() as u64,
+        "Advanced XMSS key preparation window"
+    );
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/blockchain/src/lib.rs

@@ -64,7 +64,19 @@ impl BlockChain {
         metrics::set_is_aggregator(aggregator.is_enabled());
         metrics::set_node_sync_status(metrics::SyncStatus::Idle);
         let genesis_time = store.config().genesis_time;
-        let key_manager = key_manager::KeyManager::new(validator_keys);
+        let mut key_manager = key_manager::KeyManager::new(validator_keys);
+
+        // Catch XMSS keys up to the current slot before the first tick
+        // store.time() doesn't work here: after an offline gap it lags wall-clock by
+        // exactly the gap we need to catch up through
+        let now_ms = SystemTime::UNIX_EPOCH
+            .elapsed()
+            .expect("already past the unix epoch")
+            .as_millis() as u64;
+        let current_slot =
+            (now_ms.saturating_sub(genesis_time * 1000) / MILLISECONDS_PER_SLOT) as u32;
+        key_manager.advance_keys_to(current_slot);
+
         let handle = BlockChainServer {
             store,
             p2p: None,
@@ -195,6 +207,9 @@ impl BlockChainServer {
         metrics::update_safe_target_slot(self.store.safe_target_slot());
         // Update head slot metric (head may change when attestations are promoted at intervals 0/4)
         metrics::update_head_slot(self.store.head_slot());
+
+        // Advance XMSS keys for next slot so the signing paths don't have to
+        self.key_manager.advance_keys_to((slot + 1) as u32);
     }
 
     /// Kick off a committee-signature aggregation session: