@lodestar/state-transition 1.39.0-dev.ad23ef56aa → 1.39.0-dev.b2437a6348

package/src/cache/epochTransitionCache.ts

@@ -1,12 +1,6 @@
-import {
-  EPOCHS_PER_SLASHINGS_VECTOR,
-  FAR_FUTURE_EPOCH,
-  ForkSeq,
-  MIN_ACTIVATION_BALANCE,
-  SLOTS_PER_HISTORICAL_ROOT,
-} from "@lodestar/params";
-import {Epoch, RootHex, ValidatorIndex} from "@lodestar/types";
-import {intDiv, toRootHex} from "@lodestar/utils";
+import {EPOCHS_PER_SLASHINGS_VECTOR, FAR_FUTURE_EPOCH, ForkSeq, MIN_ACTIVATION_BALANCE} from "@lodestar/params";
+import {Epoch, ValidatorIndex} from "@lodestar/types";
+import {intDiv} from "@lodestar/utils";
 import {processPendingAttestations} from "../epoch/processPendingAttestations.js";
 import {
   CachedBeaconStateAllForks,
@@ -26,16 +20,13 @@ import {
   FLAG_UNSLASHED,
   hasMarkers,
 } from "../util/attesterStatus.js";
+import {EpochShuffling} from "../util/epochShuffling.js";
 
 export type EpochTransitionCacheOpts = {
   /**
    * Assert progressive balances the same to EpochTransitionCache
    */
   assertCorrectProgressiveBalances?: boolean;
-  /**
-   * Do not queue shuffling calculation async. Forces sync JIT calculation in afterProcessEpoch
-   */
-  asyncShufflingCalculation?: boolean;
 };
 
 /**
@@ -162,9 +153,10 @@ export interface EpochTransitionCache {
   nextShufflingActiveIndices: Uint32Array;
 
   /**
-   * Shuffling decision root that gets set on the EpochCache in afterProcessEpoch
+   * Pre-computed shuffling for epoch N+2, populated by processProposerLookahead (Fulu+).
+   * Used by afterProcessEpoch to avoid recomputing the same shuffling.
    */
-  nextShufflingDecisionRoot: RootHex;
+  nextShuffling: EpochShuffling | null;
 
   /**
    * Altair specific, this is total active balances for the next epoch.
@@ -179,12 +171,6 @@ export interface EpochTransitionCache {
    */
   nextEpochTotalActiveBalanceByIncrement: number;
 
-  /**
-   * Compute the shuffling sync or async.  Defaults to synchronous.  Need to pass `true` with the
-   * `EpochTransitionCacheOpts`
-   */
-  asyncShufflingCalculation: boolean;
-
   /**
    * Track by validator index if it's active in the prev epoch.
    * Used in metrics
@@ -379,12 +365,7 @@ export function beforeProcessEpoch(
     }
   });
 
-  // Trigger async build of shuffling for epoch after next (nextShuffling post epoch transition)
-  const epochAfterNext = state.epochCtx.nextEpoch + 1;
-  // cannot call calculateShufflingDecisionRoot here because spec prevent getting current slot
-  // as a decision block.  we are part way through the transition though and this was added in
-  // process slot beforeProcessEpoch happens so it available and valid
-  const nextShufflingDecisionRoot = toRootHex(state.blockRoots.get(state.slot % SLOTS_PER_HISTORICAL_ROOT));
+  // Prepare shuffling data for epoch after next (nextShuffling post epoch transition)
   const nextShufflingActiveIndices = new Uint32Array(nextEpochShufflingActiveIndicesLength);
   if (nextEpochShufflingActiveIndicesLength > nextEpochShufflingActiveValidatorIndices.length) {
     throw new Error(
@@ -396,11 +377,6 @@ export function beforeProcessEpoch(
     nextShufflingActiveIndices[i] = nextEpochShufflingActiveValidatorIndices[i];
   }
 
-  const asyncShufflingCalculation = opts?.asyncShufflingCalculation ?? false;
-  if (asyncShufflingCalculation) {
-    state.epochCtx.shufflingCache?.build(epochAfterNext, nextShufflingDecisionRoot, state, nextShufflingActiveIndices);
-  }
-
   if (totalActiveStakeByIncrement < 1) {
     totalActiveStakeByIncrement = 1;
   } else if (totalActiveStakeByIncrement >= Number.MAX_SAFE_INTEGER) {
@@ -524,9 +500,8 @@ export function beforeProcessEpoch(
     indicesEligibleForActivationQueue,
     indicesEligibleForActivation: indicesEligibleForActivation.map(({validatorIndex}) => validatorIndex),
     indicesToEject,
-    nextShufflingDecisionRoot,
     nextShufflingActiveIndices,
-    asyncShufflingCalculation,
+    nextShuffling: null,
     // to be updated in processEffectiveBalanceUpdates
     nextEpochTotalActiveBalanceByIncrement: 0,
     isActivePrevEpoch,

package/src/cache/stateCache.ts

@@ -180,7 +180,7 @@ export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStat
     stateBytes,
     seedValidatorsBytes
   );
-  const {pubkey2index, index2pubkey, shufflingCache} = cachedSeedState.epochCtx;
+  const {pubkey2index, index2pubkey} = cachedSeedState.epochCtx;
   // Get the validators sub tree once for all the loop
   const validators = migratedState.validators;
   for (const validatorIndex of modifiedValidators) {
@@ -196,7 +196,6 @@ export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStat
       config: cachedSeedState.config,
       pubkey2index,
       index2pubkey,
-      shufflingCache,
     },
     {...(opts ?? {}), ...{skipSyncPubkeys: true}}
   ) as T;

package/src/epoch/processProposerLookahead.ts

@@ -22,13 +22,9 @@ export function processProposerLookahead(
   // Fill in the last epoch with new proposer indices
   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 shuffling = computeEpochShuffling(state, cache.nextShufflingActiveIndices, epoch);
+  // Save shuffling to cache so afterProcessEpoch can reuse it instead of recomputing
+  cache.nextShuffling = shuffling;
 
   const lastEpochProposerLookahead = computeProposerIndices(fork, state, shuffling, epoch);
 

package/src/rewards/blockRewards.ts

@@ -7,6 +7,7 @@ import {
 } from "@lodestar/params";
 import {BeaconBlock, altair, phase0, rewards} from "@lodestar/types";
 import {processAttestationsAltair} from "../block/processAttestationsAltair.js";
+import {RewardCache} from "../cache/rewardCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair, CachedBeaconStatePhase0} from "../cache/stateCache.js";
 import {getAttesterSlashableIndices} from "../util/attestation.js";
 
@@ -23,12 +24,14 @@ type SubRewardValue = number; // All reward values should be integer
 export async function computeBlockRewards(
   config: BeaconConfig,
   block: BeaconBlock,
-  preState: CachedBeaconStateAllForks,
-  postState?: CachedBeaconStateAllForks
+  preStateIn: CachedBeaconStateAllForks,
+  proposerRewards?: RewardCache
 ): Promise<rewards.BlockRewards> {
+  const preState = preStateIn.clone();
+
   const fork = config.getForkName(block.slot);
   const {attestations: cachedAttestationsReward = 0, syncAggregate: cachedSyncAggregateReward = 0} =
-    postState?.proposerRewards ?? {};
+    proposerRewards ?? {};
   let blockAttestationReward = cachedAttestationsReward;
   let syncAggregateReward = cachedSyncAggregateReward;
 

package/src/rewards/syncCommitteeRewards.ts

@@ -4,8 +4,6 @@ import {BeaconBlock, ValidatorIndex, altair, rewards} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../cache/stateCache.js";
 
-type BalanceRecord = {val: number}; // Use val for convenient way to increment/decrement balance
-
 export async function computeSyncCommitteeRewards(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
@@ -19,7 +17,7 @@ export async function computeSyncCommitteeRewards(
   }
 
   const altairBlock = block as altair.BeaconBlock;
-  const preStateAltair = preState as CachedBeaconStateAltair;
+  const preStateAltair = preState.clone() as CachedBeaconStateAltair;
 
   // Bound syncCommitteeValidatorIndices in case it goes beyond SYNC_COMMITTEE_SIZE just to be safe
   const syncCommitteeValidatorIndices = preStateAltair.epochCtx.currentSyncCommitteeIndexed.validatorIndices.slice(
@@ -29,24 +27,23 @@ export async function computeSyncCommitteeRewards(
   const {syncParticipantReward} = preStateAltair.epochCtx;
   const {syncCommitteeBits} = altairBlock.body.syncAggregate;
 
-  // Use balance of each committee as starting point such that we cap the penalty to avoid balance dropping below 0
-  const balances: Map<ValidatorIndex, BalanceRecord> = new Map();
-  for (const i of syncCommitteeValidatorIndices) {
-    balances.set(i, {val: preStateAltair.balances.get(i)});
-  }
+  // Track reward deltas per validator (can appear multiple times in sync committee)
+  const rewardDeltas: Map<ValidatorIndex, number> = new Map();
 
-  for (const i of syncCommitteeValidatorIndices) {
-    const balanceRecord = balances.get(i) as BalanceRecord;
+  // Iterate by position index to correctly access syncCommitteeBits
+  for (let i = 0; i < syncCommitteeValidatorIndices.length; i++) {
+    const validatorIndex = syncCommitteeValidatorIndices[i];
+    const currentDelta = rewardDeltas.get(validatorIndex) ?? 0;
     if (syncCommitteeBits.get(i)) {
       // Positive rewards for participants
-      balanceRecord.val += syncParticipantReward;
+      rewardDeltas.set(validatorIndex, currentDelta + syncParticipantReward);
     } else {
       // Negative rewards for non participants
-      balanceRecord.val = Math.max(0, balanceRecord.val - syncParticipantReward);
+      rewardDeltas.set(validatorIndex, currentDelta - syncParticipantReward);
     }
   }
 
-  const rewards = Array.from(balances, ([validatorIndex, v]) => ({validatorIndex, reward: v.val}));
+  const rewards = Array.from(rewardDeltas, ([validatorIndex, reward]) => ({validatorIndex, reward}));
 
   if (validatorIds.length) {
     const filtersSet = new Set(validatorIds);

package/src/types.ts

@@ -23,4 +23,5 @@ export type {
   BeaconStateFulu,
   BeaconStateGloas,
   BeaconStatePhase0,
+  ShufflingGetter,
 } from "./cache/types.js";

package/src/util/epochShuffling.ts

@@ -9,54 +9,13 @@ import {
   TARGET_COMMITTEE_SIZE,
 } from "@lodestar/params";
 import {Epoch, RootHex, ValidatorIndex, ssz} from "@lodestar/types";
-import {GaugeExtra, Logger, NoLabels, intDiv, toRootHex} from "@lodestar/utils";
+import {intDiv, toRootHex} from "@lodestar/utils";
 import {BeaconStateAllForks} from "../types.js";
 import {getBlockRootAtSlot} from "./blockRoot.js";
 import {computeAnchorCheckpoint} from "./computeAnchorCheckpoint.js";
 import {computeStartSlotAtEpoch} from "./epoch.js";
 import {getSeed} from "./seed.js";
 
-export interface ShufflingBuildProps {
-  state: BeaconStateAllForks;
-  activeIndices: Uint32Array;
-}
-
-export interface PublicShufflingCacheMetrics {
-  shufflingCache: {
-    nextShufflingNotOnEpochCache: GaugeExtra<NoLabels>;
-  };
-}
-export interface IShufflingCache {
-  metrics: PublicShufflingCacheMetrics | null;
-  logger: Logger | null;
-  /**
-   * Gets a cached shuffling via the epoch and decision root. If the state and
-   * activeIndices are passed and a shuffling is not available it will be built
-   * synchronously. If the state is not passed and the shuffling is not available
-   * nothing will be returned.
-   *
-   * NOTE: If a shuffling is already queued and not calculated it will build and resolve
-   * the promise but the already queued build will happen at some later time
-   */
-  getSync<T extends ShufflingBuildProps | undefined>(
-    epoch: Epoch,
-    decisionRoot: RootHex,
-    buildProps?: T
-  ): T extends ShufflingBuildProps ? EpochShuffling : EpochShuffling | null;
-
-  /**
-   * Gets a cached shuffling via the epoch and decision root.  Returns a promise
-   * for the shuffling if it hs not calculated yet.  Returns null if a build has
-   * not been queued nor a shuffling was calculated.
-   */
-  get(epoch: Epoch, decisionRoot: RootHex): Promise<EpochShuffling | null>;
-
-  /**
-   * Queue asynchronous build for an EpochShuffling
-   */
-  build(epoch: Epoch, decisionRoot: RootHex, state: BeaconStateAllForks, activeIndices: Uint32Array): void;
-}
-
 /**
  * Readonly interface for EpochShuffling.
  */
@@ -164,7 +123,7 @@ export async function computeEpochShufflingAsync(
   };
 }
 
-function calculateDecisionRoot(state: BeaconStateAllForks, epoch: Epoch): RootHex {
+export function calculateDecisionRoot(state: BeaconStateAllForks, epoch: Epoch): RootHex {
   const pivotSlot = computeStartSlotAtEpoch(epoch - 1) - 1;
   return toRootHex(getBlockRootAtSlot(state, pivotSlot));
 }