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

package/src/block/processExecutionPayloadEnvelope.ts

@@ -0,0 +1,181 @@
+import {PublicKey, Signature, verify} from "@chainsafe/blst";
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {DOMAIN_BEACON_BUILDER, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {gloas, ssz} from "@lodestar/types";
+import {toHex, toRootHex} from "@lodestar/utils";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {computeExitEpochAndUpdateChurn, 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
+export function processExecutionPayloadEnvelope(
+  state: CachedBeaconStateGloas,
+  signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
+  verify: boolean
+): void {
+  const envelope = signedEnvelope.message;
+  const payload = envelope.payload;
+  const fork = state.config.getForkSeq(envelope.slot);
+
+  if (verify) {
+    const builderIndex = envelope.builderIndex;
+    const pubkey = state.validators.getReadonly(builderIndex).pubkey;
+
+    if (!verifyExecutionPayloadEnvelopeSignature(state, pubkey, signedEnvelope)) {
+      throw new Error("Payload Envelope has invalid signature");
+    }
+  }
+
+  validateExecutionPayloadEnvelope(state, envelope);
+
+  const requests = envelope.executionRequests;
+
+  for (const deposit of requests.deposits) {
+    processDepositRequest(state, deposit);
+  }
+
+  for (const withdrawal of requests.withdrawals) {
+    processWithdrawalRequest(fork, state, withdrawal);
+  }
+
+  for (const consolidation of requests.consolidations) {
+    processConsolidationRequest(fork, state, consolidation);
+  }
+
+  // Queue the builder payment
+  const paymentIndex = SLOTS_PER_EPOCH + (state.slot % SLOTS_PER_EPOCH);
+  const payment = state.builderPendingPayments.get(paymentIndex).clone();
+  const amount = payment.withdrawal.amount;
+
+  if (amount > 0) {
+    const exitQueueEpoch = computeExitEpochAndUpdateChurn(state, BigInt(amount));
+
+    payment.withdrawal.withdrawableEpoch = exitQueueEpoch + state.config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY;
+    state.builderPendingWithdrawals.push(payment.withdrawal);
+  }
+
+  state.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;
+
+  if (verify && !byteArrayEquals(envelope.stateRoot, state.hashTreeRoot())) {
+    throw new Error(
+      `Envelope's state root does not match state envelope=${toRootHex(envelope.stateRoot)} state=${toRootHex(state.hashTreeRoot())}`
+    );
+  }
+}
+
+function validateExecutionPayloadEnvelope(
+  state: CachedBeaconStateGloas,
+  envelope: gloas.ExecutionPayloadEnvelope
+): void {
+  const payload = envelope.payload;
+
+  if (byteArrayEquals(state.latestBlockHeader.stateRoot, ssz.Root.defaultValue())) {
+    const previousStateRoot = state.hashTreeRoot();
+    state.latestBlockHeader.stateRoot = previousStateRoot;
+  }
+
+  // Verify consistency with the beacon block
+  if (!byteArrayEquals(envelope.beaconBlockRoot, state.latestBlockHeader.hashTreeRoot())) {
+    throw new Error(
+      `Envelope's block is not the latest block header envelope=${toRootHex(envelope.beaconBlockRoot)} latestBlockHeader=${toRootHex(state.latestBlockHeader.hashTreeRoot())}`
+    );
+  }
+
+  // Verify consistency with the beacon block
+  if (envelope.slot !== state.slot) {
+    throw new Error(`Slot mismatch between envelope and state envelope=${envelope.slot} state=${state.slot}`);
+  }
+
+  const committedBid = state.latestExecutionPayloadBid;
+  // Verify consistency with the committed bid
+  if (envelope.builderIndex !== committedBid.builderIndex) {
+    throw new Error(
+      `Builder index mismatch between envelope and committed bid envelope=${envelope.builderIndex} committedBid=${committedBid.builderIndex}`
+    );
+  }
+
+  // Verify consistency with the committed bid
+  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)}`
+    );
+  }
+
+  // Verify the withdrawals root
+  const envelopeWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(envelope.payload.withdrawals);
+  if (!byteArrayEquals(state.latestWithdrawalsRoot, envelopeWithdrawalsRoot)) {
+    throw new Error(
+      `Withdrawals root mismatch between envelope and latest withdrawals root envelope=${toRootHex(envelopeWithdrawalsRoot)} latestWithdrawalRoot=${toRootHex(state.latestWithdrawalsRoot)}`
+    );
+  }
+
+  // Verify the gas_limit
+  if (Number(committedBid.gasLimit) !== payload.gasLimit) {
+    throw new Error(
+      `Gas limit mismatch between envelope's payload and committed bid envelope=${payload.gasLimit} committedBid=${Number(committedBid.gasLimit)}`
+    );
+  }
+
+  // Verify the block hash
+  if (!byteArrayEquals(committedBid.blockHash, payload.blockHash)) {
+    throw new Error(
+      `Block hash mismatch between envelope's payload and committed bid envelope=${toRootHex(payload.blockHash)} committedBid=${toRootHex(committedBid.blockHash)}`
+    );
+  }
+
+  // Verify consistency of the parent hash with respect to the previous execution payload
+  if (!byteArrayEquals(payload.parentHash, state.latestBlockHash)) {
+    throw new Error(
+      `Parent hash mismatch between envelope's payload and state envelope=${toRootHex(payload.parentHash)} state=${toRootHex(state.latestBlockHash)}`
+    );
+  }
+
+  // Verify prev_randao matches committed bid
+  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)}`
+    );
+  }
+
+  // Verify timestamp
+  if (payload.timestamp !== computeTimeAtSlot(state.config, state.slot, state.genesisTime)) {
+    throw new Error(
+      `Timestamp mismatch between envelope's payload and state envelope=${payload.timestamp} state=${computeTimeAtSlot(state.config, state.slot, state.genesisTime)}`
+    );
+  }
+
+  // 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
+}
+
+function verifyExecutionPayloadEnvelopeSignature(
+  state: CachedBeaconStateGloas,
+  pubkey: Uint8Array,
+  signedEnvelope: gloas.SignedExecutionPayloadEnvelope
+): boolean {
+  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_BUILDER);
+  const signingRoot = computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, signedEnvelope.message, domain);
+
+  try {
+    const publicKey = PublicKey.fromBytes(pubkey);
+    const signature = Signature.fromBytes(signedEnvelope.signature, true);
+
+    return verify(signingRoot, publicKey, signature);
+  } catch (_e) {
+    return false; // Catch all BLS errors: failed key validation, failed signature validation, invalid signature
+  }
+}

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);
 }
 
@@ -56,7 +77,7 @@ export function assertValidProposerSlashing(
 
   // verify signatures
   if (verifySignatures) {
-    const signatureSets = getProposerSlashingSignatureSets(state, proposerSlashing);
+    const signatureSets = getProposerSlashingSignatureSets(state.epochCtx.index2pubkey, state, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
       if (!verifySignatureSet(signatureSets[i])) {
         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(state, block)) {
+  if (verifySignature && !verifyRandaoSignature(epochCtx.index2pubkey, state, block)) {
     throw new Error("RANDAO reveal is an invalid signature");
   }
 

package/src/block/processSyncCommittee.ts

@@ -1,6 +1,7 @@
 import {byteArrayEquals} from "@chainsafe/ssz";
 import {DOMAIN_SYNC_COMMITTEE, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {altair, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {G2_POINT_AT_INFINITY} from "../constants/index.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
@@ -23,7 +24,7 @@ export function processSyncAggregate(
   if (verifySignatures) {
     // This is to conform to the spec - we want the signature to be verified
     const participantIndices = block.body.syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
-    const signatureSet = getSyncCommitteeSignatureSet(state, block, participantIndices);
+    const signatureSet = getSyncCommitteeSignatureSet(state.epochCtx.index2pubkey, state, block, participantIndices);
     // When there's no participation we consider the signature valid and just ignore i
     if (signatureSet !== null && !verifySignatureSet(signatureSet)) {
       throw Error("Sync committee signature invalid");
@@ -63,12 +64,12 @@ export function processSyncAggregate(
 }
 
 export function getSyncCommitteeSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   block: altair.BeaconBlock,
   /** Optional parameter to prevent computing it twice */
   participantIndices?: number[]
 ): ISignatureSet | null {
-  const {epochCtx} = state;
   const {syncAggregate} = block.body;
   const signature = syncAggregate.syncCommitteeSignature;
 
@@ -110,7 +111,7 @@ export function getSyncCommitteeSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: participantIndices.map((i) => epochCtx.index2pubkey[i]),
+    pubkeys: participantIndices.map((i) => index2pubkey[i]),
     signingRoot: computeSigningRoot(ssz.Root, rootSigned, domain),
     signature,
   };

package/src/block/processVoluntaryExit.ts

@@ -69,12 +69,12 @@ 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;
   }
 
-  if (verifySignature && !verifyVoluntaryExitSignature(state, signedVoluntaryExit)) {
+  if (verifySignature && !verifyVoluntaryExitSignature(epochCtx.index2pubkey, state, signedVoluntaryExit)) {
     return VoluntaryExitValidity.invalidSignature;
   }
 

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};
 }