@lodestar/beacon-node 1.48.0-dev.57bd7a28a0 → 1.48.0-dev.58bd2c7c96

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.48.0-dev.57bd7a28a0",
+  "version": "1.48.0-dev.58bd2c7c96",
   "type": "module",
   "exports": {
     ".": {
@@ -109,7 +109,7 @@
     "@chainsafe/persistent-merkle-tree": "^1.3.1",
     "@chainsafe/prometheus-gc-stats": "^1.0.0",
     "@chainsafe/snappy-wasm": "^0.5.0",
-    "@chainsafe/ssz": "^1.7.0",
+    "@chainsafe/ssz": "^1.6.3",
     "@chainsafe/threads": "^1.11.3",
     "@crate-crypto/node-eth-kzg": "0.9.1",
     "@fastify/bearer-auth": "^10.0.1",
@@ -126,17 +126,17 @@
     "@libp2p/peer-id": "^6.0.15",
     "@libp2p/prometheus-metrics": "^5.0.28",
     "@libp2p/tcp": "^11.0.27",
-    "@lodestar/api": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/config": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/db": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/fork-choice": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/logger": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/params": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/reqresp": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/state-transition": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/types": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/utils": "^1.48.0-dev.57bd7a28a0",
-    "@lodestar/validator": "^1.48.0-dev.57bd7a28a0",
+    "@lodestar/api": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/config": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/db": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/fork-choice": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/logger": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/params": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/reqresp": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/state-transition": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/types": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/utils": "^1.48.0-dev.58bd2c7c96",
+    "@lodestar/validator": "^1.48.0-dev.58bd2c7c96",
     "@multiformats/multiaddr": "^13.0.1",
     "datastore-core": "^12.0.1",
     "datastore-level": "^13.0.1",
@@ -158,7 +158,7 @@
     "@libp2p/interface-internal": "^3.1.12",
     "@libp2p/logger": "^6.2.13",
     "@libp2p/utils": "^7.4.0",
-    "@lodestar/spec-test-util": "^1.48.0-dev.57bd7a28a0",
+    "@lodestar/spec-test-util": "^1.48.0-dev.58bd2c7c96",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
@@ -175,5 +175,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "e5cd49ed863ff394fbeb39a95c488dcd0d4fd574"
+  "gitHead": "5c8d15843b51c830b516320bfd00c1c9ee34291f"
 }

package/src/api/impl/validator/index.ts

@@ -133,37 +133,40 @@ type BidCandidate = {
 };
 
 /**
- * Ranking value of a bid, the boosted total payment scaled by 100 as `boostFactor` is a percentage.
- * Kept scaled so bids that differ by less than a percent are not truncated into a tie.
+ * Return the best bid by boosted total payment. A candidate with the max boost factor is
+ * preferred over any other regardless of value, ties prefer a builder api bid over the
+ * p2p bid, and the earlier received bid between builder api bids.
  */
-function getBoostedTotalScaled({totalGwei, boostFactor}: BidCandidate): bigint {
-  return boostFactor * totalGwei;
-}
-
-/** Order bid candidates by preference, best first, used to select a bid and to log the ranking */
-function compareBidCandidates(a: BidCandidate, b: BidCandidate): number {
-  // Preserve max boost preference before comparing bid values
-  const aIsMaxBoost = a.boostFactor === MAX_BUILDER_BOOST_FACTOR;
-  const bIsMaxBoost = b.boostFactor === MAX_BUILDER_BOOST_FACTOR;
-  if (aIsMaxBoost !== bIsMaxBoost) {
-    return aIsMaxBoost ? -1 : 1;
-  }
-
-  const aBoostedTotal = getBoostedTotalScaled(a);
-  const bBoostedTotal = getBoostedTotalScaled(b);
-  if (aBoostedTotal !== bBoostedTotal) {
-    return aBoostedTotal > bBoostedTotal ? -1 : 1;
-  }
-
-  // A tie prefers a builder api bid over the p2p bid
-  const aIsBuilderApi = a.url !== undefined;
-  const bIsBuilderApi = b.url !== undefined;
-  if (aIsBuilderApi !== bIsBuilderApi) {
-    return aIsBuilderApi ? -1 : 1;
+function selectBestBid(candidates: BidCandidate[]): BidCandidate | null {
+  const boostedValue = ({totalGwei, boostFactor}: BidCandidate): bigint => boostFactor * totalGwei;
+  let best: BidCandidate | null = null;
+  for (const candidate of candidates) {
+    if (best === null) {
+      best = candidate;
+      continue;
+    }
+    // Preserve max boost preference before comparing bid values
+    const candidateIsMaxBoost = candidate.boostFactor === MAX_BUILDER_BOOST_FACTOR;
+    const bestIsMaxBoost = best.boostFactor === MAX_BUILDER_BOOST_FACTOR;
+    if (candidateIsMaxBoost !== bestIsMaxBoost) {
+      if (candidateIsMaxBoost) {
+        best = candidate;
+      }
+      continue;
+    }
+    const candidateValue = boostedValue(candidate);
+    const bestValue = boostedValue(best);
+    if (candidateValue > bestValue) {
+      best = candidate;
+    } else if (
+      candidateValue === bestValue &&
+      // A tie prefers a builder api bid over the p2p bid, and the earlier received bid otherwise
+      (best.url === undefined || (candidate.url !== undefined && candidate.receivedMs < best.receivedMs))
+    ) {
+      best = candidate;
+    }
   }
-
-  // and the earlier received bid between builder api bids
-  return a.receivedMs - b.receivedMs;
+  return best;
 }
 
 type ProduceBlockContentsRes = {executionPayloadValue: Wei; consensusBlockValue: Wei} & {
@@ -1046,24 +1049,20 @@ export function getValidatorApi(
           });
         }
 
-        if (candidates.length === 0) {
-          return null;
-        }
-
-        const rankedCandidates = candidates.toSorted(compareBidCandidates);
-        for (const [index, candidate] of rankedCandidates.entries()) {
-          logger.debug("Builder bid candidate", {
+        const best = selectBestBid(candidates);
+        if (candidates.length > 0) {
+          logger.debug("Ranked builder bid candidates", {
             slot,
-            rank: index + 1,
-            source: candidate.url !== undefined ? toPrintableUrl(candidate.url) : "p2p",
-            builder: candidate.signedBid.message.builderIndex,
-            total: prettyGweiToEth(candidate.totalGwei),
-            boost: candidate.boostFactor,
-            boosted: prettyGweiToEth(getBoostedTotalScaled(candidate) / 100n),
-            receivedMs: candidate.receivedMs,
+            candidates: candidates
+              .map(
+                (candidate) =>
+                  `${candidate.url ?? "p2p"}:total=${prettyGweiToEth(candidate.totalGwei)}:boost=${candidate.boostFactor}:received=${candidate.receivedMs}ms`
+              )
+              .join(","),
+            bidSource: best?.url ?? "p2p",
           });
         }
-        return rankedCandidates[0];
+        return best;
       })();
 
       const commonBlockBodyPromise = chain.produceCommonBlockBody({

package/src/chain/errors/blockError.ts

@@ -78,8 +78,8 @@ export enum BlockErrorCode {
   TOO_MANY_KZG_COMMITMENTS = "BLOCK_ERROR_TOO_MANY_KZG_COMMITMENTS",
   /** Bid parent block root does not match block parent root */
   BID_PARENT_ROOT_MISMATCH = "BLOCK_ERROR_BID_PARENT_ROOT_MISMATCH",
-  /** A block contains deposits where none are allowed */
-  NON_ZERO_DEPOSITS = "BLOCK_ERROR_NON_ZERO_DEPOSITS",
+  /** A block body operation or parent execution request list exceeds its per-block limit */
+  TOO_MANY_BLOCK_OPERATIONS = "BLOCK_ERROR_TOO_MANY_BLOCK_OPERATIONS",
   /** The parent block's execution payload has been verified as invalid */
   PARENT_EXECUTION_INVALID = "BLOCK_ERROR_PARENT_EXECUTION_INVALID",
   /**
@@ -153,7 +153,7 @@ export type BlockErrorType =
   | {code: BlockErrorCode.DATA_UNAVAILABLE}
   | {code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS; blobKzgCommitmentsLen: number; commitmentLimit: number}
   | {code: BlockErrorCode.BID_PARENT_ROOT_MISMATCH; bidParentRoot: RootHex; blockParentRoot: RootHex}
-  | {code: BlockErrorCode.NON_ZERO_DEPOSITS; count: number}
+  | {code: BlockErrorCode.TOO_MANY_BLOCK_OPERATIONS; name: string; count: number; limit: number}
   | {code: BlockErrorCode.PARENT_EXECUTION_INVALID; parentRoot: RootHex}
   | {code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN; parentRoot: RootHex; parentBlockHash: RootHex}
   | {code: BlockErrorCode.NON_LINEAR_PAYLOAD_ROOTS; parentBlockHash: RootHex; expectedBlockHash: RootHex};

package/src/chain/errors/executionPayloadEnvelope.ts

@@ -12,6 +12,8 @@ export enum ExecutionPayloadEnvelopeErrorCode {
   BUILDER_INDEX_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BUILDER_INDEX_MISMATCH",
   BLOCK_HASH_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BLOCK_HASH_MISMATCH",
   EXECUTION_REQUESTS_ROOT_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_EXECUTION_REQUESTS_ROOT_MISMATCH",
+  EXECUTION_REQUESTS_COUNT_EXCEEDED = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_EXECUTION_REQUESTS_COUNT_EXCEEDED",
+  WITHDRAWALS_COUNT_EXCEEDED = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_WITHDRAWALS_COUNT_EXCEEDED",
   INVALID_SIGNATURE = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_INVALID_SIGNATURE",
   PAYLOAD_ENVELOPE_INPUT_MISSING = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_PAYLOAD_ENVELOPE_INPUT_MISSING",
 }
@@ -42,6 +44,13 @@ export type ExecutionPayloadEnvelopeErrorType =
       envelopeRequestsRoot: RootHex;
       bidRequestsRoot: RootHex;
     }
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.EXECUTION_REQUESTS_COUNT_EXCEEDED;
+      name: string;
+      count: number;
+      limit: number;
+    }
+  | {code: ExecutionPayloadEnvelopeErrorCode.WITHDRAWALS_COUNT_EXCEEDED; count: number; limit: number}
   | {code: ExecutionPayloadEnvelopeErrorCode.INVALID_SIGNATURE}
   | {code: ExecutionPayloadEnvelopeErrorCode.PAYLOAD_ENVELOPE_INPUT_MISSING; blockRoot: RootHex};
 

package/src/chain/prepareNextSlot.ts

@@ -243,22 +243,6 @@ export class PrepareNextSlotScheduler {
           parentBlockHash = preparedState.latestExecutionPayloadHeader.blockHash;
         }
 
-        // If emitPayloadAttributes is true emit a SSE payloadAttributes event for
-        // every slot. Without the flag, only emit the event if we are proposing in the next slot.
-        if (
-          (feeRecipient || this.chain.opts.emitPayloadAttributes === true) &&
-          this.chain.emitter.listenerCount(routes.events.EventType.payloadAttributes)
-        ) {
-          const data = getPayloadAttributesForSSE(fork as ForkPostBellatrix, this.chain, {
-            prepareState: stateAfterParentPayload,
-            prepareSlot,
-            parentBlockRoot: fromHex(updatedHead.blockRoot),
-            parentBlockHash,
-            feeRecipient: feeRecipient ?? "0x0000000000000000000000000000000000000000",
-          });
-          this.chain.emitter.emit(routes.events.EventType.payloadAttributes, {data, version: fork});
-        }
-
         if (feeRecipient) {
           const preparationTime =
             computeTimeAtSlot(this.config, prepareSlot, this.chain.genesisTime) - Date.now() / 1000;
@@ -289,6 +273,22 @@ export class PrepareNextSlotScheduler {
         }
 
         this.computeStateHashTreeRoot(preparedState, isEpochTransition);
+
+        // If emitPayloadAttributes is true emit a SSE payloadAttributes event for
+        // every slot. Without the flag, only emit the event if we are proposing in the next slot.
+        if (
+          (feeRecipient || this.chain.opts.emitPayloadAttributes === true) &&
+          this.chain.emitter.listenerCount(routes.events.EventType.payloadAttributes)
+        ) {
+          const data = getPayloadAttributesForSSE(fork as ForkPostBellatrix, this.chain, {
+            prepareState: stateAfterParentPayload,
+            prepareSlot,
+            parentBlockRoot: fromHex(updatedHead.blockRoot),
+            parentBlockHash,
+            feeRecipient: feeRecipient ?? "0x0000000000000000000000000000000000000000",
+          });
+          this.chain.emitter.emit(routes.events.EventType.payloadAttributes, {data, version: fork});
+        }
       } else {
         // Pre-bellatrix only reaches here at an epoch transition to precompute the next epoch state
         const preparedState = await this.chain.regen.getBlockSlotState(

package/src/chain/produceBlock/produceBlockBody.ts

@@ -528,18 +528,23 @@ export async function produceBlockBody<T extends BlockType>(
         }
       }
 
-      const {blobKzgCommitments, executionRequests} = builderRes;
-      if (blobKzgCommitments === undefined) {
-        throw Error(`Invalid builder getHeader response for fork=${fork}, missing blobKzgCommitments`);
-      }
+      if (ForkSeq[fork] >= ForkSeq.deneb) {
+        const {blobKzgCommitments} = builderRes;
+        if (blobKzgCommitments === undefined) {
+          throw Error(`Invalid builder getHeader response for fork=${fork}, missing blobKzgCommitments`);
+        }
 
-      (blockBody as BlindedBeaconBlockBody<ForkName.fulu>).blobKzgCommitments = blobKzgCommitments;
-      Object.assign(logMeta, {blobs: blobKzgCommitments.length});
+        (blockBody as deneb.BlindedBeaconBlockBody).blobKzgCommitments = blobKzgCommitments;
+        Object.assign(logMeta, {blobs: blobKzgCommitments.length});
+      }
 
-      if (executionRequests === undefined) {
-        throw Error(`Invalid builder getHeader response for fork=${fork}, missing executionRequests`);
+      if (ForkSeq[fork] >= ForkSeq.electra) {
+        const {executionRequests} = builderRes;
+        if (executionRequests === undefined) {
+          throw Error(`Invalid builder getHeader response for fork=${fork}, missing executionRequests`);
+        }
+        (blockBody as electra.BlindedBeaconBlockBody).executionRequests = executionRequests;
       }
-      (blockBody as BlindedBeaconBlockBody<ForkName.fulu>).executionRequests = executionRequests;
     }
 
     // blockType === BlockType.Full
@@ -894,38 +899,45 @@ function preparePayloadAttributes(
 ): SSEPayloadAttributes["payloadAttributes"] {
   const timestamp = computeTimeAtSlot(chain.config, prepareSlot, prepareState.genesisTime);
   const prevRandao = prepareState.getRandaoMix(prepareState.epoch);
-  if (!isStatePostCapella(prepareState)) {
-    throw new Error("Expected Capella state for withdrawals");
-  }
+  const payloadAttributes = {
+    timestamp,
+    prevRandao,
+    suggestedFeeRecipient: feeRecipient,
+  };
 
-  let withdrawals: capella.Withdrawal[];
-  if (isStatePostGloas(prepareState)) {
-    const isExtendingPayload = byteArrayEquals(parentBlockHash, prepareState.latestExecutionPayloadBid.blockHash);
-    if (isExtendingPayload) {
-      // applyParentExecutionPayload sets latestBlockHash = parentBid.blockHash, so a mismatch
-      // here means the caller did not apply parent payload to prepareState
-      if (!byteArrayEquals(prepareState.latestBlockHash, prepareState.latestExecutionPayloadBid.blockHash)) {
-        throw new Error("Expected state with parent execution payload applied for withdrawals");
+  if (ForkSeq[fork] >= ForkSeq.capella) {
+    if (!isStatePostCapella(prepareState)) {
+      throw new Error("Expected Capella state for withdrawals");
+    }
+
+    if (isStatePostGloas(prepareState)) {
+      const isExtendingPayload = byteArrayEquals(parentBlockHash, prepareState.latestExecutionPayloadBid.blockHash);
+      if (isExtendingPayload) {
+        // applyParentExecutionPayload sets latestBlockHash = parentBid.blockHash, so a mismatch
+        // here means the caller did not apply parent payload to prepareState
+        if (!byteArrayEquals(prepareState.latestBlockHash, prepareState.latestExecutionPayloadBid.blockHash)) {
+          throw new Error("Expected state with parent execution payload applied for withdrawals");
+        }
+        (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+          prepareState.getExpectedWithdrawals().expectedWithdrawals;
+      } else {
+        // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
+        // already deducted from CL balances but never credited on the EL (the envelope
+        // was not delivered). The next payload must carry those same withdrawals to
+        // restore CL/EL consistency, otherwise validators permanently lose that balance.
+        (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+          prepareState.payloadExpectedWithdrawals;
       }
-      withdrawals = prepareState.getExpectedWithdrawals().expectedWithdrawals;
     } else {
-      // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
-      // already deducted from CL balances but never credited on the EL (the envelope
-      // was not delivered). The next payload must carry those same withdrawals to
-      // restore CL/EL consistency, otherwise validators permanently lose that balance.
-      withdrawals = prepareState.payloadExpectedWithdrawals;
+      // withdrawals logic is now fork aware as it changes on electra fork post capella
+      (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+        prepareState.getExpectedWithdrawals().expectedWithdrawals;
     }
-  } else {
-    withdrawals = prepareState.getExpectedWithdrawals().expectedWithdrawals;
   }
 
-  const payloadAttributes: deneb.SSEPayloadAttributes["payloadAttributes"] = {
-    timestamp,
-    prevRandao,
-    suggestedFeeRecipient: feeRecipient,
-    withdrawals,
-    parentBeaconBlockRoot: parentBlockRoot,
-  };
+  if (ForkSeq[fork] >= ForkSeq.deneb) {
+    (payloadAttributes as deneb.SSEPayloadAttributes["payloadAttributes"]).parentBeaconBlockRoot = parentBlockRoot;
+  }
 
   if (ForkSeq[fork] >= ForkSeq.gloas) {
     if (!isStatePostGloas(prepareState)) {
@@ -1038,28 +1050,37 @@ export async function produceCommonBlockBody<T extends BlockType>(
     step: BlockProductionStep.attestations,
   });
 
-  const endSyncAggregate = stepsMetrics?.startTimer();
-  const parentBlockRoot = fromHex(parentBlock.blockRoot);
-  const previousSlot = slot - 1;
-  const syncAggregate = this.syncContributionAndProofPool.getAggregate(previousSlot, parentBlockRoot);
-  this.metrics?.production.producedSyncAggregateParticipants.observe(
-    syncAggregate.syncCommitteeBits.getTrueBitIndexes().length
-  );
-  endSyncAggregate?.({
-    step: BlockProductionStep.syncAggregate,
-  });
-
-  // Live proposal production is supported from Fulu onward.
-  return {
+  const blockBody: Omit<CommonBlockBody, "blsToExecutionChanges" | "syncAggregate"> = {
     randaoReveal,
     graffiti,
+    // Eth1 data voting is no longer required since electra
     eth1Data: currentState.eth1Data,
     proposerSlashings: this.opts.disableProposerSlashings === true ? [] : proposerSlashings,
     attesterSlashings,
     attestations,
+    // Since electra, deposits are processed by the execution layer,
+    // we no longer support handling deposits from earlier forks.
     deposits: [],
     voluntaryExits,
-    blsToExecutionChanges,
-    syncAggregate,
   };
+
+  if (ForkSeq[fork] >= ForkSeq.capella) {
+    (blockBody as CommonBlockBody).blsToExecutionChanges = blsToExecutionChanges;
+  }
+
+  const endSyncAggregate = stepsMetrics?.startTimer();
+  if (ForkSeq[fork] >= ForkSeq.altair) {
+    const parentBlockRoot = fromHex(parentBlock.blockRoot);
+    const previousSlot = slot - 1;
+    const syncAggregate = this.syncContributionAndProofPool.getAggregate(previousSlot, parentBlockRoot);
+    this.metrics?.production.producedSyncAggregateParticipants.observe(
+      syncAggregate.syncCommitteeBits.getTrueBitIndexes().length
+    );
+    (blockBody as CommonBlockBody).syncAggregate = syncAggregate;
+  }
+  endSyncAggregate?.({
+    step: BlockProductionStep.syncAggregate,
+  });
+
+  return blockBody as CommonBlockBody;
 }

package/src/chain/validation/block.ts

@@ -1,6 +1,22 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {ExecutionStatus} from "@lodestar/fork-choice";
-import {ForkName, MIN_SEED_LOOKAHEAD, isForkPostBellatrix, isForkPostDeneb, isForkPostGloas} from "@lodestar/params";
+import {
+  ForkName,
+  MAX_ATTESTATIONS_ELECTRA,
+  MAX_ATTESTER_SLASHINGS_ELECTRA,
+  MAX_BLS_TO_EXECUTION_CHANGES,
+  MAX_BUILDER_DEPOSIT_REQUESTS_PER_PAYLOAD,
+  MAX_BUILDER_EXIT_REQUESTS_PER_PAYLOAD,
+  MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD,
+  MAX_PAYLOAD_ATTESTATIONS,
+  MAX_PROPOSER_SLASHINGS,
+  MAX_VOLUNTARY_EXITS,
+  MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD,
+  MIN_SEED_LOOKAHEAD,
+  isForkPostBellatrix,
+  isForkPostDeneb,
+  isForkPostGloas,
+} from "@lodestar/params";
 import {
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
@@ -157,8 +173,7 @@ export async function validateGossipBlock(
   }
 
   if (isForkPostGloas(fork)) {
-    const body = (block as gloas.BeaconBlock).body;
-    const bid = body.signedExecutionPayloadBid.message;
+    const bid = (block as gloas.BeaconBlock).body.signedExecutionPayloadBid.message;
 
     // [REJECT] The length of KZG commitments is less than or equal to the limitation defined in Consensus Layer
     // -- i.e. validate that len(bid.blob_kzg_commitments) <= max_blobs_per_block
@@ -181,12 +196,54 @@ export async function validateGossipBlock(
       });
     }
 
-    // [REJECT] The block contains no deposits.
-    if (body.deposits.length !== 0) {
-      throw new BlockGossipError(GossipAction.REJECT, {
-        code: BlockErrorCode.NON_ZERO_DEPOSITS,
-        count: body.deposits.length,
-      });
+    // [REJECT] The counts of `block.body.parent_execution_requests` are within
+    //   their respective limits -- i.e. validate that
+    //   `len(block.body.parent_execution_requests.withdrawals) <= MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD`,
+    //   `len(block.body.parent_execution_requests.consolidations) <= MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD`,
+    //   `len(block.body.parent_execution_requests.builder_deposits) <= MAX_BUILDER_DEPOSIT_REQUESTS_PER_PAYLOAD`,
+    //   and
+    //   `len(block.body.parent_execution_requests.builder_exits) <= MAX_BUILDER_EXIT_REQUESTS_PER_PAYLOAD`.
+    // [REJECT] The counts of the block body operations are within their respective
+    //   limits -- i.e. validate that
+    //   `len(block.body.proposer_slashings) <= MAX_PROPOSER_SLASHINGS`,
+    //   `len(block.body.attester_slashings) <= MAX_ATTESTER_SLASHINGS_ELECTRA`,
+    //   `len(block.body.attestations) <= MAX_ATTESTATIONS_ELECTRA`,
+    //   `len(block.body.deposits) == 0`,
+    //   `len(block.body.voluntary_exits) <= MAX_VOLUNTARY_EXITS`,
+    //   `len(block.body.bls_to_execution_changes) <= MAX_BLS_TO_EXECUTION_CHANGES`,
+    //   and `len(block.body.payload_attestations) <= MAX_PAYLOAD_ATTESTATIONS`.
+    const body = (block as gloas.BeaconBlock).body;
+    const requests = body.parentExecutionRequests;
+    const countLimits: [string, number, number][] = [
+      ["parentExecutionRequests.withdrawals", requests.withdrawals.length, MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD],
+      [
+        "parentExecutionRequests.consolidations",
+        requests.consolidations.length,
+        MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD,
+      ],
+      [
+        "parentExecutionRequests.builderDeposits",
+        requests.builderDeposits.length,
+        MAX_BUILDER_DEPOSIT_REQUESTS_PER_PAYLOAD,
+      ],
+      ["parentExecutionRequests.builderExits", requests.builderExits.length, MAX_BUILDER_EXIT_REQUESTS_PER_PAYLOAD],
+      ["proposerSlashings", body.proposerSlashings.length, MAX_PROPOSER_SLASHINGS],
+      ["attesterSlashings", body.attesterSlashings.length, MAX_ATTESTER_SLASHINGS_ELECTRA],
+      ["attestations", body.attestations.length, MAX_ATTESTATIONS_ELECTRA],
+      ["deposits", body.deposits.length, 0],
+      ["voluntaryExits", body.voluntaryExits.length, MAX_VOLUNTARY_EXITS],
+      ["blsToExecutionChanges", body.blsToExecutionChanges.length, MAX_BLS_TO_EXECUTION_CHANGES],
+      ["payloadAttestations", body.payloadAttestations.length, MAX_PAYLOAD_ATTESTATIONS],
+    ];
+    for (const [name, count, limit] of countLimits) {
+      if (count > limit) {
+        throw new BlockGossipError(GossipAction.REJECT, {
+          code: BlockErrorCode.TOO_MANY_BLOCK_OPERATIONS,
+          name,
+          count,
+          limit,
+        });
+      }
     }
 
     // TODO GLOAS: [REJECT] The block's execution payload parent (defined by bid.parent_block_hash) passes all validation

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -1,4 +1,11 @@
 import {PayloadStatus} from "@lodestar/fork-choice";
+import {
+  MAX_BUILDER_DEPOSIT_REQUESTS_PER_PAYLOAD,
+  MAX_BUILDER_EXIT_REQUESTS_PER_PAYLOAD,
+  MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD,
+  MAX_WITHDRAWALS_PER_PAYLOAD,
+  MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD,
+} from "@lodestar/params";
 import {
   computeStartSlotAtEpoch,
   getExecutionPayloadEnvelopeSignatureSet,
@@ -115,6 +122,36 @@ async function validateExecutionPayloadEnvelope(
     });
   }
 
+  // [REJECT] The counts of `execution_requests` are within their respective limits.
+  // New in Gloas:EIP7688 — progressive lists are unbounded at the type level, so bounds
+  // are enforced here in gossip validation.
+  const {executionRequests} = envelope;
+  const requestCountLimits: [string, number, number][] = [
+    ["withdrawals", executionRequests.withdrawals.length, MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD],
+    ["consolidations", executionRequests.consolidations.length, MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD],
+    ["builderDeposits", executionRequests.builderDeposits.length, MAX_BUILDER_DEPOSIT_REQUESTS_PER_PAYLOAD],
+    ["builderExits", executionRequests.builderExits.length, MAX_BUILDER_EXIT_REQUESTS_PER_PAYLOAD],
+  ];
+  for (const [name, count, limit] of requestCountLimits) {
+    if (count > limit) {
+      throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
+        code: ExecutionPayloadEnvelopeErrorCode.EXECUTION_REQUESTS_COUNT_EXCEEDED,
+        name,
+        count,
+        limit,
+      });
+    }
+  }
+
+  // [REJECT] The number of withdrawals is within the limit.
+  if (payload.withdrawals.length > MAX_WITHDRAWALS_PER_PAYLOAD) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
+      code: ExecutionPayloadEnvelopeErrorCode.WITHDRAWALS_COUNT_EXCEEDED,
+      count: payload.withdrawals.length,
+      limit: MAX_WITHDRAWALS_PER_PAYLOAD,
+    });
+  }
+
   // Get the block state to verify the builder's signature.
   const blockState = await chain.regen
     .getState(block.stateRoot, RegenCaller.validateGossipPayloadEnvelope)