@lodestar/state-transition 1.37.0-rc.0 → 1.38.0-dev.1ddbe5d870

package/src/cache/epochCache.ts

@@ -24,6 +24,7 @@ import {
   SyncPeriod,
   ValidatorIndex,
   electra,
+  gloas,
   phase0,
 } from "@lodestar/types";
 import {LodestarError} from "@lodestar/utils";
@@ -46,6 +47,7 @@ import {
   getSeed,
   isActiveValidator,
   isAggregatorFromCommitteeLength,
+  naiveGetPayloadTimlinessCommitteeIndices,
 } from "../util/index.js";
 import {computeBaseRewardPerIncrement, computeSyncParticipantReward} from "../util/syncCommittee.js";
 import {sumTargetUnslashedBalanceIncrements} from "../util/targetUnslashedBalance.js";
@@ -59,7 +61,7 @@ import {
   computeSyncCommitteeCache,
   getSyncCommitteeCache,
 } from "./syncCommitteeCache.js";
-import {BeaconStateAllForks, BeaconStateAltair} from "./types.js";
+import {BeaconStateAllForks, BeaconStateAltair, BeaconStateGloas} from "./types.js";
 
 /** `= PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT)` */
 export const PROPOSER_WEIGHT_FACTOR = PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT);
@@ -238,6 +240,10 @@ 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: Helper stats
   syncPeriod: SyncPeriod;
 
@@ -276,6 +282,7 @@ export class EpochCache {
     previousTargetUnslashedBalanceIncrements: number;
     currentSyncCommitteeIndexed: SyncCommitteeCache;
     nextSyncCommitteeIndexed: SyncCommitteeCache;
+    payloadTimelinessCommittee: ValidatorIndex[][];
     epoch: Epoch;
     syncPeriod: SyncPeriod;
   }) {
@@ -307,6 +314,7 @@ export class EpochCache {
     this.previousTargetUnslashedBalanceIncrements = data.previousTargetUnslashedBalanceIncrements;
     this.currentSyncCommitteeIndexed = data.currentSyncCommitteeIndexed;
     this.nextSyncCommitteeIndexed = data.nextSyncCommitteeIndexed;
+    this.payloadTimelinessCommittee = data.payloadTimelinessCommittee;
     this.epoch = data.epoch;
     this.syncPeriod = data.syncPeriod;
   }
@@ -485,6 +493,17 @@ export class EpochCache {
       nextSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
     }
 
+    // Compute PTC for this epoch
+    let payloadTimelinessCommittee: ValidatorIndex[][] = [];
+    if (currentEpoch >= config.GLOAS_FORK_EPOCH) {
+      payloadTimelinessCommittee = naiveGetPayloadTimlinessCommitteeIndices(
+        state as BeaconStateGloas,
+        currentShuffling,
+        effectiveBalanceIncrements,
+        currentEpoch
+      );
+    }
+
     // 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
@@ -559,6 +578,7 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed,
+      payloadTimelinessCommittee: payloadTimelinessCommittee,
       epoch: currentEpoch,
       syncPeriod: computeSyncPeriodAtEpoch(currentEpoch),
     });
@@ -605,6 +625,7 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements: this.currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed: this.currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed: this.nextSyncCommitteeIndexed,
+      payloadTimelinessCommittee: this.payloadTimelinessCommittee,
       epoch: this.epoch,
       syncPeriod: this.syncPeriod,
     });
@@ -750,6 +771,14 @@ export class EpochCache {
     const epochAfterUpcoming = upcomingEpoch + 1;
 
     this.proposersPrevEpoch = this.proposers;
+    if (upcomingEpoch >= this.config.GLOAS_FORK_EPOCH) {
+      this.payloadTimelinessCommittee = naiveGetPayloadTimlinessCommitteeIndices(
+        state as BeaconStateGloas,
+        this.currentShuffling,
+        this.effectiveBalanceIncrements,
+        upcomingEpoch
+      );
+    }
     if (upcomingEpoch >= this.config.FULU_FORK_EPOCH) {
       // Populate proposer cache with lookahead from state
       const proposerLookahead = (state as CachedBeaconStateFulu).proposerLookahead.getAll();
@@ -1151,6 +1180,34 @@ export class EpochCache {
   isPostElectra(): boolean {
     return this.epoch >= this.config.ELECTRA_FORK_EPOCH;
   }
+
+  getPayloadTimelinessCommittee(slot: Slot): ValidatorIndex[] {
+    const epoch = computeEpochAtSlot(slot);
+
+    if (epoch < this.config.GLOAS_FORK_EPOCH) {
+      throw new Error("Payload Timeliness Committee is not available before gloas fork");
+    }
+
+    if (epoch === this.epoch) {
+      return this.payloadTimelinessCommittee[slot % SLOTS_PER_EPOCH];
+    }
+
+    throw new Error(`Payload Timeliness Committee is not available for slot=${slot}`);
+  }
+
+  getIndexedPayloadAttestation(
+    slot: Slot,
+    payloadAttestation: gloas.PayloadAttestation
+  ): gloas.IndexedPayloadAttestation {
+    const payloadTimelinessCommittee = this.getPayloadTimelinessCommittee(slot);
+    const attestingIndices = payloadAttestation.aggregationBits.intersectValues(payloadTimelinessCommittee);
+
+    return {
+      attestingIndices: attestingIndices.sort((a, b) => a - b),
+      data: payloadAttestation.data,
+      signature: payloadAttestation.signature,
+    };
+  }
 }
 
 function getEffectiveBalanceIncrementsByteLen(validatorCount: number): number {

package/src/epoch/index.ts

@@ -12,9 +12,11 @@ import {
   CachedBeaconStateCapella,
   CachedBeaconStateElectra,
   CachedBeaconStateFulu,
+  CachedBeaconStateGloas,
   CachedBeaconStatePhase0,
   EpochTransitionCache,
 } from "../types.js";
+import {processBuilderPendingPayments} from "./processBuilderPendingPayments.ts";
 import {processEffectiveBalanceUpdates} from "./processEffectiveBalanceUpdates.js";
 import {processEth1DataReset} from "./processEth1DataReset.js";
 import {processHistoricalRootsUpdate} from "./processHistoricalRootsUpdate.js";
@@ -53,6 +55,7 @@ export {
   processPendingDeposits,
   processPendingConsolidations,
   processProposerLookahead,
+  processBuilderPendingPayments,
 };
 
 export {computeUnrealizedCheckpoints} from "./computeUnrealizedCheckpoints.js";
@@ -78,6 +81,7 @@ export enum EpochTransitionStep {
   processPendingDeposits = "processPendingDeposits",
   processPendingConsolidations = "processPendingConsolidations",
   processProposerLookahead = "processProposerLookahead",
+  processBuilderPendingPayments = "processBuilderPendingPayments",
 }
 
 export function processEpoch(
@@ -154,6 +158,14 @@ export function processEpoch(
     }
   }
 
+  if (fork >= ForkSeq.gloas) {
+    const timer = metrics?.epochTransitionStepTime.startTimer({
+      step: EpochTransitionStep.processBuilderPendingPayments,
+    });
+    processBuilderPendingPayments(state as CachedBeaconStateGloas);
+    timer?.();
+  }
+
   {
     const timer = metrics?.epochTransitionStepTime.startTimer({
       step: EpochTransitionStep.processEffectiveBalanceUpdates,

package/src/epoch/processBuilderPendingPayments.ts

@@ -0,0 +1,31 @@
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {computeExitEpochAndUpdateChurn} from "../util/epoch.ts";
+import {getBuilderPaymentQuorumThreshold} from "../util/gloas.ts";
+
+/**
+ * Processes the builder pending payments from the previous epoch.
+ */
+export function processBuilderPendingPayments(state: CachedBeaconStateGloas): void {
+  const quorum = getBuilderPaymentQuorumThreshold(state);
+
+  for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
+    const payment = state.builderPendingPayments.get(i);
+    if (payment.weight > quorum) {
+      const exitQueueEpoch = computeExitEpochAndUpdateChurn(state, BigInt(payment.withdrawal.amount));
+      payment.withdrawal.withdrawableEpoch = exitQueueEpoch + state.config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY;
+
+      state.builderPendingWithdrawals.push(payment.withdrawal);
+    }
+  }
+
+  // TODO GLOAS: Optimize this
+  for (let i = 0; i < state.builderPendingPayments.length; i++) {
+    if (i < SLOTS_PER_EPOCH) {
+      state.builderPendingPayments.set(i, state.builderPendingPayments.get(i + SLOTS_PER_EPOCH).clone());
+    } else {
+      state.builderPendingPayments.set(i, ssz.gloas.BuilderPendingPayment.defaultViewDU());
+    }
+  }
+}

package/src/index.ts

@@ -52,6 +52,7 @@ export type {
   BeaconStateElectra,
   BeaconStateExecutions,
   BeaconStateFulu,
+  BeaconStateGloas,
   // Non-cached states
   BeaconStatePhase0,
   CachedBeaconStateAllForks,
@@ -62,6 +63,7 @@ export type {
   CachedBeaconStateElectra,
   CachedBeaconStateExecutions,
   CachedBeaconStateFulu,
+  CachedBeaconStateGloas,
   CachedBeaconStatePhase0,
 } from "./types.js";
 export * from "./util/index.js";

package/src/signatureSets/attesterSlashings.ts

@@ -1,29 +1,33 @@
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
 import {AttesterSlashing, IndexedAttestationBigint, SignedBeaconBlock, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot, computeStartSlotAtEpoch} from "../util/index.js";
 
 /** Get signature sets from all AttesterSlashing objects in a block */
 export function getAttesterSlashingsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   return signedBlock.message.body.attesterSlashings.flatMap((attesterSlashing) =>
-    getAttesterSlashingSignatureSets(state, attesterSlashing)
+    getAttesterSlashingSignatureSets(index2pubkey, state, attesterSlashing)
   );
 }
 
 /** Get signature sets from a single AttesterSlashing object */
 export function getAttesterSlashingSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   attesterSlashing: AttesterSlashing
 ): ISignatureSet[] {
   return [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
-    getIndexedAttestationBigintSignatureSet(state, attestation)
+    getIndexedAttestationBigintSignatureSet(index2pubkey, state, attestation)
   );
 }
 
 export function getIndexedAttestationBigintSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   indexedAttestation: IndexedAttestationBigint
 ): ISignatureSet {
@@ -32,7 +36,7 @@ export function getIndexedAttestationBigintSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: indexedAttestation.attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
+    pubkeys: indexedAttestation.attestingIndices.map((i) => index2pubkey[i]),
     signingRoot: computeSigningRoot(ssz.phase0.AttestationDataBigint, indexedAttestation.data, domain),
     signature: indexedAttestation.signature,
   };

package/src/signatureSets/index.ts

@@ -1,6 +1,7 @@
 import {ForkSeq} from "@lodestar/params";
-import {SignedBeaconBlock, altair, capella} from "@lodestar/types";
+import {IndexedAttestation, SignedBeaconBlock, altair, capella} from "@lodestar/types";
 import {getSyncCommitteeSignatureSet} from "../block/processSyncCommittee.js";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
 import {ISignatureSet} from "../util/index.js";
 import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
@@ -14,6 +15,7 @@ import {getVoluntaryExitsSignatureSets} from "./voluntaryExits.js";
 export * from "./attesterSlashings.js";
 export * from "./blsToExecutionChange.js";
 export * from "./indexedAttestation.js";
+export * from "./indexedPayloadAttestation.js";
 export * from "./proposer.js";
 export * from "./proposerSlashings.js";
 export * from "./randao.js";
@@ -24,8 +26,10 @@ export * from "./voluntaryExits.js";
  * Deposits are not included because they can legally have invalid signatures.
  */
 export function getBlockSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock,
+  indexedAttestations: IndexedAttestation[],
   opts?: {
     /** Useful since block proposer signature is verified beforehand on gossip validation */
     skipProposerSignature?: boolean;
@@ -35,20 +39,21 @@ export function getBlockSignatureSets(
   const fork = state.config.getForkSeq(signedBlock.message.slot);
 
   const signatureSets = [
-    getRandaoRevealSignatureSet(state, signedBlock.message),
-    ...getProposerSlashingsSignatureSets(state, signedBlock),
-    ...getAttesterSlashingsSignatureSets(state, signedBlock),
-    ...getAttestationsSignatureSets(state, signedBlock),
-    ...getVoluntaryExitsSignatureSets(state, signedBlock),
+    getRandaoRevealSignatureSet(index2pubkey, state, signedBlock.message),
+    ...getProposerSlashingsSignatureSets(index2pubkey, state, signedBlock),
+    ...getAttesterSlashingsSignatureSets(index2pubkey, state, signedBlock),
+    ...getAttestationsSignatureSets(index2pubkey, state, signedBlock, indexedAttestations),
+    ...getVoluntaryExitsSignatureSets(index2pubkey, state, signedBlock),
   ];
 
   if (!opts?.skipProposerSignature) {
-    signatureSets.push(getBlockProposerSignatureSet(state, signedBlock));
+    signatureSets.push(getBlockProposerSignatureSet(index2pubkey, state, signedBlock));
   }
 
   // Only after altair fork, validate tSyncCommitteeSignature
   if (fork >= ForkSeq.altair) {
     const syncCommitteeSignatureSet = getSyncCommitteeSignatureSet(
+      index2pubkey,
       state as CachedBeaconStateAltair,
       (signedBlock as altair.SignedBeaconBlock).message
     );

package/src/signatureSets/indexedAttestation.ts

@@ -1,5 +1,6 @@
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
@@ -19,33 +20,43 @@ export function getAttestationDataSigningRoot(
 }
 
 export function getAttestationWithIndicesSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   attestation: Pick<phase0.Attestation, "data" | "signature">,
   attestingIndices: number[]
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
-    attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
+    attestingIndices.map((i) => index2pubkey[i]),
     getAttestationDataSigningRoot(state, attestation.data),
     attestation.signature
   );
 }
 
 export function getIndexedAttestationSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   indexedAttestation: IndexedAttestation
 ): ISignatureSet {
-  return getAttestationWithIndicesSignatureSet(state, indexedAttestation, indexedAttestation.attestingIndices);
+  return getAttestationWithIndicesSignatureSet(
+    index2pubkey,
+    state,
+    indexedAttestation,
+    indexedAttestation.attestingIndices
+  );
 }
 
 export function getAttestationsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
-  signedBlock: SignedBeaconBlock
+  signedBlock: SignedBeaconBlock,
+  indexedAttestations: IndexedAttestation[]
 ): ISignatureSet[] {
-  // TODO: figure how to get attesting indices of an attestation once per block processing
-  return signedBlock.message.body.attestations.map((attestation) =>
-    getIndexedAttestationSignatureSet(
-      state,
-      state.epochCtx.getIndexedAttestation(state.config.getForkSeq(signedBlock.message.slot), attestation)
-    )
+  if (indexedAttestations.length !== signedBlock.message.body.attestations.length) {
+    throw Error(
+      `Indexed attestations length mismatch: got ${indexedAttestations.length}, expected ${signedBlock.message.body.attestations.length}`
+    );
+  }
+  return indexedAttestations.map((indexedAttestation) =>
+    getIndexedAttestationSignatureSet(index2pubkey, state, indexedAttestation)
   );
 }

package/src/signatureSets/indexedPayloadAttestation.ts

@@ -0,0 +1,24 @@
+import {DOMAIN_PTC_ATTESTER} from "@lodestar/params";
+import {gloas, ssz} from "@lodestar/types";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {ISignatureSet, computeSigningRoot, createAggregateSignatureSetFromComponents} from "../util/index.ts";
+
+export function getIndexedPayloadAttestationSignatureSet(
+  state: CachedBeaconStateGloas,
+  indexedPayloadAttestation: gloas.IndexedPayloadAttestation
+): ISignatureSet {
+  return createAggregateSignatureSetFromComponents(
+    indexedPayloadAttestation.attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
+    getPayloadAttestationDataSigningRoot(state, indexedPayloadAttestation.data),
+    indexedPayloadAttestation.signature
+  );
+}
+
+export function getPayloadAttestationDataSigningRoot(
+  state: CachedBeaconStateGloas,
+  data: gloas.PayloadAttestationData
+): Uint8Array {
+  const domain = state.config.getDomain(state.slot, DOMAIN_PTC_ATTESTER);
+
+  return computeSigningRoot(ssz.gloas.PayloadAttestationData, data, domain);
+}

package/src/signatureSets/proposer.ts

@@ -1,22 +1,25 @@
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, SignedBlindedBeaconBlock, Slot, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {computeSigningRoot} from "../util/index.js";
 import {ISignatureSet, SignatureSetType, verifySignatureSet} from "../util/signatureSets.js";
 
 export function verifyProposerSignature(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
-  const signatureSet = getBlockProposerSignatureSet(state, signedBlock);
+  const signatureSet = getBlockProposerSignatureSet(index2pubkey, state, signedBlock);
   return verifySignatureSet(signatureSet);
 }
 
 export function getBlockProposerSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): ISignatureSet {
-  const {config, epochCtx} = state;
+  const {config} = state;
   const domain = config.getDomain(state.slot, DOMAIN_BEACON_PROPOSER, signedBlock.message.slot);
 
   const blockType = isBlindedBeaconBlock(signedBlock.message)
@@ -25,37 +28,40 @@ export function getBlockProposerSignatureSet(
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedBlock.message.proposerIndex],
+    pubkey: index2pubkey[signedBlock.message.proposerIndex],
     signingRoot: computeSigningRoot(blockType, signedBlock.message, domain),
     signature: signedBlock.signature,
   };
 }
 
 export function getBlockHeaderProposerSignatureSetByParentStateSlot(
+  index2pubkey: Index2PubkeyCache,
   parentState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(parentState, signedBlockHeader, parentState.slot);
+  return getBlockHeaderProposerSignatureSet(index2pubkey, parentState, signedBlockHeader, parentState.slot);
 }
 
 export function getBlockHeaderProposerSignatureSetByHeaderSlot(
+  index2pubkey: Index2PubkeyCache,
   headState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(headState, signedBlockHeader, signedBlockHeader.message.slot);
+  return getBlockHeaderProposerSignatureSet(index2pubkey, headState, signedBlockHeader, signedBlockHeader.message.slot);
 }
 
 function getBlockHeaderProposerSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader,
   domainSlot: Slot
 ): ISignatureSet {
-  const {config, epochCtx} = state;
+  const {config} = state;
   const domain = config.getDomain(domainSlot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedBlockHeader.message.proposerIndex],
+    pubkey: index2pubkey[signedBlockHeader.message.proposerIndex],
     signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeader, signedBlockHeader.message, domain),
     signature: signedBlockHeader.signature,
   };

package/src/signatureSets/proposerSlashings.ts

@@ -1,5 +1,6 @@
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index.js";
 
@@ -7,11 +8,11 @@ import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index
  * Extract signatures to allow validating all block signatures at once
  */
 export function getProposerSlashingSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   proposerSlashing: phase0.ProposerSlashing
 ): ISignatureSet[] {
-  const {epochCtx} = state;
-  const pubkey = epochCtx.index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
+  const pubkey = index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
 
   // In state transition, ProposerSlashing headers are only partially validated. Their slot could be higher than the
   // clock and the slashing would still be valid. Must use bigint variants to hash correctly to all possible values
@@ -32,10 +33,11 @@ export function getProposerSlashingSignatureSets(
 }
 
 export function getProposerSlashingsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   return signedBlock.message.body.proposerSlashings.flatMap((proposerSlashing) =>
-    getProposerSlashingSignatureSets(state, proposerSlashing)
+    getProposerSlashingSignatureSets(index2pubkey, state, proposerSlashing)
   );
 }

package/src/signatureSets/randao.ts

@@ -1,5 +1,6 @@
 import {DOMAIN_RANDAO} from "@lodestar/params";
 import {BeaconBlock, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
@@ -9,22 +10,29 @@ import {
   verifySignatureSet,
 } from "../util/index.js";
 
-export function verifyRandaoSignature(state: CachedBeaconStateAllForks, block: BeaconBlock): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(state, block));
+export function verifyRandaoSignature(
+  index2pubkey: Index2PubkeyCache,
+  state: CachedBeaconStateAllForks,
+  block: BeaconBlock
+): boolean {
+  return verifySignatureSet(getRandaoRevealSignatureSet(index2pubkey, state, block));
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
-export function getRandaoRevealSignatureSet(state: CachedBeaconStateAllForks, block: BeaconBlock): ISignatureSet {
-  const {epochCtx} = state;
+export function getRandaoRevealSignatureSet(
+  index2pubkey: Index2PubkeyCache,
+  state: CachedBeaconStateAllForks,
+  block: BeaconBlock
+): ISignatureSet {
   // should not get epoch from epochCtx
   const epoch = computeEpochAtSlot(block.slot);
   const domain = state.config.getDomain(state.slot, DOMAIN_RANDAO, block.slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[block.proposerIndex],
+    pubkey: index2pubkey[block.proposerIndex],
     signingRoot: computeSigningRoot(ssz.Epoch, epoch, domain),
     signature: block.body.randaoReveal,
   };

package/src/signatureSets/voluntaryExits.ts

@@ -1,4 +1,5 @@
 import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
@@ -9,36 +10,38 @@ import {
 } from "../util/index.js";
 
 export function verifyVoluntaryExitSignature(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(state, signedVoluntaryExit));
+  return verifySignatureSet(getVoluntaryExitSignatureSet(index2pubkey, state, signedVoluntaryExit));
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
 export function getVoluntaryExitSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
-  const {epochCtx} = state;
   const slot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
   const domain = state.config.getDomainForVoluntaryExit(state.slot, slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedVoluntaryExit.message.validatorIndex],
+    pubkey: index2pubkey[signedVoluntaryExit.message.validatorIndex],
     signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
     signature: signedVoluntaryExit.signature,
   };
 }
 
 export function getVoluntaryExitsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(state, voluntaryExit)
+    getVoluntaryExitSignatureSet(index2pubkey, state, voluntaryExit)
   );
 }

package/src/slot/index.ts

@@ -1,7 +1,7 @@
 import {byteArrayEquals} from "@chainsafe/ssz";
-import {SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {ForkSeq, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {ZERO_HASH} from "../constants/index.js";
-import {CachedBeaconStateAllForks} from "../types.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
 
 export {upgradeStateToAltair} from "./upgradeStateToAltair.js";
 export {upgradeStateToBellatrix} from "./upgradeStateToBellatrix.js";
@@ -14,7 +14,7 @@ export {upgradeStateToGloas} from "./upgradeStateToGloas.js";
 /**
  * Dial state to next slot. Common for all forks
  */
-export function processSlot(state: CachedBeaconStateAllForks): void {
+export function processSlot(fork: ForkSeq, state: CachedBeaconStateAllForks): void {
   // Cache state root
   // Note: .hashTreeRoot() automatically commits() pending changes
   const previousStateRoot = state.hashTreeRoot();
@@ -29,4 +29,12 @@ export function processSlot(state: CachedBeaconStateAllForks): void {
   // Note: .hashTreeRoot() automatically commits() pending changes
   const previousBlockRoot = state.latestBlockHeader.hashTreeRoot();
   state.blockRoots.set(state.slot % SLOTS_PER_HISTORICAL_ROOT, previousBlockRoot);
+
+  if (fork >= ForkSeq.gloas) {
+    // Unset the next payload availability
+    (state as CachedBeaconStateGloas).executionPayloadAvailability.set(
+      (state.slot + 1) % SLOTS_PER_HISTORICAL_ROOT,
+      false
+    );
+  }
 }

package/src/slot/upgradeStateToAltair.ts

@@ -135,7 +135,8 @@ function translateParticipation(
       data,
       attestation.inclusionDelay,
       epochCtx.epoch,
-      rootCache
+      rootCache,
+      null
     );
 
     const committeeIndices = epochCtx.getBeaconCommittee(data.slot, data.index);