@lodestar/state-transition 1.39.0-dev.171bfe3042 → 1.39.0-dev.219c3c247e

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/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,
@@ -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));
 }