@lodestar/beacon-node 1.48.0-dev.262a9c1d16 → 1.48.0-dev.293e560a59

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.48.0-dev.262a9c1d16",
+  "version": "1.48.0-dev.293e560a59",
   "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.262a9c1d16",
-    "@lodestar/config": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/db": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/fork-choice": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/logger": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/params": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/reqresp": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/state-transition": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/types": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/utils": "^1.48.0-dev.262a9c1d16",
-    "@lodestar/validator": "^1.48.0-dev.262a9c1d16",
+    "@lodestar/api": "^1.48.0-dev.293e560a59",
+    "@lodestar/config": "^1.48.0-dev.293e560a59",
+    "@lodestar/db": "^1.48.0-dev.293e560a59",
+    "@lodestar/fork-choice": "^1.48.0-dev.293e560a59",
+    "@lodestar/logger": "^1.48.0-dev.293e560a59",
+    "@lodestar/params": "^1.48.0-dev.293e560a59",
+    "@lodestar/reqresp": "^1.48.0-dev.293e560a59",
+    "@lodestar/state-transition": "^1.48.0-dev.293e560a59",
+    "@lodestar/types": "^1.48.0-dev.293e560a59",
+    "@lodestar/utils": "^1.48.0-dev.293e560a59",
+    "@lodestar/validator": "^1.48.0-dev.293e560a59",
     "@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.262a9c1d16",
+    "@lodestar/spec-test-util": "^1.48.0-dev.293e560a59",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
@@ -175,5 +175,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "4c6fa0c6fa0074f9bd060fee542bd01986f7cf78"
+  "gitHead": "43ee31218fa076e8aa40dbe479ef5a8ec88e270e"
 }

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/blocks/importBlock.ts

@@ -524,6 +524,19 @@ export async function importBlock(
         this.metrics?.previousJustifiedEpoch.set(checkpointState.previousJustifiedCheckpoint.epoch);
         this.metrics?.currentJustifiedEpoch.set(justifiedCheckpoint.epoch);
       }
+      const finalizedCheckpoint = checkpointState.finalizedCheckpoint;
+      const finalizedEpoch = finalizedCheckpoint.epoch;
+      const preFinalizedEpoch = parentBlockSummary.finalizedEpoch;
+      if (finalizedEpoch > preFinalizedEpoch) {
+        this.emitter.emit(routes.events.EventType.finalizedCheckpoint, {
+          block: toRootHex(finalizedCheckpoint.root),
+          epoch: finalizedCheckpoint.epoch,
+          state: toRootHex(checkpointState.hashTreeRoot()),
+          executionOptimistic: false,
+        });
+        this.logger.verbose("Checkpoint finalized", toCheckpointHex(finalizedCheckpoint));
+        this.metrics?.finalizedEpoch.set(finalizedCheckpoint.epoch);
+      }
     }
   }
 

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