@lodestar/state-transition 1.38.0-dev.bc1fed4d3d → 1.38.0-dev.ebc352f211

package/src/block/processWithdrawals.ts

@@ -10,7 +10,8 @@ import {
 } from "@lodestar/params";
 import {ValidatorIndex, capella, ssz} from "@lodestar/types";
 import {MapDef, toRootHex} from "@lodestar/utils";
-import {CachedBeaconStateCapella, CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateCapella, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
+import {isBuilderPaymentWithdrawable, isParentBlockFull} from "../util/gloas.ts";
 import {
   decreaseBalance,
   getMaxEffectiveBalance,
@@ -21,31 +22,48 @@ import {
 
 export function processWithdrawals(
   fork: ForkSeq,
-  state: CachedBeaconStateCapella | CachedBeaconStateElectra,
-  payload: capella.FullOrBlindedExecutionPayload
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas,
+  payload?: capella.FullOrBlindedExecutionPayload
 ): void {
+  // Return early if the parent block is empty
+  if (fork >= ForkSeq.gloas && !isParentBlockFull(state as CachedBeaconStateGloas)) {
+    return;
+  }
+
   // processedPartialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
-  const {withdrawals: expectedWithdrawals, processedPartialWithdrawalsCount} = getExpectedWithdrawals(fork, state);
+  // processedBuilderWithdrawalsCount is withdrawals coming from builder payment since gloas (EIP-7732)
+  const {
+    withdrawals: expectedWithdrawals,
+    processedPartialWithdrawalsCount,
+    processedBuilderWithdrawalsCount,
+  } = getExpectedWithdrawals(fork, state);
   const numWithdrawals = expectedWithdrawals.length;
 
-  if (isCapellaPayloadHeader(payload)) {
-    const expectedWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(expectedWithdrawals);
-    const actualWithdrawalsRoot = payload.withdrawalsRoot;
-    if (!byteArrayEquals(expectedWithdrawalsRoot, actualWithdrawalsRoot)) {
-      throw Error(
-        `Invalid withdrawalsRoot of executionPayloadHeader, expected=${toRootHex(
-          expectedWithdrawalsRoot
-        )}, actual=${toRootHex(actualWithdrawalsRoot)}`
-      );
-    }
-  } else {
-    if (expectedWithdrawals.length !== payload.withdrawals.length) {
-      throw Error(`Invalid withdrawals length expected=${numWithdrawals} actual=${payload.withdrawals.length}`);
+  // After gloas, withdrawals are verified later in processExecutionPayloadEnvelope
+  if (fork < ForkSeq.gloas) {
+    if (payload === undefined) {
+      throw Error("payload is required for pre-gloas processWithdrawals");
     }
-    for (let i = 0; i < numWithdrawals; i++) {
-      const withdrawal = expectedWithdrawals[i];
-      if (!ssz.capella.Withdrawal.equals(withdrawal, payload.withdrawals[i])) {
-        throw Error(`Withdrawal mismatch at index=${i}`);
+
+    if (isCapellaPayloadHeader(payload)) {
+      const expectedWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(expectedWithdrawals);
+      const actualWithdrawalsRoot = payload.withdrawalsRoot;
+      if (!byteArrayEquals(expectedWithdrawalsRoot, actualWithdrawalsRoot)) {
+        throw Error(
+          `Invalid withdrawalsRoot of executionPayloadHeader, expected=${toRootHex(
+            expectedWithdrawalsRoot
+          )}, actual=${toRootHex(actualWithdrawalsRoot)}`
+        );
+      }
+    } else {
+      if (expectedWithdrawals.length !== payload.withdrawals.length) {
+        throw Error(`Invalid withdrawals length expected=${numWithdrawals} actual=${payload.withdrawals.length}`);
+      }
+      for (let i = 0; i < numWithdrawals; i++) {
+        const withdrawal = expectedWithdrawals[i];
+        if (!ssz.capella.Withdrawal.equals(withdrawal, payload.withdrawals[i])) {
+          throw Error(`Withdrawal mismatch at index=${i}`);
+        }
       }
     }
   }
@@ -62,6 +80,24 @@ export function processWithdrawals(
     );
   }
 
+  if (fork >= ForkSeq.gloas) {
+    const stateGloas = state as CachedBeaconStateGloas;
+    stateGloas.latestWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(expectedWithdrawals);
+
+    const unprocessedWithdrawals = stateGloas.builderPendingWithdrawals
+      .getAllReadonly()
+      .slice(0, processedBuilderWithdrawalsCount)
+      .filter((w) => !isBuilderPaymentWithdrawable(stateGloas, w));
+    const remainingWithdrawals = stateGloas.builderPendingWithdrawals
+      .sliceFrom(processedBuilderWithdrawalsCount)
+      .getAllReadonly();
+
+    stateGloas.builderPendingWithdrawals = ssz.gloas.BeaconState.fields.builderPendingWithdrawals.toViewDU([
+      ...unprocessedWithdrawals,
+      ...remainingWithdrawals,
+    ]);
+  }
+
   // Update the nextWithdrawalIndex
   const latestWithdrawal = expectedWithdrawals.at(-1);
   if (latestWithdrawal) {
@@ -82,11 +118,12 @@ export function processWithdrawals(
 
 export function getExpectedWithdrawals(
   fork: ForkSeq,
-  state: CachedBeaconStateCapella | CachedBeaconStateElectra
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas
 ): {
   withdrawals: capella.Withdrawal[];
   sampledValidators: number;
   processedPartialWithdrawalsCount: number;
+  processedBuilderWithdrawalsCount: number;
 } {
   if (fork < ForkSeq.capella) {
     throw new Error(`getExpectedWithdrawals not supported at forkSeq=${fork} < ForkSeq.capella`);
@@ -99,17 +136,71 @@ export function getExpectedWithdrawals(
   const withdrawals: capella.Withdrawal[] = [];
   const withdrawnBalances = new MapDef<ValidatorIndex, number>(() => 0);
   const isPostElectra = fork >= ForkSeq.electra;
+  const isPostGloas = fork >= ForkSeq.gloas;
   // partialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
   let processedPartialWithdrawalsCount = 0;
+  // builderWithdrawalsCount is withdrawals coming from builder payments since Gloas (EIP-7732)
+  let processedBuilderWithdrawalsCount = 0;
+
+  if (isPostGloas) {
+    const stateGloas = state as CachedBeaconStateGloas;
+
+    const allBuilderPendingWithdrawals =
+      stateGloas.builderPendingWithdrawals.length <= MAX_WITHDRAWALS_PER_PAYLOAD
+        ? stateGloas.builderPendingWithdrawals.getAllReadonly()
+        : null;
+
+    for (let i = 0; i < stateGloas.builderPendingWithdrawals.length; i++) {
+      const withdrawal = allBuilderPendingWithdrawals
+        ? allBuilderPendingWithdrawals[i]
+        : stateGloas.builderPendingWithdrawals.getReadonly(i);
+
+      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length + 1 === MAX_WITHDRAWALS_PER_PAYLOAD) {
+        break;
+      }
+
+      if (isBuilderPaymentWithdrawable(stateGloas, withdrawal)) {
+        const totalWithdrawn = withdrawnBalances.getOrDefault(withdrawal.builderIndex);
+        const balance = state.balances.get(withdrawal.builderIndex) - totalWithdrawn;
+        const builder = state.validators.get(withdrawal.builderIndex);
+
+        let withdrawableBalance = 0;
+
+        if (builder.slashed) {
+          withdrawableBalance = balance < withdrawal.amount ? balance : withdrawal.amount;
+        } else if (balance > MIN_ACTIVATION_BALANCE) {
+          withdrawableBalance =
+            balance - MIN_ACTIVATION_BALANCE < withdrawal.amount ? balance - MIN_ACTIVATION_BALANCE : withdrawal.amount;
+        }
+
+        if (withdrawableBalance > 0) {
+          withdrawals.push({
+            index: withdrawalIndex,
+            validatorIndex: withdrawal.builderIndex,
+            address: withdrawal.feeRecipient,
+            amount: BigInt(withdrawableBalance),
+          });
+          withdrawalIndex++;
+          withdrawnBalances.set(withdrawal.builderIndex, totalWithdrawn + withdrawableBalance);
+        }
+      }
+      processedBuilderWithdrawalsCount++;
+    }
+  }
 
   if (isPostElectra) {
+    // In pre-gloas, partialWithdrawalBound == MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP
+    const partialWithdrawalBound = Math.min(
+      withdrawals.length + MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
+      MAX_WITHDRAWALS_PER_PAYLOAD - 1
+    );
     const stateElectra = state as CachedBeaconStateElectra;
 
     // 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
     // also we may break early if withdrawableEpoch > epoch
     const allPendingPartialWithdrawals =
-      stateElectra.pendingPartialWithdrawals.length <= MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP
+      stateElectra.pendingPartialWithdrawals.length <= partialWithdrawalBound
         ? stateElectra.pendingPartialWithdrawals.getAllReadonly()
         : null;
 
@@ -118,7 +209,7 @@ export function getExpectedWithdrawals(
       const withdrawal = allPendingPartialWithdrawals
         ? allPendingPartialWithdrawals[i]
         : stateElectra.pendingPartialWithdrawals.getReadonly(i);
-      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length === MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP) {
+      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length === partialWithdrawalBound) {
         break;
       }
 
@@ -147,11 +238,11 @@ export function getExpectedWithdrawals(
     }
   }
 
-  const bound = Math.min(validators.length, MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP);
+  const withdrawalBound = Math.min(validators.length, MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP);
   let n = 0;
   // Just run a bounded loop max iterating over all withdrawals
   // however breaks out once we have MAX_WITHDRAWALS_PER_PAYLOAD
-  for (n = 0; n < bound; n++) {
+  for (n = 0; n < withdrawalBound; n++) {
     // Get next validator in turn
     const validatorIndex = (nextWithdrawalValidatorIndex + n) % validators.length;
 
@@ -203,5 +294,5 @@ export function getExpectedWithdrawals(
     }
   }
 
-  return {withdrawals, sampledValidators: n, processedPartialWithdrawalsCount};
+  return {withdrawals, sampledValidators: n, processedPartialWithdrawalsCount, processedBuilderWithdrawalsCount};
 }

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 {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,6 +26,7 @@ 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[],
@@ -36,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, indexedAttestations),
-    ...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,25 +20,33 @@ 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,
   indexedAttestations: IndexedAttestation[]
@@ -47,5 +56,7 @@ export function getAttestationsSignatureSets(
       `Indexed attestations length mismatch: got ${indexedAttestations.length}, expected ${signedBlock.message.body.attestations.length}`
     );
   }
-  return indexedAttestations.map((indexedAttestation) => getIndexedAttestationSignatureSet(state, indexedAttestation));
+  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);
+}