fix: query shuffling from cache to compute proposer lookahead (#7988)

**Motivation**

Right now we always compute shuffling during epoch transition when
processing proposer lookahead (`processProposerLookahead()`) post fulu
but it should already be in cache most of the time.

**Description**

Query shuffling from cache to compute proposer lookahead

Author: nflaig

packages/beacon-node/test/spec/presets/epoch_processing.test.ts

@@ -47,9 +47,9 @@ const epochTransitionFns: Record<string, EpochTransitionFn> = {
   historical_summaries_update: epochFns.processHistoricalSummariesUpdate as EpochTransitionFn,
   pending_deposits: epochFns.processPendingDeposits as EpochTransitionFn,
   pending_consolidations: epochFns.processPendingConsolidations as EpochTransitionFn,
-  proposer_lookahead: (state, _) => {
+  proposer_lookahead: (state, epochTransitionCache) => {
     const fork = state.config.getForkSeq(state.slot);
-    epochFns.processProposerLookahead(fork, state as CachedBeaconStateFulu);
+    epochFns.processProposerLookahead(fork, state as CachedBeaconStateFulu, epochTransitionCache);
   },
 };
 

packages/state-transition/src/epoch/index.ts

@@ -194,7 +194,7 @@ export function processEpoch(
     const timer = metrics?.epochTransitionStepTime.startTimer({
       step: EpochTransitionStep.processProposerLookahead,
     });
-    processProposerLookahead(fork, state as CachedBeaconStateFulu);
+    processProposerLookahead(fork, state as CachedBeaconStateFulu, cache);
     timer?.();
   }
 }

packages/state-transition/src/epoch/processProposerLookahead.ts

@@ -1,6 +1,7 @@
 import {ForkSeq, MIN_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
-import {CachedBeaconStateFulu} from "../types.js";
+import {CachedBeaconStateFulu, EpochTransitionCache} from "../types.js";
+import {computeEpochShuffling} from "../util/epochShuffling.js";
 import {computeProposerIndices} from "../util/seed.js";
 
 /**
@@ -10,12 +11,26 @@ import {computeProposerIndices} from "../util/seed.js";
  * this means that at the start of epoch `N`, the proposer lookahead for epoch
  * `N+1` will be computed and included in the beacon state's lookahead.
  */
-export function processProposerLookahead(fork: ForkSeq, state: CachedBeaconStateFulu): void {
+export function processProposerLookahead(
+  fork: ForkSeq,
+  state: CachedBeaconStateFulu,
+  cache: EpochTransitionCache
+): void {
   // Shift out proposers in the first epoch
   const remainingProposerLookahead = state.proposerLookahead.getAll().slice(SLOTS_PER_EPOCH);
 
   // Fill in the last epoch with new proposer indices
-  const lastEpochProposerLookahead = computeProposerIndices(fork, state, state.epochCtx.epoch + MIN_SEED_LOOKAHEAD + 1);
+  const epoch = state.epochCtx.epoch + MIN_SEED_LOOKAHEAD + 1;
+
+  const shuffling =
+    state.epochCtx.shufflingCache?.getSync(epoch, cache.nextShufflingDecisionRoot, {
+      state,
+      activeIndices: cache.nextShufflingActiveIndices,
+    }) ??
+    // Only for testing. shufflingCache should always be available in prod
+    computeEpochShuffling(state, cache.nextShufflingActiveIndices, epoch);
+
+  const lastEpochProposerLookahead = computeProposerIndices(fork, state, shuffling, epoch);
 
   state.proposerLookahead = ssz.fulu.ProposerLookahead.toViewDU([
     ...remainingProposerLookahead,

packages/state-transition/src/util/fulu.ts

@@ -1,7 +1,9 @@
 import {ForkSeq, MIN_SEED_LOOKAHEAD} from "@lodestar/params";
 import {ValidatorIndex} from "@lodestar/types";
 import {CachedBeaconStateElectra} from "../types.js";
+import {computeEpochShuffling} from "./epochShuffling.js";
 import {computeProposerIndices} from "./seed.js";
+import {getActiveValidatorIndices} from "./validator.js";
 
 /**
  * Return the proposer indices for the full available lookahead starting from current epoch.
@@ -12,8 +14,29 @@ export function initializeProposerLookahead(state: CachedBeaconStateElectra): Va
 
   const lookahead: ValidatorIndex[] = [];
 
-  for (let i = 0; i < MIN_SEED_LOOKAHEAD + 1; i++) {
-    lookahead.push(...computeProposerIndices(ForkSeq.fulu, state, currentEpoch + i));
+  for (let i = 0; i <= MIN_SEED_LOOKAHEAD; i++) {
+    const epoch = currentEpoch + i;
+
+    // Try to pull cached shuffling first
+    let shuffling = state.epochCtx.getShufflingAtEpochOrNull(epoch);
+
+    if (!shuffling) {
+      // Only compute epoch shuffling if cache is not yet populated
+      let activeIndices: Uint32Array;
+      if (epoch === currentEpoch) {
+        // This should never happen as current shuffling will always be cached
+        activeIndices = state.epochCtx.currentShuffling.activeIndices;
+      } else if (epoch === currentEpoch + 1) {
+        activeIndices = state.epochCtx.nextActiveIndices;
+      } else {
+        // This will never be reached with current spec as `MIN_SEED_LOOKAHEAD == 1`
+        activeIndices = getActiveValidatorIndices(state, epoch);
+      }
+
+      shuffling = computeEpochShuffling(state, activeIndices, epoch);
+    }
+
+    lookahead.push(...computeProposerIndices(ForkSeq.fulu, state, shuffling, epoch));
   }
 
   return lookahead;

packages/state-transition/src/util/seed.ts

@@ -22,8 +22,6 @@ import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js
 import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
 import {computeStartSlotAtEpoch} from "./epoch.js";
 import {computeEpochAtSlot} from "./epoch.js";
-import {EpochShuffling, computeEpochShuffling} from "./epochShuffling.js";
-import {getActiveValidatorIndices} from "./validator.js";
 
 /**
  * Compute proposer indices for an epoch
@@ -145,25 +143,12 @@ export function computeProposerIndex(
 export function computeProposerIndices(
   fork: ForkSeq,
   state: CachedBeaconStateAllForks,
+  shuffling: {activeIndices: Uint32Array},
   epoch: Epoch
 ): ValidatorIndex[] {
   const startSlot = computeStartSlotAtEpoch(epoch);
   const proposers = [];
   const epochSeed = getSeed(state, epoch, DOMAIN_BEACON_PROPOSER);
-  // TODO FULU: Compute shuffling if shuffling cache miss is a temporary workaround.
-  // EpochCache needs to cache shuffling for nextEpoch + 1 too.
-  let shuffling: EpochShuffling;
-  try {
-    shuffling = state.epochCtx.getShufflingAtEpoch(epoch);
-  } catch (e) {
-    state.epochCtx.shufflingCache?.logger?.verbose(
-      `Shuffling cache miss for epoch ${epoch}. Current epoch ${state.epochCtx.epoch}, computing shuffling...`,
-      {},
-      e as Error
-    );
-    state.commit();
-    shuffling = computeEpochShuffling(state, getActiveValidatorIndices(state, epoch), epoch);
-  }
 
   for (let slot = startSlot; slot < startSlot + SLOTS_PER_EPOCH; slot++) {
     proposers.push(