@lodestar/state-transition 1.37.0 → 1.38.0-dev.255e56fb68

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.37.0",
+  "version": "1.38.0-dev.255e56fb68",
   "type": "module",
   "exports": {
     ".": {
@@ -62,10 +62,10 @@
     "@chainsafe/pubkey-index-map": "^3.0.0",
     "@chainsafe/ssz": "^1.2.2",
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@lodestar/config": "^1.37.0",
-    "@lodestar/params": "^1.37.0",
-    "@lodestar/types": "^1.37.0",
-    "@lodestar/utils": "^1.37.0",
+    "@lodestar/config": "1.38.0-dev.255e56fb68",
+    "@lodestar/params": "1.38.0-dev.255e56fb68",
+    "@lodestar/types": "1.38.0-dev.255e56fb68",
+    "@lodestar/utils": "1.38.0-dev.255e56fb68",
     "bigint-buffer": "^1.1.5"
   },
   "keywords": [
@@ -74,5 +74,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "eaf5bc974a483104665b6ed57b1a15e2fd48f730"
+  "gitHead": "a6f5bc4398f508565cd5cf856c0d6946571d5465"
 }

package/src/block/index.ts

@@ -1,14 +1,22 @@
-import {ForkSeq} from "@lodestar/params";
+import {ForkPostGloas, ForkSeq} from "@lodestar/params";
 import {BeaconBlock, BlindedBeaconBlock, altair, capella} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateBellatrix, CachedBeaconStateCapella} from "../types.js";
+import {
+  CachedBeaconStateAllForks,
+  CachedBeaconStateBellatrix,
+  CachedBeaconStateCapella,
+  CachedBeaconStateGloas,
+} from "../types.js";
 import {getFullOrBlindedPayload, isExecutionEnabled} from "../util/execution.js";
 import {BlockExternalData, DataAvailabilityStatus} from "./externalData.js";
 import {processBlobKzgCommitments} from "./processBlobKzgCommitments.js";
 import {processBlockHeader} from "./processBlockHeader.js";
 import {processEth1Data} from "./processEth1Data.js";
 import {processExecutionPayload} from "./processExecutionPayload.js";
+import {processExecutionPayloadBid} from "./processExecutionPayloadBid.ts";
+import {processExecutionPayloadEnvelope} from "./processExecutionPayloadEnvelope.ts";
 import {processOperations} from "./processOperations.js";
+import {processPayloadAttestation} from "./processPayloadAttestation.ts";
 import {processRandao} from "./processRandao.js";
 import {processSyncAggregate} from "./processSyncCommittee.js";
 import {processWithdrawals} from "./processWithdrawals.js";
@@ -22,6 +30,9 @@ export {
   processEth1Data,
   processSyncAggregate,
   processWithdrawals,
+  processExecutionPayloadBid,
+  processPayloadAttestation,
+  processExecutionPayloadEnvelope,
 };
 
 export * from "./externalData.js";
@@ -41,23 +52,33 @@ export function processBlock(
 
   processBlockHeader(state, block);
 
-  // The call to the process_execution_payload must happen before the call to the process_randao as the former depends
-  // on the randao_mix computed with the reveal of the previous block.
-  if (fork >= ForkSeq.bellatrix && isExecutionEnabled(state as CachedBeaconStateBellatrix, block)) {
+  if (fork >= ForkSeq.gloas) {
+    // After gloas, processWithdrawals does not take a payload parameter
+    processWithdrawals(fork, state as CachedBeaconStateGloas);
+  } else if (fork >= ForkSeq.capella) {
     const fullOrBlindedPayload = getFullOrBlindedPayload(block);
-    // TODO Deneb: Allow to disable withdrawals for interop testing
-    // https://github.com/ethereum/consensus-specs/blob/b62c9e877990242d63aa17a2a59a49bc649a2f2e/specs/eip4844/beacon-chain.md#disabling-withdrawals
-    if (fork >= ForkSeq.capella) {
-      processWithdrawals(
-        fork,
-        state as CachedBeaconStateCapella,
-        fullOrBlindedPayload as capella.FullOrBlindedExecutionPayload
-      );
-    }
+    processWithdrawals(
+      fork,
+      state as CachedBeaconStateCapella,
+      fullOrBlindedPayload as capella.FullOrBlindedExecutionPayload
+    );
+  }
 
+  // The call to the process_execution_payload must happen before the call to the process_randao as the former depends
+  // on the randao_mix computed with the reveal of the previous block.
+  // TODO GLOAS: We call processExecutionPayload somewhere else post-gloas
+  if (
+    fork >= ForkSeq.bellatrix &&
+    fork < ForkSeq.gloas &&
+    isExecutionEnabled(state as CachedBeaconStateBellatrix, block)
+  ) {
     processExecutionPayload(fork, state as CachedBeaconStateBellatrix, block.body, externalData);
   }
 
+  if (fork >= ForkSeq.gloas) {
+    processExecutionPayloadBid(state as CachedBeaconStateGloas, block as BeaconBlock<ForkPostGloas>);
+  }
+
   processRandao(state, block, verifySignatures);
   processEth1Data(state, block.body.eth1Data);
   processOperations(fork, state, block.body, opts, metrics);

package/src/block/isValidIndexedPayloadAttestation.ts

@@ -0,0 +1,23 @@
+import {gloas} from "@lodestar/types";
+import {getIndexedPayloadAttestationSignatureSet} from "../signatureSets/index.ts";
+import {CachedBeaconStateGloas} from "../types.js";
+import {verifySignatureSet} from "../util/index.ts";
+
+export function isValidIndexedPayloadAttestation(
+  state: CachedBeaconStateGloas,
+  indexedPayloadAttestation: gloas.IndexedPayloadAttestation,
+  verifySignature: boolean
+): boolean {
+  const indices = indexedPayloadAttestation.attestingIndices;
+  const isSorted = indices.every((val, i, arr) => i === 0 || arr[i - 1] <= val);
+
+  if (indices.length === 0 || !isSorted) {
+    return false;
+  }
+
+  if (verifySignature) {
+    return verifySignatureSet(getIndexedPayloadAttestationSignatureSet(state, indexedPayloadAttestation));
+  }
+
+  return true;
+}

package/src/block/processAttestationPhase0.ts

@@ -86,7 +86,11 @@ export function validateAttestation(fork: ForkSeq, state: CachedBeaconStateAllFo
   }
 
   if (fork >= ForkSeq.electra) {
-    assert.equal(data.index, 0, `AttestationData.index must be zero: index=${data.index}`);
+    if (fork >= ForkSeq.gloas) {
+      assert.lt(data.index, 2, `AttestationData.index must be 0 or 1: index=${data.index}`);
+    } else {
+      assert.equal(data.index, 0, `AttestationData.index must be 0: index=${data.index}`);
+    }
     const attestationElectra = attestation as electra.Attestation;
     const committeeIndices = attestationElectra.committeeBits.getTrueBitIndexes();
 

package/src/block/processAttestationsAltair.ts

@@ -1,9 +1,11 @@
 import {byteArrayEquals} from "@chainsafe/ssz";
 import {
+  EFFECTIVE_BALANCE_INCREMENT,
   ForkSeq,
   MIN_ATTESTATION_INCLUSION_DELAY,
   PROPOSER_WEIGHT,
   SLOTS_PER_EPOCH,
+  SLOTS_PER_HISTORICAL_ROOT,
   TIMELY_HEAD_FLAG_INDEX,
   TIMELY_HEAD_WEIGHT,
   TIMELY_SOURCE_FLAG_INDEX,
@@ -16,7 +18,8 @@ import {Attestation, Epoch, phase0} from "@lodestar/types";
 import {intSqrt} from "@lodestar/utils";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {getAttestationWithIndicesSignatureSet} from "../signatureSets/indexedAttestation.js";
-import {CachedBeaconStateAltair} from "../types.js";
+import {CachedBeaconStateAltair, CachedBeaconStateGloas} from "../types.js";
+import {isAttestationSameSlot, isAttestationSameSlotRootCache} from "../util/gloas.ts";
 import {increaseBalance, verifySignatureSet} from "../util/index.js";
 import {RootCache} from "../util/rootCache.js";
 import {checkpointToStr, isTimelyTarget, validateAttestation} from "./processAttestationPhase0.js";
@@ -31,7 +34,7 @@ const SLOTS_PER_EPOCH_SQRT = intSqrt(SLOTS_PER_EPOCH);
 
 export function processAttestationsAltair(
   fork: ForkSeq,
-  state: CachedBeaconStateAltair,
+  state: CachedBeaconStateAltair | CachedBeaconStateGloas,
   attestations: Attestation[],
   verifySignature = true,
   metrics?: BeaconStateTransitionMetrics | null
@@ -46,6 +49,9 @@ export function processAttestationsAltair(
   let proposerReward = 0;
   let newSeenAttesters = 0;
   let newSeenAttestersEffectiveBalance = 0;
+
+  const builderWeightMap: Map<number, number> = new Map();
+
   for (const attestation of attestations) {
     const data = attestation.data;
 
@@ -66,13 +72,16 @@ export function processAttestationsAltair(
 
     const inCurrentEpoch = data.target.epoch === currentEpoch;
     const epochParticipation = inCurrentEpoch ? state.currentEpochParticipation : state.previousEpochParticipation;
+    // Count how much additional weight added to current or previous epoch's builder pending payment (in ETH increment)
+    let paymentWeightToAdd = 0;
 
     const flagsAttestation = getAttestationParticipationStatus(
       fork,
       data,
       stateSlot - data.slot,
       epochCtx.epoch,
-      rootCache
+      rootCache,
+      fork >= ForkSeq.gloas ? (state as CachedBeaconStateGloas).executionPayloadAvailability.toBoolArray() : null
     );
 
     // For each participant, update their participation
@@ -121,12 +130,35 @@ export function processAttestationsAltair(
           }
         }
       }
+
+      if (fork >= ForkSeq.gloas && flagsNewSet !== 0 && isAttestationSameSlot(state as CachedBeaconStateGloas, data)) {
+        paymentWeightToAdd += effectiveBalanceIncrements[validatorIndex];
+      }
     }
 
     // Do the discrete math inside the loop to ensure a deterministic result
     const totalIncrements = totalBalanceIncrementsWithWeight;
     const proposerRewardNumerator = totalIncrements * state.epochCtx.baseRewardPerIncrement;
     proposerReward += Math.floor(proposerRewardNumerator / PROPOSER_REWARD_DOMINATOR);
+
+    if (fork >= ForkSeq.gloas) {
+      const builderPendingPaymentIndex = inCurrentEpoch
+        ? SLOTS_PER_EPOCH + (data.slot % SLOTS_PER_EPOCH)
+        : data.slot % SLOTS_PER_EPOCH;
+
+      const existingWeight =
+        builderWeightMap.get(builderPendingPaymentIndex) ??
+        (state as CachedBeaconStateGloas).builderPendingPayments.get(builderPendingPaymentIndex).weight;
+      const updatedWeight = existingWeight + paymentWeightToAdd * EFFECTIVE_BALANCE_INCREMENT;
+      builderWeightMap.set(builderPendingPaymentIndex, updatedWeight);
+    }
+  }
+
+  for (const [index, weight] of builderWeightMap) {
+    const payment = (state as CachedBeaconStateGloas).builderPendingPayments.get(index);
+    if (payment.withdrawal.amount > 0) {
+      payment.weight = weight;
+    }
   }
 
   metrics?.newSeenAttestersPerBlock.set(newSeenAttesters);
@@ -145,7 +177,8 @@ export function getAttestationParticipationStatus(
   data: phase0.AttestationData,
   inclusionDelay: number,
   currentEpoch: Epoch,
-  rootCache: RootCache
+  rootCache: RootCache,
+  executionPayloadAvailability: boolean[] | null
 ): number {
   const justifiedCheckpoint =
     data.target.epoch === currentEpoch ? rootCache.currentJustifiedCheckpoint : rootCache.previousJustifiedCheckpoint;
@@ -168,9 +201,33 @@ export function getAttestationParticipationStatus(
   const isMatchingTarget = byteArrayEquals(data.target.root, rootCache.getBlockRoot(data.target.epoch));
 
   // a timely head is only be set if the target is _also_ matching
-  const isMatchingHead =
+  // In gloas, this is called `head_root_matches`
+  let isMatchingHead =
     isMatchingTarget && byteArrayEquals(data.beaconBlockRoot, rootCache.getBlockRootAtSlot(data.slot));
 
+  if (fork >= ForkSeq.gloas) {
+    let isMatchingPayload = false;
+
+    if (isAttestationSameSlotRootCache(rootCache, data)) {
+      if (data.index !== 0) {
+        throw new Error("Attesting same slot must indicate empty payload");
+      }
+      isMatchingPayload = true;
+    } else {
+      if (executionPayloadAvailability === null) {
+        throw new Error("Must supply executionPayloadAvailability post-gloas");
+      }
+
+      if (data.index !== 0 && data.index !== 1) {
+        throw new Error(`data index must be 0 or 1 index=${data.index}`);
+      }
+
+      isMatchingPayload = Boolean(data.index) === executionPayloadAvailability[data.slot % SLOTS_PER_HISTORICAL_ROOT];
+    }
+
+    isMatchingHead = isMatchingHead && isMatchingPayload;
+  }
+
   let flags = 0;
   if (isMatchingSource && inclusionDelay <= SLOTS_PER_EPOCH_SQRT) flags |= TIMELY_SOURCE;
   if (isMatchingTarget && isTimelyTarget(fork, inclusionDelay)) flags |= TIMELY_TARGET;

package/src/block/processConsolidationRequest.ts

@@ -1,6 +1,6 @@
-import {FAR_FUTURE_EPOCH, MIN_ACTIVATION_BALANCE, PENDING_CONSOLIDATIONS_LIMIT} from "@lodestar/params";
+import {FAR_FUTURE_EPOCH, ForkSeq, MIN_ACTIVATION_BALANCE, PENDING_CONSOLIDATIONS_LIMIT} from "@lodestar/params";
 import {electra, ssz} from "@lodestar/types";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasEth1WithdrawalCredential} from "../util/capella.js";
 import {
   hasCompoundingWithdrawalCredential,
@@ -13,7 +13,8 @@ import {getConsolidationChurnLimit, getPendingBalanceToWithdraw, isActiveValidat
 
 // TODO Electra: Clean up necessary as there is a lot of overlap with isValidSwitchToCompoundRequest
 export function processConsolidationRequest(
-  state: CachedBeaconStateElectra,
+  fork: ForkSeq,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationRequest: electra.ConsolidationRequest
 ): void {
   const {sourcePubkey, targetPubkey, sourceAddress} = consolidationRequest;
@@ -82,7 +83,7 @@ export function processConsolidationRequest(
   }
 
   // Verify the source has no pending withdrawals in the queue
-  if (getPendingBalanceToWithdraw(state, sourceIndex) > 0) {
+  if (getPendingBalanceToWithdraw(fork, state, sourceIndex) > 0) {
     return;
   }
 
@@ -103,7 +104,7 @@ export function processConsolidationRequest(
  * Determine if we should set consolidation target validator to compounding credential
  */
 function isValidSwitchToCompoundRequest(
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationRequest: electra.ConsolidationRequest
 ): boolean {
   const {sourcePubkey, targetPubkey, sourceAddress} = consolidationRequest;

package/src/block/processDepositRequest.ts

@@ -1,8 +1,11 @@
 import {UNSET_DEPOSIT_REQUESTS_START_INDEX} from "@lodestar/params";
 import {electra, ssz} from "@lodestar/types";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 
-export function processDepositRequest(state: CachedBeaconStateElectra, depositRequest: electra.DepositRequest): void {
+export function processDepositRequest(
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  depositRequest: electra.DepositRequest
+): void {
   if (state.depositRequestsStartIndex === UNSET_DEPOSIT_REQUESTS_START_INDEX) {
     state.depositRequestsStartIndex = depositRequest.index;
   }

package/src/block/processExecutionPayloadBid.ts

@@ -0,0 +1,120 @@
+import {PublicKey, Signature, verify} from "@chainsafe/blst";
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {
+  DOMAIN_BEACON_BUILDER,
+  FAR_FUTURE_EPOCH,
+  ForkPostGloas,
+  MIN_ACTIVATION_BALANCE,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
+import {BeaconBlock, gloas, ssz} from "@lodestar/types";
+import {toHex, toRootHex} from "@lodestar/utils";
+import {G2_POINT_AT_INFINITY} from "../constants/constants.ts";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {hasBuilderWithdrawalCredential} from "../util/gloas.ts";
+import {computeSigningRoot, getCurrentEpoch, getRandaoMix, isActiveValidator} from "../util/index.ts";
+
+export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block: BeaconBlock<ForkPostGloas>): void {
+  const signedBid = block.body.signedExecutionPayloadBid;
+  const bid = signedBid.message;
+  const {builderIndex, value: amount} = bid;
+  const builder = state.validators.getReadonly(builderIndex);
+
+  // For self-builds, amount must be zero regardless of withdrawal credential prefix
+  if (builderIndex === block.proposerIndex) {
+    if (amount !== 0) {
+      throw Error(`Invalid execution payload bid: self-build with non-zero amount ${amount}`);
+    }
+    if (!byteArrayEquals(signedBid.signature, G2_POINT_AT_INFINITY)) {
+      throw Error("Invalid execution payload bid: self-build with non-zero signature");
+    }
+    // Non-self builds require builder withdrawal credential
+  } else {
+    if (!hasBuilderWithdrawalCredential(builder.withdrawalCredentials)) {
+      throw Error(`Invalid execution payload bid: builder ${builderIndex} does not have builder withdrawal credential`);
+    }
+
+    if (!verifyExecutionPayloadBidSignature(state, builder.pubkey, signedBid)) {
+      throw Error(`Invalid execution payload bid: invalid signature for builder ${builderIndex}`);
+    }
+  }
+
+  if (!isActiveValidator(builder, getCurrentEpoch(state))) {
+    throw Error(`Invalid execution payload bid: builder ${builderIndex} is not active`);
+  }
+
+  if (builder.slashed) {
+    throw Error(`Invalid execution payload bid: builder ${builderIndex} is slashed`);
+  }
+
+  const pendingPayments = state.builderPendingPayments
+    .getAllReadonly()
+    .filter((payment) => payment.withdrawal.builderIndex === builderIndex)
+    .reduce((acc, payment) => acc + payment.withdrawal.amount, 0);
+  const pendingWithdrawals = state.builderPendingWithdrawals
+    .getAllReadonly()
+    .filter((withdrawal) => withdrawal.builderIndex === builderIndex)
+    .reduce((acc, withdrawal) => acc + withdrawal.amount, 0);
+
+  if (
+    amount !== 0 &&
+    state.balances.get(builderIndex) < amount + pendingPayments + pendingWithdrawals + MIN_ACTIVATION_BALANCE
+  ) {
+    throw Error("Insufficient builder balance");
+  }
+
+  if (bid.slot !== block.slot) {
+    throw Error(`Bid slot ${bid.slot} does not match block slot ${block.slot}`);
+  }
+
+  if (!byteArrayEquals(bid.parentBlockHash, state.latestBlockHash)) {
+    throw Error(
+      `Parent block hash ${toRootHex(bid.parentBlockHash)} of bid does not match state's latest block hash ${toRootHex(state.latestBlockHash)}`
+    );
+  }
+
+  if (!byteArrayEquals(bid.parentBlockRoot, block.parentRoot)) {
+    throw Error(
+      `Parent block root ${toRootHex(bid.parentBlockRoot)} of bid does not match block's parent root ${toRootHex(block.parentRoot)}`
+    );
+  }
+
+  const stateRandao = getRandaoMix(state, getCurrentEpoch(state));
+  if (!byteArrayEquals(bid.prevRandao, stateRandao)) {
+    throw Error(`Prev randao ${toHex(bid.prevRandao)} of bid does not match state's randao mix ${toHex(stateRandao)}`);
+  }
+
+  if (amount > 0) {
+    const pendingPaymentView = ssz.gloas.BuilderPendingPayment.toViewDU({
+      weight: 0,
+      withdrawal: ssz.gloas.BuilderPendingWithdrawal.toViewDU({
+        feeRecipient: bid.feeRecipient,
+        amount,
+        builderIndex,
+        withdrawableEpoch: FAR_FUTURE_EPOCH,
+      }),
+    });
+
+    state.builderPendingPayments.set(SLOTS_PER_EPOCH + (bid.slot % SLOTS_PER_EPOCH), pendingPaymentView);
+  }
+
+  state.latestExecutionPayloadBid = ssz.gloas.ExecutionPayloadBid.toViewDU(bid);
+}
+
+function verifyExecutionPayloadBidSignature(
+  state: CachedBeaconStateGloas,
+  pubkey: Uint8Array,
+  signedBid: gloas.SignedExecutionPayloadBid
+): boolean {
+  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_BUILDER);
+  const signingRoot = computeSigningRoot(ssz.gloas.ExecutionPayloadBid, signedBid.message, domain);
+
+  try {
+    const publicKey = PublicKey.fromBytes(pubkey);
+    const signature = Signature.fromBytes(signedBid.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/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
+  }
+}