@lodestar/state-transition 1.38.0-dev.548d7aa41e → 1.38.0-dev.688d5584ea

package/src/block/processOperations.ts

@@ -1,7 +1,12 @@
 import {ForkSeq} from "@lodestar/params";
-import {BeaconBlockBody, capella, electra} from "@lodestar/types";
+import {BeaconBlockBody, capella, electra, gloas} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateCapella, CachedBeaconStateElectra} from "../types.js";
+import {
+  CachedBeaconStateAllForks,
+  CachedBeaconStateCapella,
+  CachedBeaconStateElectra,
+  CachedBeaconStateGloas,
+} from "../types.js";
 import {getEth1DepositCount} from "../util/deposit.js";
 import {processAttestations} from "./processAttestations.js";
 import {processAttesterSlashing} from "./processAttesterSlashing.js";
@@ -9,6 +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 {processProposerSlashing} from "./processProposerSlashing.js";
 import {processVoluntaryExit} from "./processVoluntaryExit.js";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
@@ -64,7 +70,7 @@ export function processOperations(
     }
   }
 
-  if (fork >= ForkSeq.electra) {
+  if (fork >= ForkSeq.electra && fork < ForkSeq.gloas) {
     const stateElectra = state as CachedBeaconStateElectra;
     const bodyElectra = body as electra.BeaconBlockBody;
 
@@ -77,7 +83,13 @@ export function processOperations(
     }
 
     for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
-      processConsolidationRequest(stateElectra, elConsolidationRequest);
+      processConsolidationRequest(fork, stateElectra, elConsolidationRequest);
+    }
+  }
+
+  if (fork >= ForkSeq.gloas) {
+    for (const payloadAttestation of (body as gloas.BeaconBlockBody).payloadAttestations) {
+      processPayloadAttestation(state as CachedBeaconStateGloas, payloadAttestation);
     }
   }
 }

package/src/block/processPayloadAttestation.ts

@@ -0,0 +1,25 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {gloas} from "@lodestar/types";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.ts";
+
+export function processPayloadAttestation(
+  state: CachedBeaconStateGloas,
+  payloadAttestation: gloas.PayloadAttestation
+): void {
+  const data = payloadAttestation.data;
+
+  if (!byteArrayEquals(data.beaconBlockRoot, state.latestBlockHeader.parentRoot)) {
+    throw Error("Payload attestation is referring to the wrong block");
+  }
+
+  if (data.slot + 1 !== state.slot) {
+    throw Error("Payload attestation is not from previous slot");
+  }
+
+  const indexedPayloadAttestation = state.epochCtx.getIndexedPayloadAttestation(data.slot, payloadAttestation);
+
+  if (!isValidIndexedPayloadAttestation(state, indexedPayloadAttestation, true)) {
+    throw Error("Invalid payload attestation");
+  }
+}

package/src/block/processProposerSlashing.ts

@@ -1,8 +1,8 @@
-import {ForkSeq} from "@lodestar/params";
+import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {phase0, ssz} from "@lodestar/types";
 import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
-import {CachedBeaconStateAllForks} from "../types.js";
-import {isSlashableValidator} from "../util/index.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
+import {computeEpochAtSlot, isSlashableValidator} from "../util/index.js";
 import {verifySignatureSet} from "../util/signatureSets.js";
 import {slashValidator} from "./slashValidator.js";
 
@@ -20,6 +20,27 @@ export function processProposerSlashing(
 ): void {
   assertValidProposerSlashing(state, proposerSlashing, verifySignatures);
 
+  if (fork >= ForkSeq.gloas) {
+    const slot = Number(proposerSlashing.signedHeader1.message.slot);
+    const proposalEpoch = computeEpochAtSlot(slot);
+    const currentEpoch = state.epochCtx.epoch;
+    const previousEpoch = currentEpoch - 1;
+
+    const paymentIndex =
+      proposalEpoch === currentEpoch
+        ? SLOTS_PER_EPOCH + (slot % SLOTS_PER_EPOCH)
+        : proposalEpoch === previousEpoch
+          ? slot % SLOTS_PER_EPOCH
+          : undefined;
+
+    if (paymentIndex !== undefined) {
+      (state as CachedBeaconStateGloas).builderPendingPayments.set(
+        paymentIndex,
+        ssz.gloas.BuilderPendingPayment.defaultViewDU()
+      );
+    }
+  }
+
   slashValidator(fork, state, proposerSlashing.signedHeader1.message.proposerIndex);
 }
 

package/src/block/processVoluntaryExit.ts

@@ -69,7 +69,7 @@ export function getVoluntaryExitValidity(
   // only exit validator if it has no pending withdrawals in the queue
   if (
     fork >= ForkSeq.electra &&
-    getPendingBalanceToWithdraw(state as CachedBeaconStateElectra, voluntaryExit.validatorIndex) !== 0
+    getPendingBalanceToWithdraw(fork, state as CachedBeaconStateElectra, voluntaryExit.validatorIndex) !== 0
   ) {
     return VoluntaryExitValidity.pendingWithdrawals;
   }

package/src/block/processWithdrawalRequest.ts

@@ -7,7 +7,7 @@ import {
 } from "@lodestar/params";
 import {electra, phase0, ssz} from "@lodestar/types";
 import {toHex} from "@lodestar/utils";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasCompoundingWithdrawalCredential, hasExecutionWithdrawalCredential} from "../util/electra.js";
 import {computeExitEpochAndUpdateChurn} from "../util/epoch.js";
 import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/validator.js";
@@ -15,7 +15,7 @@ import {initiateValidatorExit} from "./initiateValidatorExit.js";
 
 export function processWithdrawalRequest(
   fork: ForkSeq,
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   withdrawalRequest: electra.WithdrawalRequest
 ): void {
   const amount = Number(withdrawalRequest.amount);
@@ -42,7 +42,7 @@ export function processWithdrawalRequest(
   }
 
   // TODO Electra: Consider caching pendingPartialWithdrawals
-  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(state, validatorIndex);
+  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(fork, state, validatorIndex);
   const validatorBalance = state.balances.get(validatorIndex);
 
   if (isFullExitRequest) {
@@ -81,7 +81,7 @@ export function processWithdrawalRequest(
 function isValidatorEligibleForWithdrawOrExit(
   validator: phase0.Validator,
   sourceAddress: Uint8Array,
-  state: CachedBeaconStateElectra
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas
 ): boolean {
   const {withdrawalCredentials} = validator;
   const addressStr = toHex(withdrawalCredentials.subarray(12));

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/index.ts

@@ -1,5 +1,5 @@
 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 {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
 import {ISignatureSet} from "../util/index.js";
@@ -14,6 +14,7 @@ import {getVoluntaryExitsSignatureSets} from "./voluntaryExits.js";
 export * from "./attesterSlashings.js";
 export * from "./blsToExecutionChange.js";
 export * from "./indexedAttestation.js";
+export * from "./indexedPayloadAttestation.ts";
 export * from "./proposer.js";
 export * from "./proposerSlashings.js";
 export * from "./randao.js";
@@ -26,6 +27,7 @@ export * from "./voluntaryExits.js";
 export function getBlockSignatureSets(
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock,
+  indexedAttestations: IndexedAttestation[],
   opts?: {
     /** Useful since block proposer signature is verified beforehand on gossip validation */
     skipProposerSignature?: boolean;
@@ -38,7 +40,7 @@ export function getBlockSignatureSets(
     getRandaoRevealSignatureSet(state, signedBlock.message),
     ...getProposerSlashingsSignatureSets(state, signedBlock),
     ...getAttesterSlashingsSignatureSets(state, signedBlock),
-    ...getAttestationsSignatureSets(state, signedBlock),
+    ...getAttestationsSignatureSets(state, signedBlock, indexedAttestations),
     ...getVoluntaryExitsSignatureSets(state, signedBlock),
   ];
 

package/src/signatureSets/indexedAttestation.ts

@@ -39,13 +39,13 @@ export function getIndexedAttestationSignatureSet(
 
 export function getAttestationsSignatureSets(
   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(state, indexedAttestation));
 }