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

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.37.0-rc.0",
+  "version": "1.38.0-dev.1ddbe5d870",
   "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-rc.0",
-    "@lodestar/params": "1.37.0-rc.0",
-    "@lodestar/types": "1.37.0-rc.0",
-    "@lodestar/utils": "1.37.0-rc.0",
+    "@lodestar/config": "1.38.0-dev.1ddbe5d870",
+    "@lodestar/params": "1.38.0-dev.1ddbe5d870",
+    "@lodestar/types": "1.38.0-dev.1ddbe5d870",
+    "@lodestar/utils": "1.38.0-dev.1ddbe5d870",
     "bigint-buffer": "^1.1.5"
   },
   "keywords": [
@@ -74,5 +74,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "f67eb777ee4528e5bb9dc7420c6e7ab28b6e0ff8"
+  "gitHead": "6971d287b75663e80ed5f5635d26e81892a53476"
 }

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

@@ -1,5 +1,6 @@
 import {ForkSeq, MAX_COMMITTEES_PER_SLOT, MAX_VALIDATORS_PER_COMMITTEE} from "@lodestar/params";
 import {IndexedAttestation, IndexedAttestationBigint} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {getIndexedAttestationBigintSignatureSet, getIndexedAttestationSignatureSet} from "../signatureSets/index.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {verifySignatureSet} from "../util/index.js";
@@ -8,6 +9,7 @@ import {verifySignatureSet} from "../util/index.js";
  * Check if `indexedAttestation` has sorted and unique indices and a valid aggregate signature.
  */
 export function isValidIndexedAttestation(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   indexedAttestation: IndexedAttestation,
   verifySignature: boolean
@@ -17,12 +19,13 @@ export function isValidIndexedAttestation(
   }
 
   if (verifySignature) {
-    return verifySignatureSet(getIndexedAttestationSignatureSet(state, indexedAttestation));
+    return verifySignatureSet(getIndexedAttestationSignatureSet(index2pubkey, state, indexedAttestation));
   }
   return true;
 }
 
 export function isValidIndexedAttestationBigint(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   indexedAttestation: IndexedAttestationBigint,
   verifySignature: boolean
@@ -32,7 +35,7 @@ export function isValidIndexedAttestationBigint(
   }
 
   if (verifySignature) {
-    return verifySignatureSet(getIndexedAttestationBigintSignatureSet(state, indexedAttestation));
+    return verifySignatureSet(getIndexedAttestationBigintSignatureSet(index2pubkey, state, indexedAttestation));
   }
   return true;
 }

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

@@ -50,7 +50,14 @@ export function processAttestationPhase0(
     state.previousEpochAttestations.push(pendingAttestation);
   }
 
-  if (!isValidIndexedAttestation(state, epochCtx.getIndexedAttestation(ForkSeq.phase0, attestation), verifySignature)) {
+  if (
+    !isValidIndexedAttestation(
+      epochCtx.index2pubkey,
+      state,
+      epochCtx.getIndexedAttestation(ForkSeq.phase0, attestation),
+      verifySignature
+    )
+  ) {
     throw new Error("Attestation is not valid");
   }
 }
@@ -86,7 +93,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;
 
@@ -58,7 +64,7 @@ export function processAttestationsAltair(
     // TODO: Why should we verify an indexed attestation that we just created? If it's just for the signature
     // we can verify only that and nothing else.
     if (verifySignature) {
-      const sigSet = getAttestationWithIndicesSignatureSet(state, attestation, attestingIndices);
+      const sigSet = getAttestationWithIndicesSignatureSet(epochCtx.index2pubkey, state, attestation, attestingIndices);
       if (!verifySignatureSet(sigSet)) {
         throw new Error("Attestation signature is not valid");
       }
@@ -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/processAttesterSlashing.ts

@@ -1,5 +1,6 @@
 import {ForkSeq} from "@lodestar/params";
 import {AttesterSlashing} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {getAttesterSlashableIndices, isSlashableAttestationData, isSlashableValidator} from "../util/index.js";
 import {isValidIndexedAttestationBigint} from "./isValidIndexedAttestation.js";
@@ -17,7 +18,8 @@ export function processAttesterSlashing(
   attesterSlashing: AttesterSlashing,
   verifySignatures = true
 ): void {
-  assertValidAttesterSlashing(state, attesterSlashing, verifySignatures);
+  const {epochCtx} = state;
+  assertValidAttesterSlashing(epochCtx.index2pubkey, state, attesterSlashing, verifySignatures);
 
   const intersectingIndices = getAttesterSlashableIndices(attesterSlashing);
 
@@ -25,7 +27,7 @@ export function processAttesterSlashing(
   const validators = state.validators; // Get the validators sub tree once for all indices
   // Spec requires to sort indexes beforehand
   for (const index of intersectingIndices.sort((a, b) => a - b)) {
-    if (isSlashableValidator(validators.getReadonly(index), state.epochCtx.epoch)) {
+    if (isSlashableValidator(validators.getReadonly(index), epochCtx.epoch)) {
       slashValidator(fork, state, index);
       slashedAny = true;
     }
@@ -37,6 +39,7 @@ export function processAttesterSlashing(
 }
 
 export function assertValidAttesterSlashing(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   attesterSlashing: AttesterSlashing,
   verifySignatures = true
@@ -52,7 +55,7 @@ export function assertValidAttesterSlashing(
   // be higher than the clock and the slashing would still be valid. Same applies to attestation data index, which
   // can be any arbitrary value. Must use bigint variants to hash correctly to all possible values
   for (const [i, attestation] of [attestation1, attestation2].entries()) {
-    if (!isValidIndexedAttestationBigint(state, attestation, verifySignatures)) {
+    if (!isValidIndexedAttestationBigint(index2pubkey, state, attestation, verifySignatures)) {
       throw new Error(`AttesterSlashing attestation${i} is invalid`);
     }
   }

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