@lodestar/state-transition 1.40.0 → 1.41.0-dev.0087e7a664

package/src/block/processDepositRequest.ts

@@ -14,7 +14,8 @@ export function applyDepositForBuilder(
   pubkey: BLSPubkey,
   withdrawalCredentials: Bytes32,
   amount: UintNum64,
-  signature: Bytes32
+  signature: Bytes32,
+  slot: UintNum64
 ): void {
   const builderIndex = findBuilderIndexByPubkey(state, pubkey);
 
@@ -25,7 +26,7 @@ export function applyDepositForBuilder(
   } else {
     // New builder - verify signature and add to registry
     if (isValidDepositSignature(state.config, pubkey, withdrawalCredentials, amount, signature)) {
-      addBuilderToRegistry(state, pubkey, withdrawalCredentials, amount);
+      addBuilderToRegistry(state, pubkey, withdrawalCredentials, amount, slot);
     }
   }
 }
@@ -38,9 +39,11 @@ function addBuilderToRegistry(
   state: CachedBeaconStateGloas,
   pubkey: BLSPubkey,
   withdrawalCredentials: Bytes32,
-  amount: UintNum64
+  amount: UintNum64,
+  slot: UintNum64
 ): void {
   const currentEpoch = computeEpochAtSlot(state.slot);
+  const depositEpoch = computeEpochAtSlot(slot);
 
   // Try to find a reusable slot from an exited builder with zero balance
   let builderIndex = state.builders.length;
@@ -58,7 +61,7 @@ function addBuilderToRegistry(
     version: withdrawalCredentials[0],
     executionAddress: withdrawalCredentials.subarray(12),
     balance: amount,
-    depositEpoch: currentEpoch,
+    depositEpoch: depositEpoch,
     withdrawableEpoch: FAR_FUTURE_EPOCH,
   });
 
@@ -93,7 +96,7 @@ export function processDepositRequest(
     // Route to builder if it's an existing builder OR has builder prefix and is not a validator
     if (isBuilder || (isBuilderPrefix && !isValidator)) {
       // Apply builder deposits immediately
-      applyDepositForBuilder(stateGloas, pubkey, withdrawalCredentials, amount, signature);
+      applyDepositForBuilder(stateGloas, pubkey, withdrawalCredentials, amount, signature, state.slot);
       return;
     }
   }

package/src/block/processExecutionPayloadBid.ts

@@ -2,11 +2,11 @@ import {PublicKey, Signature, verify} from "@chainsafe/blst";
 import {BUILDER_INDEX_SELF_BUILD, ForkPostGloas, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {BeaconBlock, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
-import {G2_POINT_AT_INFINITY} from "../constants/constants.ts";
+import {G2_POINT_AT_INFINITY} from "../constants/constants.js";
 import {getExecutionPayloadBidSigningRoot} from "../signatureSets/executionPayloadBid.js";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {canBuilderCoverBid, isActiveBuilder} from "../util/gloas.ts";
-import {getCurrentEpoch, getRandaoMix} from "../util/index.ts";
+import {CachedBeaconStateGloas} from "../types.js";
+import {canBuilderCoverBid, isActiveBuilder} from "../util/gloas.js";
+import {getCurrentEpoch, getRandaoMix} from "../util/index.js";
 
 export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block: BeaconBlock<ForkPostGloas>): void {
   const signedBid = block.body.signedExecutionPayloadBid;
@@ -63,6 +63,14 @@ export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block:
     throw Error(`Prev randao ${toHex(bid.prevRandao)} of bid does not match state's randao mix ${toHex(stateRandao)}`);
   }
 
+  // Verify commitments are under limit
+  const maxBlobsPerBlock = state.config.getMaxBlobsPerBlock(state.epochCtx.epoch);
+  if (bid.blobKzgCommitments.length > maxBlobsPerBlock) {
+    throw Error(
+      `Kzg commitments exceed limit commitments.length=${bid.blobKzgCommitments.length} limit=${maxBlobsPerBlock}`
+    );
+  }
+
   if (amount > 0) {
     const pendingPaymentView = ssz.gloas.BuilderPendingPayment.toViewDU({
       weight: 0,

package/src/block/processExecutionPayloadEnvelope.ts

@@ -7,18 +7,25 @@ import {
 } from "@lodestar/params";
 import {gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {computeSigningRoot, computeTimeAtSlot} from "../util/index.ts";
-import {processConsolidationRequest} from "./processConsolidationRequest.ts";
-import {processDepositRequest} from "./processDepositRequest.ts";
-import {processWithdrawalRequest} from "./processWithdrawalRequest.ts";
-
-// This function does not call execution engine to verify payload. Need to call it from other place
+import {CachedBeaconStateGloas} from "../types.js";
+import {computeSigningRoot, computeTimeAtSlot} from "../util/index.js";
+import {processConsolidationRequest} from "./processConsolidationRequest.js";
+import {processDepositRequest} from "./processDepositRequest.js";
+import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
+
+export type ProcessExecutionPayloadEnvelopeOpts = {
+  dontTransferCache?: boolean;
+};
+
+// Unlike other block processing functions which mutate state in-place, this function
+// clones the state and returns the post-state, similar to stateTransition().
+// This function does not call execution engine to verify payload. Need to call it from other place.
 export function processExecutionPayloadEnvelope(
   state: CachedBeaconStateGloas,
   signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
-  verify: boolean
-): void {
+  verify: boolean,
+  opts?: ProcessExecutionPayloadEnvelopeOpts
+): CachedBeaconStateGloas {
   const envelope = signedEnvelope.message;
   const payload = envelope.payload;
   const fork = state.config.getForkSeq(envelope.slot);
@@ -27,42 +34,49 @@ export function processExecutionPayloadEnvelope(
     throw Error(`Execution payload envelope has invalid signature builderIndex=${envelope.builderIndex}`);
   }
 
-  validateExecutionPayloadEnvelope(state, envelope);
+  // .clone() before mutating state, similar to stateTransition()
+  const postState = state.clone(opts?.dontTransferCache) as CachedBeaconStateGloas;
+
+  validateExecutionPayloadEnvelope(postState, envelope);
 
   const requests = envelope.executionRequests;
 
   for (const deposit of requests.deposits) {
-    processDepositRequest(fork, state, deposit);
+    processDepositRequest(fork, postState, deposit);
   }
 
   for (const withdrawal of requests.withdrawals) {
-    processWithdrawalRequest(fork, state, withdrawal);
+    processWithdrawalRequest(fork, postState, withdrawal);
   }
 
   for (const consolidation of requests.consolidations) {
-    processConsolidationRequest(state, consolidation);
+    processConsolidationRequest(postState, consolidation);
   }
 
   // Queue the builder payment
-  const paymentIndex = SLOTS_PER_EPOCH + (state.slot % SLOTS_PER_EPOCH);
-  const payment = state.builderPendingPayments.get(paymentIndex).clone();
+  const paymentIndex = SLOTS_PER_EPOCH + (postState.slot % SLOTS_PER_EPOCH);
+  const payment = postState.builderPendingPayments.get(paymentIndex).clone();
   const amount = payment.withdrawal.amount;
 
   if (amount > 0) {
-    state.builderPendingWithdrawals.push(payment.withdrawal);
+    postState.builderPendingWithdrawals.push(payment.withdrawal);
   }
 
-  state.builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
+  postState.builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
 
   // Cache the execution payload hash
-  state.executionPayloadAvailability.set(state.slot % SLOTS_PER_HISTORICAL_ROOT, true);
-  state.latestBlockHash = payload.blockHash;
+  postState.executionPayloadAvailability.set(postState.slot % SLOTS_PER_HISTORICAL_ROOT, true);
+  postState.latestBlockHash = payload.blockHash;
+
+  postState.commit();
 
-  if (verify && !byteArrayEquals(envelope.stateRoot, state.hashTreeRoot())) {
+  if (verify && !byteArrayEquals(envelope.stateRoot, postState.hashTreeRoot())) {
     throw new Error(
-      `Envelope's state root does not match state envelope=${toRootHex(envelope.stateRoot)} state=${toRootHex(state.hashTreeRoot())}`
+      `Envelope's state root does not match state envelope=${toRootHex(envelope.stateRoot)} state=${toRootHex(postState.hashTreeRoot())}`
     );
   }
+
+  return postState;
 }
 
 function validateExecutionPayloadEnvelope(
@@ -96,13 +110,6 @@ function validateExecutionPayloadEnvelope(
     );
   }
 
-  const envelopeKzgRoot = ssz.deneb.BlobKzgCommitments.hashTreeRoot(envelope.blobKzgCommitments);
-  if (!byteArrayEquals(committedBid.blobKzgCommitmentsRoot, envelopeKzgRoot)) {
-    throw new Error(
-      `Kzg commitment root mismatch between envelope and committed bid envelope=${toRootHex(envelopeKzgRoot)} committedBid=${toRootHex(committedBid.blobKzgCommitmentsRoot)}`
-    );
-  }
-
   if (!byteArrayEquals(committedBid.prevRandao, payload.prevRandao)) {
     throw new Error(
       `Prev randao mismatch between committed bid and payload committedBid=${toHex(committedBid.prevRandao)} payload=${toHex(payload.prevRandao)}`
@@ -146,14 +153,6 @@ function validateExecutionPayloadEnvelope(
     );
   }
 
-  // Verify commitments are under limit
-  const maxBlobsPerBlock = state.config.getMaxBlobsPerBlock(state.epochCtx.epoch);
-  if (envelope.blobKzgCommitments.length > maxBlobsPerBlock) {
-    throw new Error(
-      `Kzg commitments exceed limit commitment.length=${envelope.blobKzgCommitments.length} limit=${maxBlobsPerBlock}`
-    );
-  }
-
   // Skipped: Verify the execution payload is valid
 }
 
@@ -171,7 +170,11 @@ function verifyExecutionPayloadEnvelopeSignature(
 
     if (builderIndex === BUILDER_INDEX_SELF_BUILD) {
       const validatorIndex = state.latestBlockHeader.proposerIndex;
-      publicKey = state.epochCtx.index2pubkey[validatorIndex];
+      const proposerPubkey = state.epochCtx.pubkeyCache.get(validatorIndex);
+      if (!proposerPubkey) {
+        return false;
+      }
+      publicKey = proposerPubkey;
     } else {
       publicKey = PublicKey.fromBytes(state.builders.getReadonly(builderIndex).pubkey);
     }

package/src/block/processOperations.ts

@@ -14,7 +14,7 @@ import {processBlsToExecutionChange} from "./processBlsToExecutionChange.js";
 import {processConsolidationRequest} from "./processConsolidationRequest.js";
 import {processDeposit} from "./processDeposit.js";
 import {processDepositRequest} from "./processDepositRequest.js";
-import {processPayloadAttestation} from "./processPayloadAttestation.ts";
+import {processPayloadAttestation} from "./processPayloadAttestation.js";
 import {processProposerSlashing} from "./processProposerSlashing.js";
 import {processVoluntaryExit} from "./processVoluntaryExit.js";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.js";

package/src/block/processPayloadAttestation.ts

@@ -1,7 +1,7 @@
 import {gloas} from "@lodestar/types";
 import {byteArrayEquals} from "@lodestar/utils";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.ts";
+import {CachedBeaconStateGloas} from "../types.js";
+import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.js";
 
 export function processPayloadAttestation(
   state: CachedBeaconStateGloas,

package/src/block/processProposerSlashing.ts

@@ -2,7 +2,7 @@ import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {Slot, phase0, ssz} from "@lodestar/types";
 import {Validator} from "@lodestar/types/phase0";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot, isSlashableValidator} from "../util/index.js";
@@ -24,7 +24,7 @@ export function processProposerSlashing(
   const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
   assertValidProposerSlashing(
     state.config,
-    state.epochCtx.index2pubkey,
+    state.epochCtx.pubkeyCache,
     state.slot,
     proposerSlashing,
     proposer,
@@ -57,7 +57,7 @@ export function processProposerSlashing(
 
 export function assertValidProposerSlashing(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing,
   proposer: Validator,
@@ -94,7 +94,7 @@ export function assertValidProposerSlashing(
   if (verifySignatures) {
     const signatureSets = getProposerSlashingSignatureSets(config, stateSlot, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
-      if (!verifySignatureSet(signatureSets[i], index2pubkey)) {
+      if (!verifySignatureSet(signatureSets[i], pubkeyCache)) {
         throw new Error(`ProposerSlashing header${i + 1} signature invalid`);
       }
     }

package/src/block/processRandao.ts

@@ -17,7 +17,7 @@ export function processRandao(state: CachedBeaconStateAllForks, block: BeaconBlo
   const randaoReveal = block.body.randaoReveal;
 
   // verify RANDAO reveal
-  if (verifySignature && !verifyRandaoSignature(config, epochCtx.index2pubkey, block)) {
+  if (verifySignature && !verifyRandaoSignature(config, epochCtx.pubkeyCache, block)) {
     throw new Error("RANDAO reveal is an invalid signature");
   }
 

package/src/block/processSyncCommittee.ts

@@ -32,7 +32,7 @@ export function processSyncAggregate(
       participantIndices
     );
     // When there's no participation we consider the signature valid and just ignore it
-    if (signatureSet !== null && !verifySignatureSet(signatureSet, state.epochCtx.index2pubkey)) {
+    if (signatureSet !== null && !verifySignatureSet(signatureSet, state.epochCtx.pubkeyCache)) {
       throw Error("Sync committee signature invalid");
     }
   }

package/src/block/processVoluntaryExit.ts

@@ -131,7 +131,7 @@ export function getVoluntaryExitValidity(
 
   if (
     verifySignature &&
-    !verifyVoluntaryExitSignature(state.config, epochCtx.index2pubkey, state.slot, signedVoluntaryExit)
+    !verifyVoluntaryExitSignature(state.config, epochCtx.pubkeyCache, state.slot, signedVoluntaryExit)
   ) {
     return VoluntaryExitValidity.invalidSignature;
   }

package/src/block/processWithdrawalRequest.ts

@@ -21,7 +21,7 @@ export function processWithdrawalRequest(
   const amount = Number(withdrawalRequest.amount);
   const {pendingPartialWithdrawals, validators, epochCtx} = state;
   // no need to use unfinalized pubkey cache from 6110 as validator won't be active anyway
-  const {pubkey2index, config} = epochCtx;
+  const {pubkeyCache, config} = epochCtx;
   const isFullExitRequest = amount === FULL_EXIT_REQUEST_AMOUNT;
 
   // If partial withdrawal queue is full, only full exits are processed
@@ -31,7 +31,7 @@ export function processWithdrawalRequest(
 
   // bail out if validator is not in beacon state
   // note that we don't need to check for 6110 unfinalized vals as they won't be eligible for withdraw/exit anyway
-  const validatorIndex = pubkey2index.get(withdrawalRequest.validatorPubkey);
+  const validatorIndex = pubkeyCache.getIndex(withdrawalRequest.validatorPubkey);
   if (validatorIndex === null) {
     return;
   }

package/src/block/processWithdrawals.ts

@@ -16,7 +16,7 @@ import {
   convertValidatorIndexToBuilderIndex,
   isBuilderIndex,
   isParentBlockFull,
-} from "../util/gloas.ts";
+} from "../util/gloas.js";
 import {
   decreaseBalance,
   getMaxEffectiveBalance,
@@ -249,6 +249,10 @@ function getPendingPartialWithdrawals(
     numPriorWithdrawal + MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
     MAX_WITHDRAWALS_PER_PAYLOAD - 1
   );
+  // There must be at least one space reserved for validator sweep withdrawals
+  if (numPriorWithdrawal > partialWithdrawalBound) {
+    throw Error(`Prior withdrawals exceed limit: ${numPriorWithdrawal} > ${partialWithdrawalBound}`);
+  }
 
   // MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP = 8, PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728 so we should only call getAllReadonly() if it makes sense
   // pendingPartialWithdrawals comes from EIP-7002 smart contract where it takes fee so it's more likely than not validator is in correct condition to withdraw
@@ -309,6 +313,11 @@ function getValidatorsSweepWithdrawals(
   numPriorWithdrawal: number,
   validatorBalanceAfterWithdrawals: Map<ValidatorIndex, number>
 ): {sweepWithdrawals: capella.Withdrawal[]; processedCount: number} {
+  // There must be at least one space reserved for validator sweep withdrawals
+  if (numPriorWithdrawal >= MAX_WITHDRAWALS_PER_PAYLOAD) {
+    throw Error(`Prior withdrawals exceed limit: ${numPriorWithdrawal} >= ${MAX_WITHDRAWALS_PER_PAYLOAD}`);
+  }
+
   const sweepWithdrawals: capella.Withdrawal[] = [];
   const epoch = state.epochCtx.epoch;
   const {validators, balances, nextWithdrawalValidatorIndex} = state;
@@ -319,7 +328,7 @@ function getValidatorsSweepWithdrawals(
   // Just run a bounded loop max iterating over all withdrawals
   // however breaks out once we have MAX_WITHDRAWALS_PER_PAYLOAD
   for (let n = 0; n < validatorsLimit; n++) {
-    if (sweepWithdrawals.length + numPriorWithdrawal === MAX_WITHDRAWALS_PER_PAYLOAD) {
+    if (sweepWithdrawals.length + numPriorWithdrawal >= MAX_WITHDRAWALS_PER_PAYLOAD) {
       break;
     }
 

package/src/cache/epochCache.ts

@@ -1,5 +1,4 @@
 import {PublicKey} from "@chainsafe/blst";
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconConfig, ChainConfig, createBeaconConfig} from "@lodestar/config";
 import {
   ATTESTATION_SUBNET_COUNT,
@@ -36,6 +35,7 @@ import {
 import {
   computeActivationExitEpoch,
   computeEpochAtSlot,
+  computePayloadTimelinessCommitteesForEpoch,
   computeProposers,
   computeSyncPeriodAtEpoch,
   getActivationChurnLimit,
@@ -43,7 +43,6 @@ import {
   getSeed,
   isActiveValidator,
   isAggregatorFromCommitteeLength,
-  naiveGetPayloadTimlinessCommitteeIndices,
 } from "../util/index.js";
 import {
   AttesterDuty,
@@ -56,7 +55,7 @@ import {computeBaseRewardPerIncrement, computeSyncParticipantReward} from "../ut
 import {sumTargetUnslashedBalanceIncrements} from "../util/targetUnslashedBalance.js";
 import {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsWithLen} from "./effectiveBalanceIncrements.js";
 import {EpochTransitionCache} from "./epochTransitionCache.js";
-import {Index2PubkeyCache, syncPubkeys} from "./pubkeyCache.js";
+import {PubkeyCache, createPubkeyCache, syncPubkeys} from "./pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateFulu} from "./stateCache.js";
 import {
   SyncCommitteeCache,
@@ -64,15 +63,14 @@ import {
   computeSyncCommitteeCache,
   getSyncCommitteeCache,
 } from "./syncCommitteeCache.js";
-import {BeaconStateAllForks, BeaconStateAltair, BeaconStateGloas, ShufflingGetter} from "./types.js";
+import {BeaconStateAllForks, BeaconStateAltair, ShufflingGetter} 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;
+  pubkeyCache: PubkeyCache;
 };
 
 export type EpochCacheOpts = {
@@ -111,15 +109,9 @@ export class EpochCache {
   /**
    * Unique globally shared pubkey registry. There should only exist one for the entire application.
    *
-   * $VALIDATOR_COUNT x 192 char String -> Number Map
+   * Couples both index→pubkey and pubkey→index lookups, keeping them in sync atomically.
    */
-  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;
+  pubkeyCache: PubkeyCache;
   /**
    * Indexes of the block proposers for the current epoch.
    * For pre-fulu, this is computed and cached from the current shuffling.
@@ -234,9 +226,11 @@ export class EpochCache {
   /** TODO: Indexed SyncCommitteeCache */
   nextSyncCommitteeIndexed: SyncCommitteeCache;
 
-  // TODO GLOAS: See if we need to cached PTC for prev/next epoch
-  // PTC for current epoch
-  payloadTimelinessCommittee: ValidatorIndex[][];
+  // TODO GLOAS: See if we need to cache PTC for next epoch
+  // PTC for previous epoch, required for slot N block validating slot N-1 attestations
+  previousPayloadTimelinessCommittees: Uint32Array[];
+  // PTC for current epoch, computed eagerly at epoch transition
+  payloadTimelinessCommittees: Uint32Array[];
 
   // TODO: Helper stats
   syncPeriod: SyncPeriod;
@@ -249,8 +243,7 @@ export class EpochCache {
 
   constructor(data: {
     config: BeaconConfig;
-    pubkey2index: PubkeyIndexMap;
-    index2pubkey: Index2PubkeyCache;
+    pubkeyCache: PubkeyCache;
     proposers: number[];
     proposersPrevEpoch: number[] | null;
     proposersNextEpoch: ProposersDeferred;
@@ -275,13 +268,13 @@ export class EpochCache {
     previousTargetUnslashedBalanceIncrements: number;
     currentSyncCommitteeIndexed: SyncCommitteeCache;
     nextSyncCommitteeIndexed: SyncCommitteeCache;
-    payloadTimelinessCommittee: ValidatorIndex[][];
+    previousPayloadTimelinessCommittees: Uint32Array[];
+    payloadTimelinessCommittees: Uint32Array[];
     epoch: Epoch;
     syncPeriod: SyncPeriod;
   }) {
     this.config = data.config;
-    this.pubkey2index = data.pubkey2index;
-    this.index2pubkey = data.index2pubkey;
+    this.pubkeyCache = data.pubkeyCache;
     this.proposers = data.proposers;
     this.proposersPrevEpoch = data.proposersPrevEpoch;
     this.proposersNextEpoch = data.proposersNextEpoch;
@@ -306,7 +299,8 @@ export class EpochCache {
     this.previousTargetUnslashedBalanceIncrements = data.previousTargetUnslashedBalanceIncrements;
     this.currentSyncCommitteeIndexed = data.currentSyncCommitteeIndexed;
     this.nextSyncCommitteeIndexed = data.nextSyncCommitteeIndexed;
-    this.payloadTimelinessCommittee = data.payloadTimelinessCommittee;
+    this.previousPayloadTimelinessCommittees = data.previousPayloadTimelinessCommittees;
+    this.payloadTimelinessCommittees = data.payloadTimelinessCommittees;
     this.epoch = data.epoch;
     this.syncPeriod = data.syncPeriod;
   }
@@ -319,7 +313,7 @@ export class EpochCache {
    */
   static createFromState(
     state: BeaconStateAllForks,
-    {config, pubkey2index, index2pubkey}: EpochCacheImmutableData,
+    {config, pubkeyCache}: EpochCacheImmutableData,
     opts?: EpochCacheOpts
   ): EpochCache {
     const currentEpoch = computeEpochAtSlot(state.slot);
@@ -335,9 +329,9 @@ export class EpochCache {
     const validatorCount = validators.length;
 
     // syncPubkeys here to ensure EpochCacheImmutableData is popualted before computing the rest of caches
-    // - computeSyncCommitteeCache() needs a fully populated pubkey2index cache
+    // - computeSyncCommitteeCache() needs a fully populated pubkeyCache
     if (!opts?.skipSyncPubkeys) {
-      syncPubkeys(validators, pubkey2index, index2pubkey);
+      syncPubkeys(pubkeyCache, validators);
     }
 
     const effectiveBalanceIncrements = getEffectiveBalanceIncrementsWithLen(validatorCount);
@@ -450,22 +444,32 @@ export class EpochCache {
     // 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);
+      currentSyncCommitteeIndexed = computeSyncCommitteeCache(altairState.currentSyncCommittee, pubkeyCache);
+      nextSyncCommitteeIndexed = computeSyncCommitteeCache(altairState.nextSyncCommittee, pubkeyCache);
     } else {
       currentSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
       nextSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
     }
 
-    // Compute PTC for this epoch
-    let payloadTimelinessCommittee: ValidatorIndex[][] = [];
+    // Compute PTC for all slots in the prev/current epoch
+    let previousPayloadTimelinessCommittees: Uint32Array[] = [];
+    let payloadTimelinessCommittees: Uint32Array[] = [];
     if (currentEpoch >= config.GLOAS_FORK_EPOCH) {
-      payloadTimelinessCommittee = naiveGetPayloadTimlinessCommitteeIndices(
-        state as BeaconStateGloas,
-        currentShuffling,
-        effectiveBalanceIncrements,
-        currentEpoch
+      payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+        state,
+        currentEpoch,
+        currentShuffling.committees,
+        effectiveBalanceIncrements
       );
+
+      if (!isGenesis && previousEpoch >= config.GLOAS_FORK_EPOCH) {
+        previousPayloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+          state,
+          previousEpoch,
+          previousShuffling.committees,
+          effectiveBalanceIncrements
+        );
+      }
     }
 
     // Precompute churnLimit for efficient initiateValidatorExit() during block proposing MUST be recompute everytime the
@@ -514,8 +518,7 @@ export class EpochCache {
 
     return new EpochCache({
       config,
-      pubkey2index,
-      index2pubkey,
+      pubkeyCache,
       proposers,
       // On first epoch, set to null to prevent unnecessary work since this is only used for metrics
       proposersPrevEpoch: null,
@@ -541,7 +544,8 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed,
-      payloadTimelinessCommittee: payloadTimelinessCommittee,
+      previousPayloadTimelinessCommittees,
+      payloadTimelinessCommittees,
       epoch: currentEpoch,
       syncPeriod: computeSyncPeriodAtEpoch(currentEpoch),
     });
@@ -557,8 +561,7 @@ export class EpochCache {
     return new EpochCache({
       config: this.config,
       // Common append-only structures shared with all states, no need to clone
-      pubkey2index: this.pubkey2index,
-      index2pubkey: this.index2pubkey,
+      pubkeyCache: this.pubkeyCache,
       // Immutable data
       proposers: this.proposers,
       proposersPrevEpoch: this.proposersPrevEpoch,
@@ -587,7 +590,8 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements: this.currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed: this.currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed: this.nextSyncCommitteeIndexed,
-      payloadTimelinessCommittee: this.payloadTimelinessCommittee,
+      previousPayloadTimelinessCommittees: this.previousPayloadTimelinessCommittees,
+      payloadTimelinessCommittees: this.payloadTimelinessCommittees,
       epoch: this.epoch,
       syncPeriod: this.syncPeriod,
     });
@@ -698,11 +702,13 @@ export class EpochCache {
 
     this.proposersPrevEpoch = this.proposers;
     if (upcomingEpoch >= this.config.GLOAS_FORK_EPOCH) {
-      this.payloadTimelinessCommittee = naiveGetPayloadTimlinessCommitteeIndices(
-        state as BeaconStateGloas,
-        this.currentShuffling,
-        this.effectiveBalanceIncrements,
-        upcomingEpoch
+      // Shift and compute current epoch PTC eagerly for all slots
+      this.previousPayloadTimelinessCommittees = this.payloadTimelinessCommittees;
+      this.payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+        state,
+        upcomingEpoch,
+        this.currentShuffling.committees,
+        this.effectiveBalanceIncrements
       );
     }
     if (upcomingEpoch >= this.config.FULU_FORK_EPOCH) {
@@ -882,16 +888,15 @@ export class EpochCache {
    * Return pubkey given the validator index.
    */
   getPubkey(index: ValidatorIndex): PublicKey | undefined {
-    return this.index2pubkey[index];
+    return this.pubkeyCache.get(index);
   }
 
   getValidatorIndex(pubkey: Uint8Array): ValidatorIndex | null {
-    return this.pubkey2index.get(pubkey);
+    return this.pubkeyCache.getIndex(pubkey);
   }
 
   addPubkey(index: ValidatorIndex, pubkey: Uint8Array): void {
-    this.pubkey2index.set(pubkey, index);
-    this.index2pubkey[index] = PublicKey.fromBytes(pubkey); // Optimize for aggregation
+    this.pubkeyCache.set(index, pubkey);
   }
 
   getShufflingAtSlot(slot: Slot): EpochShuffling {
@@ -1022,7 +1027,7 @@ export class EpochCache {
     return this.epoch >= this.config.ELECTRA_FORK_EPOCH;
   }
 
-  getPayloadTimelinessCommittee(slot: Slot): ValidatorIndex[] {
+  getPayloadTimelinessCommittee(slot: Slot): Uint32Array {
     const epoch = computeEpochAtSlot(slot);
 
     if (epoch < this.config.GLOAS_FORK_EPOCH) {
@@ -1030,7 +1035,11 @@ export class EpochCache {
     }
 
     if (epoch === this.epoch) {
-      return this.payloadTimelinessCommittee[slot % SLOTS_PER_EPOCH];
+      return this.payloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
+    }
+
+    if (epoch === this.epoch - 1 && this.previousPayloadTimelinessCommittees.length > 0) {
+      return this.previousPayloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
     }
 
     throw new Error(`Payload Timeliness Committee is not available for slot=${slot}`);
@@ -1099,7 +1108,6 @@ export function createEmptyEpochCacheImmutableData(
   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: [],
+    pubkeyCache: createPubkeyCache(),
   };
 }