@lodestar/state-transition 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/cache/epochCache.ts

@@ -1,1213 +0,0 @@
-import {PublicKey} from "@chainsafe/blst";
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
-import {BeaconConfig, ChainConfig, createBeaconConfig} from "@lodestar/config";
-import {
-  ATTESTATION_SUBNET_COUNT,
-  DOMAIN_BEACON_PROPOSER,
-  EFFECTIVE_BALANCE_INCREMENT,
-  FAR_FUTURE_EPOCH,
-  ForkSeq,
-  GENESIS_EPOCH,
-  PROPOSER_WEIGHT,
-  SLOTS_PER_EPOCH,
-  WEIGHT_DENOMINATOR,
-} from "@lodestar/params";
-import {
-  Attestation,
-  BLSSignature,
-  CommitteeIndex,
-  Epoch,
-  IndexedAttestation,
-  RootHex,
-  Slot,
-  SubnetID,
-  SyncPeriod,
-  ValidatorIndex,
-  electra,
-  phase0,
-} from "@lodestar/types";
-import {LodestarError} from "@lodestar/utils";
-import {getTotalSlashingsByIncrement} from "../epoch/processSlashings.js";
-import {AttesterDuty, calculateCommitteeAssignments} from "../util/calculateCommitteeAssignments.js";
-import {
-  EpochShuffling,
-  IShufflingCache,
-  calculateShufflingDecisionRoot,
-  computeEpochShuffling,
-} from "../util/epochShuffling.js";
-import {
-  computeActivationExitEpoch,
-  computeEpochAtSlot,
-  computeProposers,
-  computeStartSlotAtEpoch,
-  computeSyncPeriodAtEpoch,
-  getActivationChurnLimit,
-  getChurnLimit,
-  getSeed,
-  isActiveValidator,
-  isAggregatorFromCommitteeLength,
-} from "../util/index.js";
-import {computeBaseRewardPerIncrement, computeSyncParticipantReward} from "../util/syncCommittee.js";
-import {sumTargetUnslashedBalanceIncrements} from "../util/targetUnslashedBalance.js";
-import {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsWithLen} from "./effectiveBalanceIncrements.js";
-import {EpochTransitionCache} from "./epochTransitionCache.js";
-import {Index2PubkeyCache, syncPubkeys} from "./pubkeyCache.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateFulu} from "./stateCache.js";
-import {
-  SyncCommitteeCache,
-  SyncCommitteeCacheEmpty,
-  computeSyncCommitteeCache,
-  getSyncCommitteeCache,
-} from "./syncCommitteeCache.js";
-import {BeaconStateAllForks, BeaconStateAltair} from "./types.js";
-
-/** `= PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT)` */
-export const PROPOSER_WEIGHT_FACTOR = PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT);
-
-export type EpochCacheImmutableData = {
-  config: BeaconConfig;
-  pubkey2index: PubkeyIndexMap;
-  index2pubkey: Index2PubkeyCache;
-  shufflingCache?: IShufflingCache;
-};
-
-export type EpochCacheOpts = {
-  skipSyncCommitteeCache?: boolean;
-  skipSyncPubkeys?: boolean;
-};
-
-/** Defers computing proposers by persisting only the seed, and dropping it once indexes are computed */
-type ProposersDeferred = {computed: false; seed: Uint8Array} | {computed: true; indexes: ValidatorIndex[]};
-
-/**
- * EpochCache is the parent object of:
- * - Any data-structures not part of the spec'ed BeaconState
- * - Necessary to only compute data once
- * - Must be kept at all times through an epoch
- *
- * The performance gains with EpochCache are fundamental for the BeaconNode to be able to participate in a
- * production network with 100_000s of validators. In summary, it contains:
- *
- * Expensive data constant through the epoch:
- * - pubkey cache
- * - proposer indexes
- * - shufflings
- * - sync committee indexed
- * Counters (maybe) mutated through the epoch:
- * - churnLimit
- * - exitQueueEpoch
- * - exitQueueChurn
- * Time data faster than recomputing from the state:
- * - epoch
- * - syncPeriod
- **/
-export class EpochCache {
-  config: BeaconConfig;
-  /**
-   * Unique globally shared pubkey registry. There should only exist one for the entire application.
-   *
-   * TODO: this is a hack, we need a safety mechanism in case a bad eth1 majority vote is in,
-   * or handle non finalized data differently, or use an immutable.js structure for cheap copies
-   *
-   * $VALIDATOR_COUNT x 192 char String -> Number Map
-   */
-  pubkey2index: PubkeyIndexMap;
-  /**
-   * Unique globally shared pubkey registry. There should only exist one for the entire application.
-   *
-   * $VALIDATOR_COUNT x BLST deserialized pubkey (Jacobian coordinates)
-   */
-  index2pubkey: Index2PubkeyCache;
-  /**
-   * ShufflingCache is passed in from `beacon-node` so should be available at runtime but may not be
-   * present during testing.
-   */
-  shufflingCache?: IShufflingCache;
-
-  /**
-   * Indexes of the block proposers for the current epoch.
-   * For pre-fulu, this is computed and cached from the current shuffling.
-   * For post-fulu, this is copied from the state.proposerLookahead.
-   *
-   * 32 x Number
-   */
-  proposers: ValidatorIndex[];
-
-  /** Proposers for previous epoch, initialized to null in first epoch */
-  proposersPrevEpoch: ValidatorIndex[] | null;
-
-  /**
-   * The next proposer seed is only used in the getBeaconProposersNextEpoch call. It cannot be moved into
-   * getBeaconProposersNextEpoch because it needs state as input and all data needed by getBeaconProposersNextEpoch
-   * should be in the epoch context.
-   *
-   * For pre-fulu, this is lazily computed from the next epoch's shuffling.
-   * For post-fulu, this is copied from the state.proposerLookahead.
-   */
-  proposersNextEpoch: ProposersDeferred;
-
-  /**
-   * Epoch decision roots to look up correct shuffling from the Shuffling Cache
-   */
-  previousDecisionRoot: RootHex;
-  currentDecisionRoot: RootHex;
-  nextDecisionRoot: RootHex;
-  /**
-   * Shuffling of validator indexes. Immutable through the epoch, then it's replaced entirely.
-   * Note: Per spec definition, shuffling will always be defined. They are never called before loadState()
-   *
-   * $VALIDATOR_COUNT x Number
-   */
-  previousShuffling: EpochShuffling;
-  /** Same as previousShuffling */
-  currentShuffling: EpochShuffling;
-  /** Same as previousShuffling */
-  nextShuffling: EpochShuffling | null;
-  /**
-   * Cache nextActiveIndices so that in afterProcessEpoch the next shuffling can be build synchronously
-   * in case it is not built or the ShufflingCache is not available
-   */
-  nextActiveIndices: Uint32Array;
-  /**
-   * Effective balances, for altair processAttestations()
-   */
-  effectiveBalanceIncrements: EffectiveBalanceIncrements;
-  /**
-   * Total state.slashings by increment, for processSlashing()
-   */
-  totalSlashingsByIncrement: number;
-  syncParticipantReward: number;
-  syncProposerReward: number;
-  /**
-   * Update freq: once per epoch after `process_effective_balance_updates()`
-   */
-  baseRewardPerIncrement: number;
-  /**
-   * Total active balance for current epoch, to be used instead of getTotalBalance()
-   */
-  totalActiveBalanceIncrements: number;
-
-  /**
-   * Rate at which validators can enter or leave the set per epoch. Depends only on activeIndexes, so it does not
-   * change through the epoch. It's used in initiateValidatorExit(). Must be update after changing active indexes.
-   */
-  churnLimit: number;
-
-  /**
-   * Fork limited actual activationChurnLimit
-   */
-  activationChurnLimit: number;
-  /**
-   * Closest epoch with available churn for validators to exit at. May be updated every block as validators are
-   * initiateValidatorExit(). This value may vary on each fork of the state.
-   *
-   * NOTE: Changes block to block
-   * NOTE: No longer used by initiateValidatorExit post-electra
-   */
-  exitQueueEpoch: Epoch;
-  /**
-   * Number of validators initiating an exit at exitQueueEpoch. May be updated every block as validators are
-   * initiateValidatorExit(). This value may vary on each fork of the state.
-   *
-   * NOTE: Changes block to block
-   * NOTE: No longer used by initiateValidatorExit post-electra
-   */
-  exitQueueChurn: number;
-
-  /**
-   * Total cumulative balance increments through epoch for current target.
-   * Required for unrealized checkpoints issue pull-up tips N+1. Otherwise must run epoch transition every block
-   * This value is equivalent to:
-   * - Forward current state to end-of-epoch
-   * - Run beforeProcessEpoch
-   * - epochTransitionCache.currEpochUnslashedTargetStakeByIncrement
-   */
-  currentTargetUnslashedBalanceIncrements: number;
-  /**
-   * Total cumulative balance increments through epoch for previous target.
-   * Required for unrealized checkpoints issue pull-up tips N+1. Otherwise must run epoch transition every block
-   * This value is equivalent to:
-   * - Forward current state to end-of-epoch
-   * - Run beforeProcessEpoch
-   * - epochTransitionCache.prevEpochUnslashedStake.targetStakeByIncrement
-   */
-  previousTargetUnslashedBalanceIncrements: number;
-
-  /** TODO: Indexed SyncCommitteeCache */
-  currentSyncCommitteeIndexed: SyncCommitteeCache;
-  /** TODO: Indexed SyncCommitteeCache */
-  nextSyncCommitteeIndexed: SyncCommitteeCache;
-
-  // TODO: Helper stats
-  syncPeriod: SyncPeriod;
-
-  epoch: Epoch;
-
-  get nextEpoch(): Epoch {
-    return this.epoch + 1;
-  }
-
-  constructor(data: {
-    config: BeaconConfig;
-    pubkey2index: PubkeyIndexMap;
-    index2pubkey: Index2PubkeyCache;
-    shufflingCache?: IShufflingCache;
-    proposers: number[];
-    proposersPrevEpoch: number[] | null;
-    proposersNextEpoch: ProposersDeferred;
-    previousDecisionRoot: RootHex;
-    currentDecisionRoot: RootHex;
-    nextDecisionRoot: RootHex;
-    previousShuffling: EpochShuffling;
-    currentShuffling: EpochShuffling;
-    nextShuffling: EpochShuffling | null;
-    nextActiveIndices: Uint32Array;
-    effectiveBalanceIncrements: EffectiveBalanceIncrements;
-    totalSlashingsByIncrement: number;
-    syncParticipantReward: number;
-    syncProposerReward: number;
-    baseRewardPerIncrement: number;
-    totalActiveBalanceIncrements: number;
-    churnLimit: number;
-    activationChurnLimit: number;
-    exitQueueEpoch: Epoch;
-    exitQueueChurn: number;
-    currentTargetUnslashedBalanceIncrements: number;
-    previousTargetUnslashedBalanceIncrements: number;
-    currentSyncCommitteeIndexed: SyncCommitteeCache;
-    nextSyncCommitteeIndexed: SyncCommitteeCache;
-    epoch: Epoch;
-    syncPeriod: SyncPeriod;
-  }) {
-    this.config = data.config;
-    this.pubkey2index = data.pubkey2index;
-    this.index2pubkey = data.index2pubkey;
-    this.shufflingCache = data.shufflingCache;
-    this.proposers = data.proposers;
-    this.proposersPrevEpoch = data.proposersPrevEpoch;
-    this.proposersNextEpoch = data.proposersNextEpoch;
-    this.previousDecisionRoot = data.previousDecisionRoot;
-    this.currentDecisionRoot = data.currentDecisionRoot;
-    this.nextDecisionRoot = data.nextDecisionRoot;
-    this.previousShuffling = data.previousShuffling;
-    this.currentShuffling = data.currentShuffling;
-    this.nextShuffling = data.nextShuffling;
-    this.nextActiveIndices = data.nextActiveIndices;
-    this.effectiveBalanceIncrements = data.effectiveBalanceIncrements;
-    this.totalSlashingsByIncrement = data.totalSlashingsByIncrement;
-    this.syncParticipantReward = data.syncParticipantReward;
-    this.syncProposerReward = data.syncProposerReward;
-    this.baseRewardPerIncrement = data.baseRewardPerIncrement;
-    this.totalActiveBalanceIncrements = data.totalActiveBalanceIncrements;
-    this.churnLimit = data.churnLimit;
-    this.activationChurnLimit = data.activationChurnLimit;
-    this.exitQueueEpoch = data.exitQueueEpoch;
-    this.exitQueueChurn = data.exitQueueChurn;
-    this.currentTargetUnslashedBalanceIncrements = data.currentTargetUnslashedBalanceIncrements;
-    this.previousTargetUnslashedBalanceIncrements = data.previousTargetUnslashedBalanceIncrements;
-    this.currentSyncCommitteeIndexed = data.currentSyncCommitteeIndexed;
-    this.nextSyncCommitteeIndexed = data.nextSyncCommitteeIndexed;
-    this.epoch = data.epoch;
-    this.syncPeriod = data.syncPeriod;
-  }
-
-  /**
-   * Create an epoch cache
-   * @param state a finalized beacon state. Passing in unfinalized state may cause unexpected behaviour
-   *
-   * SLOW CODE - 🐢
-   */
-  static createFromState(
-    state: BeaconStateAllForks,
-    {config, pubkey2index, index2pubkey, shufflingCache}: EpochCacheImmutableData,
-    opts?: EpochCacheOpts
-  ): EpochCache {
-    const currentEpoch = computeEpochAtSlot(state.slot);
-    const isGenesis = currentEpoch === GENESIS_EPOCH;
-    const previousEpoch = isGenesis ? GENESIS_EPOCH : currentEpoch - 1;
-    const nextEpoch = currentEpoch + 1;
-
-    let totalActiveBalanceIncrements = 0;
-    let exitQueueEpoch = computeActivationExitEpoch(currentEpoch);
-    let exitQueueChurn = 0;
-
-    const validators = state.validators.getAllReadonlyValues();
-    const validatorCount = validators.length;
-
-    // syncPubkeys here to ensure EpochCacheImmutableData is popualted before computing the rest of caches
-    // - computeSyncCommitteeCache() needs a fully populated pubkey2index cache
-    if (!opts?.skipSyncPubkeys) {
-      syncPubkeys(validators, pubkey2index, index2pubkey);
-    }
-
-    const effectiveBalanceIncrements = getEffectiveBalanceIncrementsWithLen(validatorCount);
-    const totalSlashingsByIncrement = getTotalSlashingsByIncrement(state);
-    const previousActiveIndicesAsNumberArray: ValidatorIndex[] = [];
-    const currentActiveIndicesAsNumberArray: ValidatorIndex[] = [];
-    const nextActiveIndicesAsNumberArray: ValidatorIndex[] = [];
-
-    // BeaconChain could provide a shuffling cache to avoid re-computing shuffling every epoch
-    // in that case, we don't need to compute shufflings again
-    const previousDecisionRoot = calculateShufflingDecisionRoot(config, state, previousEpoch);
-    const cachedPreviousShuffling = shufflingCache?.getSync(previousEpoch, previousDecisionRoot);
-    const currentDecisionRoot = calculateShufflingDecisionRoot(config, state, currentEpoch);
-    const cachedCurrentShuffling = shufflingCache?.getSync(currentEpoch, currentDecisionRoot);
-    const nextDecisionRoot = calculateShufflingDecisionRoot(config, state, nextEpoch);
-    const cachedNextShuffling = shufflingCache?.getSync(nextEpoch, nextDecisionRoot);
-
-    for (let i = 0; i < validatorCount; i++) {
-      const validator = validators[i];
-
-      // Note: Not usable for fork-choice balances since in-active validators are not zero'ed
-      effectiveBalanceIncrements[i] = Math.floor(validator.effectiveBalance / EFFECTIVE_BALANCE_INCREMENT);
-
-      // we only need to track active indices for previous, current and next epoch if we have to compute shufflings
-      // skip doing that if we already have cached shufflings
-      if (cachedPreviousShuffling == null && isActiveValidator(validator, previousEpoch)) {
-        previousActiveIndicesAsNumberArray.push(i);
-      }
-      if (isActiveValidator(validator, currentEpoch)) {
-        if (cachedCurrentShuffling == null) {
-          currentActiveIndicesAsNumberArray.push(i);
-        }
-        // We track totalActiveBalanceIncrements as ETH to fit total network balance in a JS number (53 bits)
-        totalActiveBalanceIncrements += effectiveBalanceIncrements[i];
-      }
-      if (cachedNextShuffling == null && isActiveValidator(validator, nextEpoch)) {
-        nextActiveIndicesAsNumberArray.push(i);
-      }
-
-      const {exitEpoch} = validator;
-      if (exitEpoch !== FAR_FUTURE_EPOCH) {
-        if (exitEpoch > exitQueueEpoch) {
-          exitQueueEpoch = exitEpoch;
-          exitQueueChurn = 1;
-        } else if (exitEpoch === exitQueueEpoch) {
-          exitQueueChurn += 1;
-        }
-      }
-    }
-
-    // Spec: `EFFECTIVE_BALANCE_INCREMENT` Gwei minimum to avoid divisions by zero
-    // 1 = 1 unit of EFFECTIVE_BALANCE_INCREMENT
-    if (totalActiveBalanceIncrements < 1) {
-      totalActiveBalanceIncrements = 1;
-    } else if (totalActiveBalanceIncrements >= Number.MAX_SAFE_INTEGER) {
-      throw Error("totalActiveBalanceIncrements >= Number.MAX_SAFE_INTEGER. MAX_EFFECTIVE_BALANCE is too low.");
-    }
-
-    const nextActiveIndices = new Uint32Array(nextActiveIndicesAsNumberArray);
-    let previousShuffling: EpochShuffling;
-    let currentShuffling: EpochShuffling;
-    let nextShuffling: EpochShuffling;
-
-    if (!shufflingCache) {
-      // Only for testing. shufflingCache should always be available in prod
-      previousShuffling = computeEpochShuffling(
-        state,
-        new Uint32Array(previousActiveIndicesAsNumberArray),
-        previousEpoch
-      );
-
-      currentShuffling = isGenesis
-        ? previousShuffling
-        : computeEpochShuffling(state, new Uint32Array(currentActiveIndicesAsNumberArray), currentEpoch);
-
-      nextShuffling = computeEpochShuffling(state, nextActiveIndices, nextEpoch);
-    } else {
-      currentShuffling = cachedCurrentShuffling
-        ? cachedCurrentShuffling
-        : shufflingCache.getSync(currentEpoch, currentDecisionRoot, {
-            state,
-            activeIndices: new Uint32Array(currentActiveIndicesAsNumberArray),
-          });
-
-      previousShuffling = cachedPreviousShuffling
-        ? cachedPreviousShuffling
-        : isGenesis
-          ? currentShuffling
-          : shufflingCache.getSync(previousEpoch, previousDecisionRoot, {
-              state,
-              activeIndices: new Uint32Array(previousActiveIndicesAsNumberArray),
-            });
-
-      nextShuffling = cachedNextShuffling
-        ? cachedNextShuffling
-        : shufflingCache.getSync(nextEpoch, nextDecisionRoot, {
-            state,
-            activeIndices: nextActiveIndices,
-          });
-    }
-
-    const currentProposerSeed = getSeed(state, currentEpoch, DOMAIN_BEACON_PROPOSER);
-
-    let proposers: number[];
-    if (currentEpoch >= config.FULU_FORK_EPOCH) {
-      // Overwrite proposers with state.proposerLookahead
-      proposers = (state as CachedBeaconStateFulu).proposerLookahead.getAll().slice(0, SLOTS_PER_EPOCH);
-    } else {
-      // We need to calculate Pre-fulu
-      // Allow to create CachedBeaconState for empty states, or no active validators
-      proposers =
-        currentShuffling.activeIndices.length > 0
-          ? computeProposers(
-              config.getForkSeqAtEpoch(currentEpoch),
-              currentProposerSeed,
-              currentShuffling,
-              effectiveBalanceIncrements
-            )
-          : [];
-    }
-
-    const proposersNextEpoch: ProposersDeferred = {
-      computed: false,
-      seed: getSeed(state, nextEpoch, DOMAIN_BEACON_PROPOSER),
-    };
-
-    // Only after altair, compute the indices of the current sync committee
-    const afterAltairFork = currentEpoch >= config.ALTAIR_FORK_EPOCH;
-
-    // Values syncParticipantReward, syncProposerReward, baseRewardPerIncrement are only used after altair.
-    // However, since they are very cheap to compute they are computed always to simplify upgradeState function.
-    const syncParticipantReward = computeSyncParticipantReward(totalActiveBalanceIncrements);
-    const syncProposerReward = Math.floor(syncParticipantReward * PROPOSER_WEIGHT_FACTOR);
-    const baseRewardPerIncrement = computeBaseRewardPerIncrement(totalActiveBalanceIncrements);
-
-    let currentSyncCommitteeIndexed: SyncCommitteeCache;
-    let nextSyncCommitteeIndexed: SyncCommitteeCache;
-    // Allow to skip populating sync committee for initializeBeaconStateFromEth1()
-    if (afterAltairFork && !opts?.skipSyncCommitteeCache) {
-      const altairState = state as BeaconStateAltair;
-      currentSyncCommitteeIndexed = computeSyncCommitteeCache(altairState.currentSyncCommittee, pubkey2index);
-      nextSyncCommitteeIndexed = computeSyncCommitteeCache(altairState.nextSyncCommittee, pubkey2index);
-    } else {
-      currentSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
-      nextSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
-    }
-
-    // Precompute churnLimit for efficient initiateValidatorExit() during block proposing MUST be recompute everytime the
-    // active validator indices set changes in size. Validators change active status only when:
-    // - validator.activation_epoch is set. Only changes in process_registry_updates() if validator can be activated. If
-    //   the value changes it will be set to `epoch + 1 + MAX_SEED_LOOKAHEAD`.
-    // - validator.exit_epoch is set. Only changes in initiate_validator_exit() if validator exits. If the value changes,
-    //   it will be set to at least `epoch + 1 + MAX_SEED_LOOKAHEAD`.
-    // ```
-    // is_active_validator = validator.activation_epoch <= epoch < validator.exit_epoch
-    // ```
-    // So the returned value of is_active_validator(epoch) is guaranteed to not change during `MAX_SEED_LOOKAHEAD` epochs.
-    //
-    // activeIndices size is dependent on the state epoch. The epoch is advanced after running the epoch transition, and
-    // the first block of the epoch process_block() call. So churnLimit must be computed at the end of the before epoch
-    // transition and the result is valid until the end of the next epoch transition
-    const churnLimit = getChurnLimit(config, currentShuffling.activeIndices.length);
-    const activationChurnLimit = getActivationChurnLimit(
-      config,
-      config.getForkSeq(state.slot),
-      currentShuffling.activeIndices.length
-    );
-    if (exitQueueChurn >= churnLimit) {
-      exitQueueEpoch += 1;
-      exitQueueChurn = 0;
-    }
-
-    // TODO: describe issue. Compute progressive target balances
-    // Compute balances from zero, note this state could be mid-epoch so target balances != 0
-    let previousTargetUnslashedBalanceIncrements = 0;
-    let currentTargetUnslashedBalanceIncrements = 0;
-
-    if (config.getForkSeq(state.slot) >= ForkSeq.altair) {
-      const {previousEpochParticipation, currentEpochParticipation} = state as BeaconStateAltair;
-      previousTargetUnslashedBalanceIncrements = sumTargetUnslashedBalanceIncrements(
-        previousEpochParticipation.getAll(),
-        previousEpoch,
-        validators
-      );
-      currentTargetUnslashedBalanceIncrements = sumTargetUnslashedBalanceIncrements(
-        currentEpochParticipation.getAll(),
-        currentEpoch,
-        validators
-      );
-    }
-
-    return new EpochCache({
-      config,
-      pubkey2index,
-      index2pubkey,
-      shufflingCache,
-      proposers,
-      // On first epoch, set to null to prevent unnecessary work since this is only used for metrics
-      proposersPrevEpoch: null,
-      proposersNextEpoch,
-      previousDecisionRoot,
-      currentDecisionRoot,
-      nextDecisionRoot,
-      previousShuffling,
-      currentShuffling,
-      nextShuffling,
-      nextActiveIndices,
-      effectiveBalanceIncrements,
-      totalSlashingsByIncrement,
-      syncParticipantReward,
-      syncProposerReward,
-      baseRewardPerIncrement,
-      totalActiveBalanceIncrements,
-      churnLimit,
-      activationChurnLimit,
-      exitQueueEpoch,
-      exitQueueChurn,
-      previousTargetUnslashedBalanceIncrements,
-      currentTargetUnslashedBalanceIncrements,
-      currentSyncCommitteeIndexed,
-      nextSyncCommitteeIndexed,
-      epoch: currentEpoch,
-      syncPeriod: computeSyncPeriodAtEpoch(currentEpoch),
-    });
-  }
-
-  /**
-   * Copies a given EpochCache while avoiding copying its immutable parts.
-   */
-  clone(): EpochCache {
-    // warning: pubkey cache is not copied, it is shared, as eth1 is not expected to reorder validators.
-    // Shallow copy all data from current epoch context to the next
-    // All data is completely replaced, or only-appended
-    return new EpochCache({
-      config: this.config,
-      // Common append-only structures shared with all states, no need to clone
-      pubkey2index: this.pubkey2index,
-      index2pubkey: this.index2pubkey,
-      shufflingCache: this.shufflingCache,
-      // Immutable data
-      proposers: this.proposers,
-      proposersPrevEpoch: this.proposersPrevEpoch,
-      proposersNextEpoch: this.proposersNextEpoch,
-      previousDecisionRoot: this.previousDecisionRoot,
-      currentDecisionRoot: this.currentDecisionRoot,
-      nextDecisionRoot: this.nextDecisionRoot,
-      previousShuffling: this.previousShuffling,
-      currentShuffling: this.currentShuffling,
-      nextShuffling: this.nextShuffling,
-      nextActiveIndices: this.nextActiveIndices,
-      // Uint8Array, requires cloning, but it is cloned only when necessary before an epoch transition
-      // See EpochCache.beforeEpochTransition()
-      effectiveBalanceIncrements: this.effectiveBalanceIncrements,
-      totalSlashingsByIncrement: this.totalSlashingsByIncrement,
-      // Basic types (numbers) cloned implicitly
-      syncParticipantReward: this.syncParticipantReward,
-      syncProposerReward: this.syncProposerReward,
-      baseRewardPerIncrement: this.baseRewardPerIncrement,
-      totalActiveBalanceIncrements: this.totalActiveBalanceIncrements,
-      churnLimit: this.churnLimit,
-      activationChurnLimit: this.activationChurnLimit,
-      exitQueueEpoch: this.exitQueueEpoch,
-      exitQueueChurn: this.exitQueueChurn,
-      previousTargetUnslashedBalanceIncrements: this.previousTargetUnslashedBalanceIncrements,
-      currentTargetUnslashedBalanceIncrements: this.currentTargetUnslashedBalanceIncrements,
-      currentSyncCommitteeIndexed: this.currentSyncCommitteeIndexed,
-      nextSyncCommitteeIndexed: this.nextSyncCommitteeIndexed,
-      epoch: this.epoch,
-      syncPeriod: this.syncPeriod,
-    });
-  }
-
-  /**
-   * Called to re-use information, such as the shuffling of the next epoch, after transitioning into a
-   * new epoch. Also handles pre-computation of values that may change during the upcoming epoch and
-   * that get used in the following epoch transition.  Often those pre-computations are not used by the
-   * chain but are courtesy values that are served via the API for epoch look ahead of duties.
-   *
-   * Steps for afterProcessEpoch
-   * 1) update previous/current/next values of cached items
-   *
-   * At fork boundary, this runs pre-fork logic and it happens before `upgradeState*` is called.
-   */
-  afterProcessEpoch(state: CachedBeaconStateAllForks, epochTransitionCache: EpochTransitionCache): void {
-    // Because the slot was incremented before entering this function the "next epoch" is actually the "current epoch"
-    // in this context but that is not actually true because the state transition happens in the last 4 seconds of the
-    // epoch. For the context of this function "upcoming epoch" is used to denote the epoch that will begin after this
-    // function returns.  The epoch that is "next" once the state transition is complete is referred to as the
-    // epochAfterUpcoming for the same reason to help minimize confusion.
-    const upcomingEpoch = this.nextEpoch;
-    const epochAfterUpcoming = upcomingEpoch + 1;
-
-    // move current to previous
-    this.previousShuffling = this.currentShuffling;
-    this.previousDecisionRoot = this.currentDecisionRoot;
-
-    // move next to current or calculate upcoming
-    this.currentDecisionRoot = this.nextDecisionRoot;
-    if (this.nextShuffling) {
-      // was already pulled from the ShufflingCache to the EpochCache (should be in most cases)
-      this.currentShuffling = this.nextShuffling;
-    } else {
-      this.shufflingCache?.metrics?.shufflingCache.nextShufflingNotOnEpochCache.inc();
-      this.currentShuffling =
-        this.shufflingCache?.getSync(upcomingEpoch, this.currentDecisionRoot, {
-          state,
-          // have to use the "nextActiveIndices" that were saved in the last transition here to calculate
-          // the upcoming shuffling if it is not already built (similar condition to the below computation)
-          activeIndices: this.nextActiveIndices,
-        }) ??
-        // allow for this case during testing where the ShufflingCache is not present, may affect perf testing
-        // so should be taken into account when structuring tests.  Should not affect unit or other tests though
-        computeEpochShuffling(state, this.nextActiveIndices, upcomingEpoch);
-    }
-
-    // handle next values
-    this.nextDecisionRoot = epochTransitionCache.nextShufflingDecisionRoot;
-    this.nextActiveIndices = epochTransitionCache.nextShufflingActiveIndices;
-    if (this.shufflingCache) {
-      if (!epochTransitionCache.asyncShufflingCalculation) {
-        this.nextShuffling = this.shufflingCache.getSync(epochAfterUpcoming, this.nextDecisionRoot, {
-          state,
-          activeIndices: this.nextActiveIndices,
-        });
-      } else {
-        this.nextShuffling = null;
-        // This promise will resolve immediately after the synchronous code of the state-transition runs. Until
-        // the build is done on a worker thread it will be calculated immediately after the epoch transition
-        // completes.  Once the work is done concurrently it should be ready by time this get runs so the promise
-        // will resolve directly on the next spin of the event loop because the epoch transition and shuffling take
-        // about the same time to calculate so theoretically its ready now.  Do not await here though in case it
-        // is not ready yet as the transition must not be asynchronous.
-        this.shufflingCache
-          .get(epochAfterUpcoming, this.nextDecisionRoot)
-          .then((shuffling) => {
-            if (!shuffling) {
-              throw new Error("EpochShuffling not returned from get in afterProcessEpoch");
-            }
-            this.nextShuffling = shuffling;
-          })
-          .catch((err) => {
-            this.shufflingCache?.logger?.error(
-              "EPOCH_CONTEXT_SHUFFLING_BUILD_ERROR",
-              {epoch: epochAfterUpcoming, decisionRoot: epochTransitionCache.nextShufflingDecisionRoot},
-              err
-            );
-          });
-      }
-    } else {
-      // Only for testing. shufflingCache should always be available in prod
-      this.nextShuffling = computeEpochShuffling(state, this.nextActiveIndices, epochAfterUpcoming);
-    }
-
-    // TODO: DEDUPLICATE from createEpochCache
-    //
-    // Precompute churnLimit for efficient initiateValidatorExit() during block proposing MUST be recompute every time the
-    // active validator indices set changes in size. Validators change active status only when:
-    // - validator.activation_epoch is set. Only changes in process_registry_updates() if validator can be activated. If
-    //   the value changes it will be set to `epoch + 1 + MAX_SEED_LOOKAHEAD`.
-    // - validator.exit_epoch is set. Only changes in initiate_validator_exit() if validator exits. If the value changes,
-    //   it will be set to at least `epoch + 1 + MAX_SEED_LOOKAHEAD`.
-    // ```
-    // is_active_validator = validator.activation_epoch <= epoch < validator.exit_epoch
-    // ```
-    // So the returned value of is_active_validator(epoch) is guaranteed to not change during `MAX_SEED_LOOKAHEAD` epochs.
-    //
-    // activeIndices size is dependent on the state epoch. The epoch is advanced after running the epoch transition, and
-    // the first block of the epoch process_block() call. So churnLimit must be computed at the end of the before epoch
-    // transition and the result is valid until the end of the next epoch transition
-    this.churnLimit = getChurnLimit(this.config, this.currentShuffling.activeIndices.length);
-    this.activationChurnLimit = getActivationChurnLimit(
-      this.config,
-      this.config.getForkSeq(state.slot),
-      this.currentShuffling.activeIndices.length
-    );
-
-    // Maybe advance exitQueueEpoch at the end of the epoch if there haven't been any exists for a while
-    const exitQueueEpoch = computeActivationExitEpoch(upcomingEpoch);
-    if (exitQueueEpoch > this.exitQueueEpoch) {
-      this.exitQueueEpoch = exitQueueEpoch;
-      this.exitQueueChurn = 0;
-    }
-
-    this.totalActiveBalanceIncrements = epochTransitionCache.nextEpochTotalActiveBalanceByIncrement;
-    if (upcomingEpoch >= this.config.ALTAIR_FORK_EPOCH) {
-      this.syncParticipantReward = computeSyncParticipantReward(this.totalActiveBalanceIncrements);
-      this.syncProposerReward = Math.floor(this.syncParticipantReward * PROPOSER_WEIGHT_FACTOR);
-      this.baseRewardPerIncrement = computeBaseRewardPerIncrement(this.totalActiveBalanceIncrements);
-    }
-
-    this.previousTargetUnslashedBalanceIncrements = this.currentTargetUnslashedBalanceIncrements;
-    this.currentTargetUnslashedBalanceIncrements = 0;
-
-    // Advance time units
-    // state.slot is advanced right before calling this function
-    // ```
-    // postState.slot++;
-    // afterProcessEpoch(postState, epochTransitionCache);
-    // ```
-    this.epoch = computeEpochAtSlot(state.slot);
-    this.syncPeriod = computeSyncPeriodAtEpoch(this.epoch);
-  }
-
-  /**
-   * At fork boundary, this runs post-fork logic and it happens after `upgradeState*` is called.
-   */
-  finalProcessEpoch(state: CachedBeaconStateAllForks): void {
-    // this.epoch was updated at the end of afterProcessEpoch()
-    const upcomingEpoch = this.epoch;
-    const epochAfterUpcoming = upcomingEpoch + 1;
-
-    this.proposersPrevEpoch = this.proposers;
-    if (upcomingEpoch >= this.config.FULU_FORK_EPOCH) {
-      // Populate proposer cache with lookahead from state
-      const proposerLookahead = (state as CachedBeaconStateFulu).proposerLookahead.getAll();
-      this.proposers = proposerLookahead.slice(0, SLOTS_PER_EPOCH);
-
-      if (proposerLookahead.length >= SLOTS_PER_EPOCH * 2) {
-        this.proposersNextEpoch = {
-          computed: true,
-          indexes: proposerLookahead.slice(SLOTS_PER_EPOCH, SLOTS_PER_EPOCH * 2),
-        };
-      } else {
-        // This should not happen unless MIN_SEED_LOOKAHEAD is set to 0
-        // this ensures things don't break if the proposer lookahead is not long enough
-        this.proposersNextEpoch = {computed: false, seed: getSeed(state, epochAfterUpcoming, DOMAIN_BEACON_PROPOSER)};
-      }
-    } else {
-      // Need to calculate proposers pre-fulu
-      const upcomingProposerSeed = getSeed(state, upcomingEpoch, DOMAIN_BEACON_PROPOSER);
-      // next epoch was moved to current epoch so use current here
-      this.proposers = computeProposers(
-        this.config.getForkSeqAtEpoch(upcomingEpoch),
-        upcomingProposerSeed,
-        this.currentShuffling,
-        this.effectiveBalanceIncrements
-      );
-      // Only pre-compute the seed since it's very cheap. Do the expensive computeProposers() call only on demand.
-      this.proposersNextEpoch = {computed: false, seed: getSeed(state, epochAfterUpcoming, DOMAIN_BEACON_PROPOSER)};
-    }
-  }
-
-  beforeEpochTransition(): void {
-    // Clone (copy) before being mutated in processEffectiveBalanceUpdates
-    // NOTE: Force to use Uint16Array.slice (copy) instead of Buffer.call (not copy)
-    this.effectiveBalanceIncrements = Uint16Array.prototype.slice.call(this.effectiveBalanceIncrements, 0);
-  }
-
-  /**
-   * Return the beacon committee at slot for index.
-   */
-  getBeaconCommittee(slot: Slot, index: CommitteeIndex): Uint32Array {
-    return this.getBeaconCommittees(slot, [index])[0];
-  }
-
-  /**
-   * Return a Uint32Array[] representing committees of indices
-   */
-  getBeaconCommittees(slot: Slot, indices: CommitteeIndex[]): Uint32Array[] {
-    if (indices.length === 0) {
-      throw new Error("Attempt to get committees without providing CommitteeIndex");
-    }
-
-    const slotCommittees = this.getShufflingAtSlot(slot).committees[slot % SLOTS_PER_EPOCH];
-    const committees = [];
-
-    for (const index of indices) {
-      if (index >= slotCommittees.length) {
-        throw new EpochCacheError({
-          code: EpochCacheErrorCode.COMMITTEE_INDEX_OUT_OF_RANGE,
-          index,
-          maxIndex: slotCommittees.length,
-        });
-      }
-      committees.push(slotCommittees[index]);
-    }
-
-    return committees;
-  }
-
-  getCommitteeCountPerSlot(epoch: Epoch): number {
-    return this.getShufflingAtEpoch(epoch).committeesPerSlot;
-  }
-
-  /**
-   * Compute the correct subnet for a slot/committee index
-   */
-  computeSubnetForSlot(slot: number, committeeIndex: number): SubnetID {
-    const slotsSinceEpochStart = slot % SLOTS_PER_EPOCH;
-    const committeesPerSlot = this.getCommitteeCountPerSlot(computeEpochAtSlot(slot));
-    const committeesSinceEpochStart = committeesPerSlot * slotsSinceEpochStart;
-    return (committeesSinceEpochStart + committeeIndex) % ATTESTATION_SUBNET_COUNT;
-  }
-
-  /**
-   * Read from proposers instead of state.proposer_lookahead because we set it in `finalProcessEpoch()`
-   * See https://github.com/ethereum/consensus-specs/blob/e9266b2145c09b63ba0039a9f477cfe8a629c78b/specs/fulu/beacon-chain.md#modified-get_beacon_proposer_index
-   */
-  getBeaconProposer(slot: Slot): ValidatorIndex {
-    const epoch = computeEpochAtSlot(slot);
-    if (epoch !== this.currentShuffling.epoch) {
-      throw new EpochCacheError({
-        code: EpochCacheErrorCode.PROPOSER_EPOCH_MISMATCH,
-        currentEpoch: this.currentShuffling.epoch,
-        requestedEpoch: epoch,
-      });
-    }
-    return this.proposers[slot % SLOTS_PER_EPOCH];
-  }
-
-  getBeaconProposers(): ValidatorIndex[] {
-    return this.proposers;
-  }
-
-  getBeaconProposersPrevEpoch(): ValidatorIndex[] | null {
-    return this.proposersPrevEpoch;
-  }
-
-  /**
-   * We allow requesting proposal duties 1 epoch in the future as in normal network conditions it's possible to predict
-   * the correct shuffling with high probability. While knowing the proposers in advance is not useful for consensus,
-   * users want to know it to plan manteinance and avoid missing block proposals.
-   *
-   * **How to predict future proposers**
-   *
-   * Proposer duties for epoch N are guaranteed to be known at epoch N. Proposer duties depend exclusively on:
-   * 1. seed (from randao_mix): known 2 epochs ahead
-   * 2. active validator set: known 4 epochs ahead
-   * 3. effective balance: not known ahead
-   *
-   * ```python
-   * def get_beacon_proposer_index(state: BeaconState) -> ValidatorIndex:
-   *   epoch = get_current_epoch(state)
-   *   seed = hash(get_seed(state, epoch, DOMAIN_BEACON_PROPOSER) + uint_to_bytes(state.slot))
-   *   indices = get_active_validator_indices(state, epoch)
-   *   return compute_proposer_index(state, indices, seed)
-   * ```
-   *
-   * **1**: If `MIN_SEED_LOOKAHEAD = 1` the randao_mix used for the seed is from 2 epochs ago. So at epoch N, the seed
-   * is known and unchangable for duties at epoch N+1 and N+2 for proposer duties.
-   *
-   * ```python
-   * def get_seed(state: BeaconState, epoch: Epoch, domain_type: DomainType) -> Bytes32:
-   *   mix = get_randao_mix(state, Epoch(epoch - MIN_SEED_LOOKAHEAD - 1))
-   *   return hash(domain_type + uint_to_bytes(epoch) + mix)
-   * ```
-   *
-   * **2**: The active validator set can be predicted `MAX_SEED_LOOKAHEAD` in advance due to how activations are
-   * processed. We already compute the active validator set for the next epoch to optimize epoch processing, so it's
-   * reused here.
-   *
-   * **3**: Effective balance is not known ahead of time, but it rarely changes. Even if it changes, only a few
-   * balances are sampled to adjust the probability of the next selection (32 per epoch on average). So to invalidate
-   * the prediction the effective of one of those 32 samples should change and change the random_byte inequality.
-   */
-  getBeaconProposersNextEpoch(): ValidatorIndex[] {
-    if (!this.proposersNextEpoch.computed) {
-      // this is lazily computed pre-fulu
-      const indexes = computeProposers(
-        this.config.getForkSeqAtEpoch(this.nextEpoch),
-        this.proposersNextEpoch.seed,
-        this.getShufflingAtEpoch(this.nextEpoch),
-        this.effectiveBalanceIncrements
-      );
-      this.proposersNextEpoch = {computed: true, indexes};
-    }
-
-    // this is eagerly computed post-fulu
-    return this.proposersNextEpoch.indexes;
-  }
-
-  /**
-   * Return the indexed attestation corresponding to ``attestation``.
-   */
-  getIndexedAttestation(fork: ForkSeq, attestation: Attestation): IndexedAttestation {
-    const {data} = attestation;
-    const attestingIndices = this.getAttestingIndices(fork, attestation);
-
-    // sort in-place
-    attestingIndices.sort((a, b) => a - b);
-    return {
-      attestingIndices: attestingIndices,
-      data: data,
-      signature: attestation.signature,
-    };
-  }
-
-  /**
-   * Return indices of validators who attestested in `attestation`
-   */
-  getAttestingIndices(fork: ForkSeq, attestation: Attestation): number[] {
-    if (fork < ForkSeq.electra) {
-      const {aggregationBits, data} = attestation;
-      const validatorIndices = this.getBeaconCommittee(data.slot, data.index);
-
-      return aggregationBits.intersectValues(validatorIndices);
-    }
-    const {aggregationBits, committeeBits, data} = attestation as electra.Attestation;
-
-    // There is a naming conflict on the term `committeeIndices`
-    // In Lodestar it usually means a list of validator indices of participants in a committee
-    // In the spec it means a list of committee indices according to committeeBits
-    // This `committeeIndices` refers to the latter
-    // TODO Electra: resolve the naming conflicts
-    const committeeIndices = committeeBits.getTrueBitIndexes();
-
-    const validatorsByCommittee = this.getBeaconCommittees(data.slot, committeeIndices);
-
-    // Create a new Uint32Array to flatten `validatorsByCommittee`
-    const totalLength = validatorsByCommittee.reduce((acc, curr) => acc + curr.length, 0);
-    const committeeValidators = new Uint32Array(totalLength);
-
-    let offset = 0;
-    for (const committee of validatorsByCommittee) {
-      committeeValidators.set(committee, offset);
-      offset += committee.length;
-    }
-
-    return aggregationBits.intersectValues(committeeValidators);
-  }
-
-  getCommitteeAssignments(
-    epoch: Epoch,
-    requestedValidatorIndices: ValidatorIndex[]
-  ): Map<ValidatorIndex, AttesterDuty> {
-    const shuffling = this.getShufflingAtEpoch(epoch);
-    return calculateCommitteeAssignments(shuffling, requestedValidatorIndices);
-  }
-
-  /**
-   * Return the committee assignment in the ``epoch`` for ``validator_index``.
-   * ``assignment`` returned is a tuple of the following form:
-   * ``assignment[0]`` is the list of validators in the committee
-   * ``assignment[1]`` is the index to which the committee is assigned
-   * ``assignment[2]`` is the slot at which the committee is assigned
-   * Return null if no assignment..
-   */
-  getCommitteeAssignment(epoch: Epoch, validatorIndex: ValidatorIndex): phase0.CommitteeAssignment | null {
-    if (epoch > this.currentShuffling.epoch + 1) {
-      throw Error(
-        `Requesting committee assignment for more than 1 epoch ahead: ${epoch} > ${this.currentShuffling.epoch} + 1`
-      );
-    }
-
-    const epochStartSlot = computeStartSlotAtEpoch(epoch);
-    const committeeCountPerSlot = this.getCommitteeCountPerSlot(epoch);
-    for (let slot = epochStartSlot; slot < epochStartSlot + SLOTS_PER_EPOCH; slot++) {
-      for (let i = 0; i < committeeCountPerSlot; i++) {
-        const committee = this.getBeaconCommittee(slot, i);
-        if (committee.includes(validatorIndex)) {
-          return {
-            validators: Array.from(committee),
-            committeeIndex: i,
-            slot,
-          };
-        }
-      }
-    }
-    return null;
-  }
-
-  isAggregator(slot: Slot, index: CommitteeIndex, slotSignature: BLSSignature): boolean {
-    const committee = this.getBeaconCommittee(slot, index);
-    return isAggregatorFromCommitteeLength(committee.length, slotSignature);
-  }
-
-  /**
-   * Return pubkey given the validator index.
-   */
-  getPubkey(index: ValidatorIndex): PublicKey | undefined {
-    return this.index2pubkey[index];
-  }
-
-  getValidatorIndex(pubkey: Uint8Array): ValidatorIndex | null {
-    return this.pubkey2index.get(pubkey);
-  }
-
-  addPubkey(index: ValidatorIndex, pubkey: Uint8Array): void {
-    this.pubkey2index.set(pubkey, index);
-    this.index2pubkey[index] = PublicKey.fromBytes(pubkey); // Optimize for aggregation
-  }
-
-  getShufflingAtSlot(slot: Slot): EpochShuffling {
-    const epoch = computeEpochAtSlot(slot);
-    return this.getShufflingAtEpoch(epoch);
-  }
-
-  getShufflingAtSlotOrNull(slot: Slot): EpochShuffling | null {
-    const epoch = computeEpochAtSlot(slot);
-    return this.getShufflingAtEpochOrNull(epoch);
-  }
-
-  getShufflingAtEpoch(epoch: Epoch): EpochShuffling {
-    const shuffling = this.getShufflingAtEpochOrNull(epoch);
-    if (shuffling === null) {
-      if (epoch === this.nextEpoch) {
-        throw new EpochCacheError({
-          code: EpochCacheErrorCode.NEXT_SHUFFLING_NOT_AVAILABLE,
-          epoch: epoch,
-          decisionRoot: this.getShufflingDecisionRoot(this.nextEpoch),
-        });
-      }
-      throw new EpochCacheError({
-        code: EpochCacheErrorCode.COMMITTEE_EPOCH_OUT_OF_RANGE,
-        currentEpoch: this.currentShuffling.epoch,
-        requestedEpoch: epoch,
-      });
-    }
-
-    return shuffling;
-  }
-
-  getShufflingDecisionRoot(epoch: Epoch): RootHex {
-    switch (epoch) {
-      case this.epoch - 1:
-        return this.previousDecisionRoot;
-      case this.epoch:
-        return this.currentDecisionRoot;
-      case this.nextEpoch:
-        return this.nextDecisionRoot;
-      default:
-        throw new EpochCacheError({
-          code: EpochCacheErrorCode.DECISION_ROOT_EPOCH_OUT_OF_RANGE,
-          currentEpoch: this.epoch,
-          requestedEpoch: epoch,
-        });
-    }
-  }
-
-  getShufflingAtEpochOrNull(epoch: Epoch): EpochShuffling | null {
-    switch (epoch) {
-      case this.epoch - 1:
-        return this.previousShuffling;
-      case this.epoch:
-        return this.currentShuffling;
-      case this.nextEpoch:
-        if (!this.nextShuffling) {
-          this.nextShuffling =
-            this.shufflingCache?.getSync(this.nextEpoch, this.getShufflingDecisionRoot(this.nextEpoch)) ?? null;
-        }
-        return this.nextShuffling;
-      default:
-        return null;
-    }
-  }
-
-  /**
-   * Note: The range of slots a validator has to perform duties is off by one.
-   * The previous slot wording means that if your validator is in a sync committee for a period that runs from slot
-   * 100 to 200,then you would actually produce signatures in slot 99 - 199.
-   */
-  getIndexedSyncCommittee(slot: Slot): SyncCommitteeCache {
-    // See note above for the +1 offset
-    return this.getIndexedSyncCommitteeAtEpoch(computeEpochAtSlot(slot + 1));
-  }
-
-  /**
-   * **DO NOT USE FOR GOSSIP VALIDATION**: Sync committee duties are offset by one slot. @see {@link EpochCache.getIndexedSyncCommittee}
-   *
-   * Get indexed sync committee at epoch without offsets
-   */
-  getIndexedSyncCommitteeAtEpoch(epoch: Epoch): SyncCommitteeCache {
-    switch (computeSyncPeriodAtEpoch(epoch)) {
-      case this.syncPeriod:
-        return this.currentSyncCommitteeIndexed;
-      case this.syncPeriod + 1:
-        return this.nextSyncCommitteeIndexed;
-      default:
-        throw new EpochCacheError({code: EpochCacheErrorCode.NO_SYNC_COMMITTEE, epoch});
-    }
-  }
-
-  /** On processSyncCommitteeUpdates rotate next to current and set nextSyncCommitteeIndexed */
-  rotateSyncCommitteeIndexed(nextSyncCommitteeIndices: Uint32Array): void {
-    this.currentSyncCommitteeIndexed = this.nextSyncCommitteeIndexed;
-    this.nextSyncCommitteeIndexed = getSyncCommitteeCache(nextSyncCommitteeIndices);
-  }
-
-  /** On phase0 -> altair fork, set both current and nextSyncCommitteeIndexed */
-  setSyncCommitteesIndexed(nextSyncCommitteeIndices: Uint32Array): void {
-    this.nextSyncCommitteeIndexed = getSyncCommitteeCache(nextSyncCommitteeIndices);
-    this.currentSyncCommitteeIndexed = this.nextSyncCommitteeIndexed;
-  }
-
-  effectiveBalanceIncrementsSet(index: number, effectiveBalance: number): void {
-    if (this.isPostElectra()) {
-      // TODO: electra
-      // getting length and setting getEffectiveBalanceIncrementsByteLen is not fork safe
-      // so each time we add an index, we should new the Uint8Array to keep it forksafe
-      // one simple optimization could be to increment the length once per block rather
-      // on each add/set
-      //
-      // there could still be some unused length remaining from the prev ELECTRA padding
-      const newLength =
-        index >= this.effectiveBalanceIncrements.length ? index + 1 : this.effectiveBalanceIncrements.length;
-      const effectiveBalanceIncrements = this.effectiveBalanceIncrements;
-      this.effectiveBalanceIncrements = new Uint16Array(newLength);
-      this.effectiveBalanceIncrements.set(effectiveBalanceIncrements, 0);
-    } else {
-      if (index >= this.effectiveBalanceIncrements.length) {
-        // Clone and extend effectiveBalanceIncrements
-        const effectiveBalanceIncrements = this.effectiveBalanceIncrements;
-        this.effectiveBalanceIncrements = new Uint16Array(getEffectiveBalanceIncrementsByteLen(index + 1));
-        this.effectiveBalanceIncrements.set(effectiveBalanceIncrements, 0);
-      }
-    }
-
-    this.effectiveBalanceIncrements[index] = Math.floor(effectiveBalance / EFFECTIVE_BALANCE_INCREMENT);
-  }
-
-  isPostElectra(): boolean {
-    return this.epoch >= this.config.ELECTRA_FORK_EPOCH;
-  }
-}
-
-function getEffectiveBalanceIncrementsByteLen(validatorCount: number): number {
-  // TODO: Research what's the best number to minimize both memory cost and copy costs
-  return 1024 * Math.ceil(validatorCount / 1024);
-}
-
-export enum EpochCacheErrorCode {
-  COMMITTEE_INDEX_OUT_OF_RANGE = "EPOCH_CONTEXT_ERROR_COMMITTEE_INDEX_OUT_OF_RANGE",
-  COMMITTEE_EPOCH_OUT_OF_RANGE = "EPOCH_CONTEXT_ERROR_COMMITTEE_EPOCH_OUT_OF_RANGE",
-  DECISION_ROOT_EPOCH_OUT_OF_RANGE = "EPOCH_CONTEXT_ERROR_DECISION_ROOT_EPOCH_OUT_OF_RANGE",
-  NEXT_SHUFFLING_NOT_AVAILABLE = "EPOCH_CONTEXT_ERROR_NEXT_SHUFFLING_NOT_AVAILABLE",
-  NO_SYNC_COMMITTEE = "EPOCH_CONTEXT_ERROR_NO_SYNC_COMMITTEE",
-  PROPOSER_EPOCH_MISMATCH = "EPOCH_CONTEXT_ERROR_PROPOSER_EPOCH_MISMATCH",
-}
-
-type EpochCacheErrorType =
-  | {
-      code: EpochCacheErrorCode.COMMITTEE_INDEX_OUT_OF_RANGE;
-      index: number;
-      maxIndex: number;
-    }
-  | {
-      code: EpochCacheErrorCode.COMMITTEE_EPOCH_OUT_OF_RANGE;
-      requestedEpoch: Epoch;
-      currentEpoch: Epoch;
-    }
-  | {
-      code: EpochCacheErrorCode.DECISION_ROOT_EPOCH_OUT_OF_RANGE;
-      requestedEpoch: Epoch;
-      currentEpoch: Epoch;
-    }
-  | {
-      code: EpochCacheErrorCode.NEXT_SHUFFLING_NOT_AVAILABLE;
-      epoch: Epoch;
-      decisionRoot: RootHex;
-    }
-  | {
-      code: EpochCacheErrorCode.NO_SYNC_COMMITTEE;
-      epoch: Epoch;
-    }
-  | {
-      code: EpochCacheErrorCode.PROPOSER_EPOCH_MISMATCH;
-      requestedEpoch: Epoch;
-      currentEpoch: Epoch;
-    };
-
-export class EpochCacheError extends LodestarError<EpochCacheErrorType> {}
-
-export function createEmptyEpochCacheImmutableData(
-  chainConfig: ChainConfig,
-  state: Pick<BeaconStateAllForks, "genesisValidatorsRoot">
-): EpochCacheImmutableData {
-  return {
-    config: createBeaconConfig(chainConfig, state.genesisValidatorsRoot),
-    // This is a test state, there's no need to have a global shared cache of keys
-    pubkey2index: new PubkeyIndexMap(),
-    index2pubkey: [],
-  };
-}