@lodestar/beacon-node 1.48.0-dev.b62c97bb9f → 1.48.0-dev.b71ab45af3

package/src/chain/chain.ts

@@ -1271,65 +1271,59 @@ export class BeaconChain implements IBeaconChain {
     try {
       const prevHead = this.forkChoice.getHead();
       const head = this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetCanonicalHead}).head;
-      this.emitHeadEvents(prevHead, head);
-      return head;
-    } catch (e) {
-      this.metrics?.forkChoice.errors.inc({entrypoint: UpdateHeadOpt.GetCanonicalHead});
-      throw e;
-    } finally {
-      timer?.();
-    }
-  }
 
-  /**
-   * Emit `head` and `head_v2` when the fork choice head differs between two observations. Every caller that
-   * can move the head, `updateAndGetHead()` and `updateTime()`, must capture the head before and pass both.
-   */
-  private emitHeadEvents(prevHead: ProtoBlock, head: ProtoBlock): void {
-    const headRootChanged = head.blockRoot !== prevHead.blockRoot;
+      const headRootChanged = head.blockRoot !== prevHead.blockRoot;
 
-    if (!headRootChanged && prevHead.payloadStatus === head.payloadStatus) {
-      return;
-    }
+      if (!headRootChanged && prevHead.payloadStatus === head.payloadStatus) {
+        return head;
+      }
 
-    try {
-      const previousDutyDependentRoot = this.forkChoice.getDependentRoot(head, EpochDifference.previous);
-      const currentDutyDependentRoot = this.forkChoice.getDependentRoot(head, EpochDifference.current);
-      const epochTransition = computeStartSlotAtEpoch(computeEpochAtSlot(head.slot)) === head.slot;
-      const executionOptimistic = isOptimisticBlock(head);
-
-      if (headRootChanged) {
-        this.emitter.emit(routes.events.EventType.head, {
-          block: head.blockRoot,
-          epochTransition,
-          slot: head.slot,
-          state: head.stateRoot,
-          previousDutyDependentRoot,
-          currentDutyDependentRoot,
-          executionOptimistic,
+      try {
+        const previousDutyDependentRoot = this.forkChoice.getDependentRoot(head, EpochDifference.previous);
+        const currentDutyDependentRoot = this.forkChoice.getDependentRoot(head, EpochDifference.current);
+        const epochTransition = computeStartSlotAtEpoch(computeEpochAtSlot(head.slot)) === head.slot;
+        const executionOptimistic = isOptimisticBlock(head);
+
+        if (headRootChanged) {
+          this.emitter.emit(routes.events.EventType.head, {
+            block: head.blockRoot,
+            epochTransition,
+            slot: head.slot,
+            state: head.stateRoot,
+            previousDutyDependentRoot,
+            currentDutyDependentRoot,
+            executionOptimistic,
+          });
+        }
+
+        this.emitter.emit(routes.events.EventType.headV2, {
+          version: this.config.getForkName(head.slot),
+          data: {
+            slot: head.slot,
+            block: head.blockRoot,
+            state: head.stateRoot,
+            payloadStatus: head.payloadStatus === PayloadStatus.FULL ? "full" : "empty",
+            epochTransition,
+            currentEpochDependentRoot: previousDutyDependentRoot,
+            nextEpochDependentRoot: currentDutyDependentRoot,
+            executionOptimistic,
+          },
         });
+      } catch (e) {
+        // getDependentRoot() may fail with error: "No block for root" as we can see in holesky non-finality issue
+        this.logger.debug(
+          "Error emitting head/head_v2 event",
+          {slot: head.slot, root: head.blockRoot, headRootChanged},
+          e as Error
+        );
       }
 
-      this.emitter.emit(routes.events.EventType.headV2, {
-        version: this.config.getForkName(head.slot),
-        data: {
-          slot: head.slot,
-          block: head.blockRoot,
-          state: head.stateRoot,
-          payloadStatus: head.payloadStatus === PayloadStatus.FULL ? "full" : "empty",
-          epochTransition,
-          currentEpochDependentRoot: previousDutyDependentRoot,
-          nextEpochDependentRoot: currentDutyDependentRoot,
-          executionOptimistic,
-        },
-      });
+      return head;
     } catch (e) {
-      // getDependentRoot() may fail with error: "No block for root" as we can see in holesky non-finality issue
-      this.logger.debug(
-        "Error emitting head/head_v2 event",
-        {slot: head.slot, root: head.blockRoot, headRootChanged},
-        e as Error
-      );
+      this.metrics?.forkChoice.errors.inc({entrypoint: UpdateHeadOpt.GetCanonicalHead});
+      throw e;
+    } finally {
+      timer?.();
     }
   }
 
@@ -1618,10 +1612,7 @@ export class BeaconChain implements IBeaconChain {
       this.processShutdownCallback(this.forkChoice.irrecoverableError);
     }
 
-    // updateTime() recomputes the head on epoch-boundary checkpoint pull-up and under fast confirmation
-    const prevHead = this.forkChoice.getHead();
     this.forkChoice.updateTime(slot);
-    this.emitHeadEvents(prevHead, this.forkChoice.getHead());
     this.metrics?.clockSlot.set(slot);
 
     this.attestationPool.prune(slot);
@@ -1679,25 +1670,6 @@ export class BeaconChain implements IBeaconChain {
 
   private async onForkChoiceFinalized(this: BeaconChain, cp: CheckpointWithHex): Promise<void> {
     this.logger.verbose("Fork choice finalized", {epoch: cp.epoch, root: cp.rootHex});
-    this.metrics?.finalizedEpoch.set(cp.epoch);
-    const finalizedBlock = this.forkChoice.getBlockHexDefaultStatus(cp.rootHex);
-    if (finalizedBlock) {
-      // The callback runs synchronously inside fork choice checkpoint updates, defer writing to subscribers
-      callInNextEventLoop(() => {
-        this.emitter.emit(routes.events.EventType.finalizedCheckpoint, {
-          block: cp.rootHex,
-          epoch: cp.epoch,
-          state: finalizedBlock.stateRoot,
-          executionOptimistic: isOptimisticBlock(finalizedBlock),
-        });
-      });
-    } else {
-      this.logger.debug("Finalized block not found in fork choice, skip finalized_checkpoint event", {
-        epoch: cp.epoch,
-        root: cp.rootHex,
-      });
-    }
-
     const finalizedSlot = computeStartSlotAtEpoch(cp.epoch);
     this.seenBlockProposers.prune(finalizedSlot);
 

package/src/chain/emitter.ts

@@ -33,7 +33,7 @@ export enum ChainEvent {
   /**
    * This event signals that the fork choice store has been updated.
    *
-   * This event is guaranteed to be triggered whenever the fork choice finalized checkpoint is updated. This is either in response to a newly processed block or a new clock tick.
+   * This event is guaranteed to be triggered whenever the fork choice justified checkpoint is updated. This is in response to a newly processed block.
    */
   forkChoiceFinalized = "forkChoice:finalized",
   /**

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)

package/src/chain/validatorMonitor.ts

@@ -1,5 +1,5 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
   IBeaconStateView,
   ParticipationFlags,
@@ -1117,11 +1117,7 @@ function isCanonical(rootCache: RootHexCache, block: AttestationBlockInclusion):
 
 /** Returns true if root at slot is the same at slot - 1 == there was no new block at slot */
 function isMissedSlot(rootCache: RootHexCache, slot: Slot): boolean {
-  if (slot <= 0) {
-    return false;
-  }
-  const root = rootCache.getBlockRootAtSlot(slot);
-  return root !== null && root === rootCache.getBlockRootAtSlot(slot - 1);
+  return slot > 0 && rootCache.getBlockRootAtSlot(slot) === rootCache.getBlockRootAtSlot(slot - 1);
 }
 
 function renderBlockProposalSummary(
@@ -1135,11 +1131,7 @@ function renderBlockProposalSummary(
     return "not_submitted";
   }
 
-  const canonicalRoot = rootCache.getBlockRootAtSlot(proposalSlot);
-  if (canonicalRoot === null) {
-    return "unknown";
-  }
-  if (canonicalRoot === proposal.blockRoot) {
+  if (rootCache.getBlockRootAtSlot(proposalSlot) === proposal.blockRoot) {
     // Canonical state includes our block
     return "canonical";
   }
@@ -1165,23 +1157,14 @@ function renderBlockProposalSummary(
  * In normal network conditions the same root is read multiple times, specially the target.
  */
 export class RootHexCache {
-  private readonly blockRootSlotCache = new Map<Slot, RootHex | null>();
+  private readonly blockRootSlotCache = new Map<Slot, RootHex>();
 
   constructor(private readonly state: IBeaconStateView) {}
 
-  /**
-   * Block root at `slot`, null if the state does not cover it: slots at or after the state's own slot (an inclusion
-   * in a block the head state does not know yet, e.g. an orphaned block, or the slot after the last attestation of
-   * the epoch) or slots older than `SLOTS_PER_HISTORICAL_ROOT`. Callers treat null as unknown instead of throwing
-   * and aborting the summaries of all remaining validators.
-   */
-  getBlockRootAtSlot(slot: Slot): RootHex | null {
+  getBlockRootAtSlot(slot: Slot): RootHex {
     let root = this.blockRootSlotCache.get(slot);
-    if (root === undefined) {
-      root =
-        slot < this.state.slot && slot >= this.state.slot - SLOTS_PER_HISTORICAL_ROOT
-          ? toRootHex(this.state.getBlockRootAtSlot(slot))
-          : null;
+    if (!root) {
+      root = toRootHex(this.state.getBlockRootAtSlot(slot));
       this.blockRootSlotCache.set(slot, root);
     }
     return root;

package/src/execution/engine/mock.ts

@@ -296,10 +296,7 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
 
     // 5. Client software MUST update its forkchoice state if payloads referenced by forkchoiceState.headBlockHash and
     //    forkchoiceState.finalizedBlockHash are VALID.
-    //
-    // A zero finalizedBlockHash means "no finalized execution block" (e.g. the finalized checkpoint has no execution
-    // payload, pre-merge/pre-TTD). Real EL clients accept this, so the mock must not treat it as an unknown block.
-    if (finalizedBlockHash !== ZERO_HASH_HEX && !this.validBlocks.has(finalizedBlockHash)) {
+    if (!this.validBlocks.has(finalizedBlockHash)) {
       throw Error(`Unknown finalizedBlockHash ${finalizedBlockHash}`);
     }
     this.headBlockHash = headBlockHash;

package/src/network/reqresp/rateLimit.ts

@@ -126,8 +126,7 @@ function getRequestCountFn<T extends ReqRespMethod>(
   const type = requestSszTypeByMethod(fork, config)[method];
   return (reqData: Uint8Array) => {
     try {
-      // A schema-valid request can cost 0 tokens; floor to 1 so it stays charged and bannable, not free.
-      return Math.max(1, (type && fn(type.deserialize(reqData))) ?? 1);
+      return (type && fn(type.deserialize(reqData))) ?? 1;
     } catch (_e) {
       return 1;
     }