@lodestar/beacon-node 1.45.0 → 1.46.0-dev.1cd9a671ea

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

@@ -50,6 +50,7 @@ import {
   ssz,
 } from "@lodestar/types";
 import {
+  GWEI_TO_WEI,
   TimeoutError,
   defer,
   formatWeiToEth,
@@ -101,7 +102,7 @@ import {computeSubnetForCommitteesAtSlot, getPubkeysForIndices, selectBlockProdu
  * A cutoff of 2 seconds gives enough time and if there are unexpected delays it ensures we publish
  * in time as proposals post 4 seconds into the slot will likely be orphaned due to proposer boost reorg.
  *
- * TODO GLOAS: re-evaluate cutoff timing
+ * TODO GLOAS: re-evaluate cutoff timing due to attestation deadline changes in gloas
  */
 const BLOCK_PRODUCTION_RACE_CUTOFF_MS = 2_000;
 /** Overall timeout for execution and block production apis */
@@ -528,6 +529,16 @@ export function getValidatorApi(
     builderBoostFactor?: bigint,
     {feeRecipient, builderSelection, strictFeeRecipientCheck}: routes.validator.ExtraProduceBlockOpts = {}
   ): Promise<ProduceBlindedBlockOrBlockContentsRes> {
+    builderSelection = builderSelection ?? routes.validator.BuilderSelection.MaxProfit;
+    if (builderSelection === routes.validator.BuilderSelection.BuilderOnly) {
+      logger.warn("Builder selection builderonly is no longer supported, treating as builderalways");
+      builderSelection = routes.validator.BuilderSelection.BuilderAlways;
+    }
+    builderBoostFactor = builderBoostFactor ?? BigInt(100);
+    if (builderBoostFactor > MAX_BUILDER_BOOST_FACTOR) {
+      throw new ApiError(400, `Invalid builderBoostFactor=${builderBoostFactor} > MAX_BUILDER_BOOST_FACTOR`);
+    }
+
     notWhileSyncing(chain, sync.state);
     await waitForSlot(slot); // Must never request for a future slot > currentSlot
 
@@ -538,36 +549,12 @@ export function getValidatorApi(
     metrics?.blockProductionSlotDelta.set(slot - parentSlot);
 
     const fork = config.getForkName(slot);
-    // set some sensible opts
-    // builderSelection will be deprecated and will run in mode MaxProfit if builder is enabled
-    // and the actual selection will be determined using builderBoostFactor passed by the validator
-    builderSelection = builderSelection ?? routes.validator.BuilderSelection.MaxProfit;
-    builderBoostFactor = builderBoostFactor ?? BigInt(100);
-    if (builderBoostFactor > MAX_BUILDER_BOOST_FACTOR) {
-      throw new ApiError(400, `Invalid builderBoostFactor=${builderBoostFactor} > MAX_BUILDER_BOOST_FACTOR`);
-    }
 
     const isBuilderEnabled =
       ForkSeq[fork] >= ForkSeq.bellatrix &&
       chain.executionBuilder !== undefined &&
       builderSelection !== routes.validator.BuilderSelection.ExecutionOnly;
 
-    // At any point either the builder or execution or both flows should be active.
-    //
-    // Ideally such a scenario should be prevented on startup, but proposerSettingsFile or keymanager
-    // configurations could cause a validator pubkey to have builder disabled with builder selection builder only
-    // (TODO: independently make sure such an options update is not successful for a validator pubkey)
-    //
-    // So if builder is disabled ignore builder selection of builder only if caused by user mistake
-    // https://github.com/ChainSafe/lodestar/issues/6338
-    const isEngineEnabled = !isBuilderEnabled || builderSelection !== routes.validator.BuilderSelection.BuilderOnly;
-
-    if (!isEngineEnabled && !isBuilderEnabled) {
-      throw Error(
-        `Internal Error: Neither builder nor execution proposal flow activated isBuilderEnabled=${isBuilderEnabled} builderSelection=${builderSelection}`
-      );
-    }
-
     const graffitiBytes = toGraffitiBytes(
       getBlockGraffiti(graffiti, getLodestarClientVersion(opts), chain.executionEngine.clientVersion, {
         private: opts.private,
@@ -582,7 +569,6 @@ export function getValidatorApi(
       fork,
       builderSelection,
       isBuilderEnabled,
-      isEngineEnabled,
       strictFeeRecipientCheck,
       // winston logger doesn't like bigint
       builderBoostFactor: `${builderBoostFactor}`,
@@ -608,27 +594,25 @@ export function getValidatorApi(
         })
       : Promise.reject(new Error("Builder disabled"));
 
-    const enginePromise = isEngineEnabled
-      ? produceEngineBlockContents(slot, randaoReveal, graffitiBytes, {
-          feeRecipient,
-          strictFeeRecipientCheck,
-          commonBlockBodyPromise,
-          parentBlock,
-        }).then((engineBlock) => {
-          // Once the engine returns a block, in the event of either:
-          // - suspected builder censorship
-          // - builder boost factor set to 0 or builder selection `executionalways`
-          // we don't need to wait for builder block as engine block will always be selected
-          if (
-            engineBlock.shouldOverrideBuilder ||
-            builderBoostFactor === BigInt(0) ||
-            builderSelection === routes.validator.BuilderSelection.ExecutionAlways
-          ) {
-            controller.abort();
-          }
-          return engineBlock;
-        })
-      : Promise.reject(new Error("Engine disabled"));
+    const enginePromise = produceEngineBlockContents(slot, randaoReveal, graffitiBytes, {
+      feeRecipient,
+      strictFeeRecipientCheck,
+      commonBlockBodyPromise,
+      parentBlock,
+    }).then((engineBlock) => {
+      // Once the engine returns a block, in the event of either:
+      // - suspected builder censorship
+      // - builder boost factor set to 0 or builder selection `executionalways`
+      // we don't need to wait for builder block as engine block will always be selected
+      if (
+        engineBlock.shouldOverrideBuilder ||
+        builderBoostFactor === BigInt(0) ||
+        builderSelection === routes.validator.BuilderSelection.ExecutionAlways
+      ) {
+        controller.abort();
+      }
+      return engineBlock;
+    });
 
     // Calculate cutoff time based on start of the slot
     const cutoffMs = Math.max(0, BLOCK_PRODUCTION_RACE_CUTOFF_MS - chain.clock.msFromSlot(slot));
@@ -675,30 +659,24 @@ export function getValidatorApi(
       throw Error("Builder and engine both failed to produce the block within timeout");
     }
 
-    if (builder.status === "pending" && !isEngineEnabled) {
-      throw Error("Builder failed to produce the block within timeout");
-    }
-
     if (engine.status === "pending" && !isBuilderEnabled) {
       throw Error("Engine failed to produce the block within timeout");
     }
 
-    if (isEngineEnabled) {
-      if (engine.status === "rejected") {
-        logger.warn(
-          "Engine failed to produce the block",
-          {
-            ...loggerContext,
-            durationMs: engine.durationMs,
-          },
-          engine.reason
-        );
-      } else if (engine.status === "pending") {
-        logger.warn("Engine failed to produce the block within cutoff time", {
+    if (engine.status === "rejected") {
+      logger.warn(
+        "Engine failed to produce the block",
+        {
           ...loggerContext,
-          cutoffMs,
-        });
-      }
+          durationMs: engine.durationMs,
+        },
+        engine.reason
+      );
+    } else if (engine.status === "pending") {
+      logger.warn("Engine failed to produce the block within cutoff time", {
+        ...loggerContext,
+        cutoffMs,
+      });
     }
 
     if (isBuilderEnabled) {
@@ -727,14 +705,12 @@ export function getValidatorApi(
     }
 
     if (builder.status === "rejected" && engine.status === "rejected") {
-      throw Error(
-        `${isBuilderEnabled && isEngineEnabled ? "Builder and engine both" : isBuilderEnabled ? "Builder" : "Engine"} failed to produce the block`
-      );
+      throw Error(`${isBuilderEnabled ? "Builder and engine both" : "Engine"} failed to produce the block`);
     }
 
     // handle shouldOverrideBuilder separately
-    if (engine.status === "fulfilled" && engine.value.shouldOverrideBuilder) {
-      logger.info("Selected engine block: censorship suspected in builder blocks", {
+    if (engine.status === "fulfilled" && engine.value.shouldOverrideBuilder && isBuilderEnabled) {
+      logger.warn("Selected engine block: censorship suspected in builder blocks", {
         ...loggerContext,
         durationMs: engine.durationMs,
         shouldOverrideBuilder: engine.value.shouldOverrideBuilder,
@@ -751,11 +727,9 @@ export function getValidatorApi(
 
     if (builder.status === "fulfilled" && engine.status !== "fulfilled") {
       const reason =
-        isEngineEnabled === false
-          ? BuilderBlockSelectionReason.EngineDisabled
-          : engine.status === "pending"
-            ? BuilderBlockSelectionReason.EnginePending
-            : BuilderBlockSelectionReason.EngineError;
+        engine.status === "pending"
+          ? BuilderBlockSelectionReason.EnginePending
+          : BuilderBlockSelectionReason.EngineError;
 
       logger.info("Selected builder block: no engine block produced", {
         reason,
@@ -865,13 +839,31 @@ export function getValidatorApi(
       return {data, meta};
     },
 
-    async produceBlockV4({slot, randaoReveal, graffiti, feeRecipient}) {
+    async produceBlockV4({
+      slot,
+      randaoReveal,
+      graffiti,
+      feeRecipient,
+      includePayload,
+      builderSelection,
+      builderBoostFactor,
+    }) {
       const fork = config.getForkName(slot);
 
       if (!isForkPostGloas(fork)) {
         throw new ApiError(400, `produceBlockV4 not supported for pre-gloas fork=${fork}`);
       }
 
+      builderSelection = builderSelection ?? routes.validator.BuilderSelection.MaxProfit;
+      if (builderSelection === routes.validator.BuilderSelection.BuilderOnly) {
+        logger.warn("Builder selection builderonly is no longer supported, treating as builderalways");
+        builderSelection = routes.validator.BuilderSelection.BuilderAlways;
+      }
+      builderBoostFactor = builderBoostFactor ?? BigInt(100);
+      if (builderBoostFactor > MAX_BUILDER_BOOST_FACTOR) {
+        throw new ApiError(400, `Invalid builderBoostFactor=${builderBoostFactor} > MAX_BUILDER_BOOST_FACTOR`);
+      }
+
       notWhileSyncing(chain, sync.state);
       await waitForSlot(slot);
 
@@ -888,15 +880,17 @@ export function getValidatorApi(
         })
       );
 
-      // TODO GLOAS: respect builderSelection (MaxProfit, BuilderAlways, ExecutionAlways, etc.) to let
-      // the user control bid source preferences and value comparison. Also add external builder api
-      // support when it is implemented.
+      // TODO GLOAS: add external builder api support when it is implemented
       const isBuildingOnFull = chain.forkChoice.shouldBuildOnFull(parentBlock, slot);
       const bidParentBlockHash = isBuildingOnFull ? parentBlock.executionPayloadBlockHash : parentBlock.parentBlockHash;
+      // Bids are only skipped entirely with executiononly or while the circuit breaker is active,
+      // other engine-preferring selections still build a block with the best bid as fallback in
+      // case local production fails
       const circuitBreakerActive = chain.builderCircuitBreaker.isActive(slot);
-      const builderBid = circuitBreakerActive
-        ? null
-        : chain.executionPayloadBidPool.getBestBid(slot, bidParentBlockHash, parentBlockRootHex);
+      const builderBid =
+        builderSelection === routes.validator.BuilderSelection.ExecutionOnly || circuitBreakerActive
+          ? null
+          : chain.executionPayloadBidPool.getBestBid(slot, bidParentBlockHash, parentBlockRootHex);
 
       const logCtx = {
         slot,
@@ -904,6 +898,8 @@ export function getValidatorApi(
         parentBlockRoot: parentBlockRootHex,
         parentBlockHash: parentBlock.executionPayloadBlockHash,
         fork,
+        builderSelection,
+        builderBoostFactor,
         circuitBreakerActive,
         ...(builderBid !== null
           ? {
@@ -940,33 +936,101 @@ export function getValidatorApi(
         return fn().finally(() => t?.({source}));
       };
 
-      // Always build local block. If builder bid available, also build with it in parallel and prefer it.
-      const [engineResult, bidResult] = await Promise.allSettled([
-        timed(ProducedBlockSource.engine, () => chain.produceBlock(baseAttrs)),
+      // Calculate cutoff time based on start of the slot, ensures a slow local payload build does
+      // not delay the proposal when a builder bid block is available (and vice versa)
+      const cutoffMs = Math.max(0, BLOCK_PRODUCTION_RACE_CUTOFF_MS - chain.clock.msFromSlot(slot));
+
+      // use abort controller to stop waiting for the bid block if the engine block will be selected
+      const controller = new AbortController();
+
+      const enginePromise: ReturnType<typeof chain.produceBlock> = timed(ProducedBlockSource.engine, () =>
+        chain.produceBlock(baseAttrs)
+      ).then((engineBlock) => {
+        // No need to wait for the bid block if the engine block will always be selected due to
+        // suspected builder censorship, a builder boost factor of 0 or executionalways selection
+        if (
+          engineBlock.shouldOverrideBuilder ||
+          builderBoostFactor === BigInt(0) ||
+          builderSelection === routes.validator.BuilderSelection.ExecutionAlways
+        ) {
+          controller.abort();
+        }
+        return engineBlock;
+      });
+      const bidPromise: ReturnType<typeof chain.produceBlock> =
         builderBid !== null
           ? timed(ProducedBlockSource.builder, () => chain.produceBlock({...baseAttrs, builderBid}))
-          : Promise.reject(),
-      ]);
+          : Promise.reject(new Error("No builder bid available"));
+
+      const [engineResult, bidResult] = await resolveOrRacePromises([enginePromise, bidPromise], {
+        resolveTimeoutMs: cutoffMs,
+        raceTimeoutMs: BLOCK_PRODUCTION_RACE_TIMEOUT_MS,
+        signal: controller.signal,
+      });
 
       let bestResult: typeof engineResult | null = null;
       let source: ProducedBlockSource = ProducedBlockSource.engine;
-      if (builderBid !== null && bidResult.status === "fulfilled") {
+
+      // handle shouldOverrideBuilder separately
+      if (engineResult.status === "fulfilled" && engineResult.value.shouldOverrideBuilder && builderBid !== null) {
+        source = ProducedBlockSource.engine;
+        bestResult = engineResult;
+        metrics?.blockProductionSelectionResults.inc({
+          source: ProducedBlockSource.engine,
+          reason: EngineBlockSelectionReason.BuilderCensorship,
+        });
+        logger.warn("Selected local block: censorship suspected in builder bid", logCtx);
+      } else if (engineResult.status === "fulfilled" && bidResult.status === "fulfilled") {
+        const result = selectBlockProductionSource({
+          builderSelection,
+          builderBoostFactor,
+          engineExecutionPayloadValue: engineResult.value.executionPayloadValue,
+          // The bid value is the payment to the proposer, in Gwei
+          builderExecutionPayloadValue: BigInt(builderBid?.message.value ?? 0) * GWEI_TO_WEI,
+        });
+        source = result.source;
+        metrics?.blockProductionSelectionResults.inc(result);
+        logger.info(`Selected ${source} block`, {reason: result.reason, ...logCtx});
+        bestResult = source === ProducedBlockSource.builder ? bidResult : engineResult;
+      } else if (bidResult.status === "fulfilled") {
         source = ProducedBlockSource.builder;
         bestResult = bidResult;
-        logger.info("Selected builder bid block", logCtx);
+        const reason =
+          engineResult.status === "pending"
+            ? BuilderBlockSelectionReason.EnginePending
+            : BuilderBlockSelectionReason.EngineError;
+        metrics?.blockProductionSelectionResults.inc({source: ProducedBlockSource.builder, reason});
+        logger.info("Selected builder bid block: no local block produced", {
+          reason,
+          ...logCtx,
+          error: engineResult.status === "rejected" ? (engineResult.reason as Error).message : undefined,
+        });
       } else if (engineResult.status === "fulfilled") {
         source = ProducedBlockSource.engine;
         bestResult = engineResult;
-        if (builderBid !== null) {
-          logger.warn("Builder bid block production failed, using local block", logCtx);
-        }
+        const reason =
+          builderBid === null
+            ? EngineBlockSelectionReason.BuilderNoBid
+            : bidResult.status === "pending"
+              ? EngineBlockSelectionReason.BuilderPending
+              : EngineBlockSelectionReason.BuilderError;
+        metrics?.blockProductionSelectionResults.inc({source: ProducedBlockSource.engine, reason});
+        logger.info("Selected local block: no builder bid block produced", {
+          reason,
+          ...logCtx,
+          error: bidResult.status === "rejected" ? (bidResult.reason as Error).message : undefined,
+        });
       }
 
       if (bestResult === null || bestResult.status !== "fulfilled") {
-        const engineReason = engineResult.status === "rejected" ? engineResult.reason : undefined;
-        const bidReason = builderBid !== null && bidResult.status === "rejected" ? bidResult.reason : undefined;
-        logger.error("Block production failed", {...logCtx, engineReason, bidReason});
-        throw Error(`Block production failed: engine=${engineReason ?? "n/a"} builder=${bidReason ?? "n/a"}`);
+        const engineReason = engineResult.status === "rejected" ? engineResult.reason : engineResult.status;
+        const bidReason = bidResult.status === "rejected" ? bidResult.reason : bidResult.status;
+        logger.error("Block production failed", {
+          ...logCtx,
+          engineReason: String(engineReason),
+          bidReason: String(bidReason),
+        });
+        throw Error(`Block production failed: engine=${String(engineReason)} builder=${String(bidReason)}`);
       }
 
       const {block, executionPayloadValue, consensusBlockValue} = bestResult.value;
@@ -987,9 +1051,41 @@ export function getValidatorApi(
         void chain.persistBlock(block, "produced_engine_block");
       }
 
+      // Include the payload for self-builds unless disabled (stateless flow)
+      const isSelfBuild = source === ProducedBlockSource.engine;
+      if (isSelfBuild && includePayload) {
+        const produceResult = chain.blockProductionCache.get(blockRoot);
+        if (
+          produceResult === undefined ||
+          !isForkPostGloas(produceResult.fork) ||
+          produceResult.type !== BlockType.Full
+        ) {
+          throw Error(`Missing cached block production result for produced block slot=${slot} blockRoot=${blockRoot}`);
+        }
+        const {executionPayload, executionRequests, blobsBundle, parentBlockRoot} = produceResult as ProduceFullGloas;
+
+        const blockContents: gloas.BlockContents = {
+          block: block as gloas.BeaconBlock,
+          executionPayloadEnvelope: {
+            payload: executionPayload,
+            executionRequests,
+            builderIndex: BUILDER_INDEX_SELF_BUILD,
+            beaconBlockRoot: fromHex(blockRoot),
+            parentBeaconBlockRoot: parentBlockRoot,
+          },
+          kzgProofs: blobsBundle.proofs,
+          blobs: blobsBundle.blobs,
+        };
+
+        return {
+          data: blockContents,
+          meta: {version: fork, consensusBlockValue, executionPayloadValue, executionPayloadIncluded: true},
+        };
+      }
+
       return {
         data: block as gloas.BeaconBlock,
-        meta: {version: fork, consensusBlockValue},
+        meta: {version: fork, consensusBlockValue, executionPayloadValue, executionPayloadIncluded: false},
       };
     },
 
@@ -1798,6 +1894,18 @@ export function getValidatorApi(
 
       const {executionPayload, executionRequests, parentBlockRoot} = produceResult as ProduceFullGloas;
 
+      if (executionPayload === undefined) {
+        // Blocks committing to a builder bid are cached as full but without payload data
+        throw new ApiError(404, `No local execution payload cached for block root ${blockRootHex}`);
+      }
+
+      if (executionPayload.slotNumber !== slot) {
+        throw new ApiError(
+          404,
+          `Cached execution payload is for slot=${executionPayload.slotNumber}, requested slot=${slot}`
+        );
+      }
+
       const envelope: gloas.ExecutionPayloadEnvelope = {
         payload: executionPayload,
         executionRequests: executionRequests,

package/src/api/rest/base.ts

@@ -5,6 +5,7 @@ import {parse as parseQueryString} from "qs";
 import {addSszContentTypeParser} from "@lodestar/api/server";
 import {NUMBER_OF_COLUMNS} from "@lodestar/params";
 import {ErrorAborted, Gauge, Histogram, Logger} from "@lodestar/utils";
+import {GossipActionError} from "../../chain/errors/gossipValidation.js";
 import {isLocalhostIP} from "../../util/ip.js";
 import {ApiError, FailureList, IndexedError, NodeIsSyncing} from "../impl/errors.js";
 import {HttpActiveSocketsTracker, SocketMetrics} from "./activeSockets.js";
@@ -121,8 +122,8 @@ export class RestApiServer {
         };
         void res.status(err.statusCode).send(payload);
       } else {
-        // Convert our custom ApiError into status code
-        const statusCode = err instanceof ApiError ? err.statusCode : 500;
+        // Convert known request errors into status codes
+        const statusCode = err instanceof ApiError ? err.statusCode : err instanceof GossipActionError ? 400 : 500;
         const payload: ErrorResponse = {code: statusCode, message: err.message, stacktraces};
         void res.status(statusCode).send(payload);
       }
@@ -170,7 +171,11 @@ export class RestApiServer {
 
       const operationId = getOperationId(req);
 
-      if (err instanceof ApiError || [INVALID_MEDIA_TYPE_CODE, SCHEMA_VALIDATION_ERROR_CODE].includes(err.code)) {
+      if (
+        err instanceof ApiError ||
+        err instanceof GossipActionError ||
+        [INVALID_MEDIA_TYPE_CODE, SCHEMA_VALIDATION_ERROR_CODE].includes(err.code)
+      ) {
         this.logger.warn(`Req ${req.id} ${operationId} failed`, {reason: err.message});
       } else {
         this.logger.error(`Req ${req.id} ${operationId} error`, {}, err);

package/src/chain/blocks/importBlock.ts

@@ -2,7 +2,6 @@ import {BitArray} from "@chainsafe/ssz";
 import {routes} from "@lodestar/api";
 import {
   AncestorStatus,
-  EpochDifference,
   ExecutionStatus,
   ForkChoiceError,
   ForkChoiceErrorCode,
@@ -21,7 +20,6 @@ import {
   IBeaconStateView,
   RootCache,
   computeEpochAtSlot,
-  computeStartSlotAtEpoch,
   computeTimeAtSlot,
   isStartSlotOfEpoch,
   isStatePostAltair,
@@ -301,21 +299,6 @@ export async function importBlock(
     // Set head state as strong reference
     this.regen.updateHeadState(newHead, postState);
 
-    try {
-      this.emitter.emit(routes.events.EventType.head, {
-        block: newHead.blockRoot,
-        epochTransition: computeStartSlotAtEpoch(computeEpochAtSlot(newHead.slot)) === newHead.slot,
-        slot: newHead.slot,
-        state: newHead.stateRoot,
-        previousDutyDependentRoot: this.forkChoice.getDependentRoot(newHead, EpochDifference.previous),
-        currentDutyDependentRoot: this.forkChoice.getDependentRoot(newHead, EpochDifference.current),
-        executionOptimistic: isOptimisticBlock(newHead),
-      });
-    } 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 event", {slot: newHead.slot, root: newHead.blockRoot}, e as Error);
-    }
-
     const delaySec = this.clock.secFromSlot(newHead.slot);
     this.logger.verbose("New chain head", {
       slot: newHead.slot,

package/src/chain/blocks/utils/chainSegment.ts

@@ -86,11 +86,22 @@ export function assertLinearChainSegment(
           // Maybe the previous slot's FULL envelope was orphaned — try falling back.
           // If even prevExecHash doesn't match, the segment is non-linear.
           if (bidParentHash !== prevExecHash) {
-            throw new BlockError(block, {
-              code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
-              parentRoot: toRootHex(block.message.parentRoot),
-              parentBlockHash: bidParentHash,
-            });
+            // i === 0 compares against the seeded fork-choice parent (segment boundary); i > 0
+            // compares against the in-segment predecessor's payload (broken link inside the segment).
+            throw new BlockError(
+              block,
+              i === 0
+                ? {
+                    code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+                    parentRoot: toRootHex(block.message.parentRoot),
+                    parentBlockHash: bidParentHash,
+                  }
+                : {
+                    code: BlockErrorCode.NON_LINEAR_PAYLOAD_ROOTS,
+                    parentBlockHash: bidParentHash,
+                    expectedBlockHash: currentExecHash,
+                  }
+            );
           }
           if (lastFullSlot !== null && payloadEnvelopes !== null) {
             const orphanedInput = payloadEnvelopes.get(lastFullSlot);

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -201,7 +201,7 @@ export async function verifyBlockExecutionPayload(
         invalidateFromParentBlockHash: toRootHex(executionPayloadEnabled.parentHash),
       };
       const execError = new BlockError(block, {
-        code: BlockErrorCode.EXECUTION_ENGINE_ERROR,
+        code: BlockErrorCode.EXECUTION_ENGINE_INVALID,
         execStatus: execResult.status,
         errorMessage: execResult.validationError ?? "",
       });

package/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -94,7 +94,7 @@ export function verifyBlocksSanityChecks(
       const parentRoot = toRootHex(block.message.parentRoot);
       const parentBlockDefaultStatus = chain.forkChoice.getBlockHexDefaultStatus(parentRoot);
       if (!parentBlockDefaultStatus) {
-        throw new BlockError(block, {code: BlockErrorCode.PARENT_UNKNOWN, parentRoot});
+        throw new BlockError(block, {code: BlockErrorCode.PARENT_BLOCK_UNKNOWN, parentRoot});
       }
 
       parentBlock = parentBlockDefaultStatus;

package/src/chain/blocks/verifyExecutionPayloadEnvelope.ts

@@ -100,8 +100,8 @@ export function verifyExecutionPayloadEnvelope(
   }
 
   // Verify consistency with expected withdrawals
-  const payloadWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(payload.withdrawals);
-  const expectedWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(state.payloadExpectedWithdrawals);
+  const payloadWithdrawalsRoot = ssz.gloas.Withdrawals.hashTreeRoot(payload.withdrawals);
+  const expectedWithdrawalsRoot = ssz.gloas.Withdrawals.hashTreeRoot(state.payloadExpectedWithdrawals);
   if (!byteArrayEquals(payloadWithdrawalsRoot, expectedWithdrawalsRoot)) {
     throw new Error(
       `Withdrawals mismatch between payload and expected payload=${toRootHex(payloadWithdrawalsRoot)} expected=${toRootHex(expectedWithdrawalsRoot)}`

package/src/chain/chain.ts

@@ -1,8 +1,17 @@
 import path from "node:path";
 import {PrivateKey} from "@libp2p/interface";
 import {Type} from "@chainsafe/ssz";
+import {routes} from "@lodestar/api";
 import {BeaconConfig} from "@lodestar/config";
-import {CheckpointWithHex, ForkChoiceStateGetter, IForkChoice, ProtoBlock, UpdateHeadOpt} from "@lodestar/fork-choice";
+import {
+  CheckpointWithHex,
+  EpochDifference,
+  ForkChoiceStateGetter,
+  IForkChoice,
+  PayloadStatus,
+  ProtoBlock,
+  UpdateHeadOpt,
+} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
@@ -1179,7 +1188,56 @@ export class BeaconChain implements IBeaconChain {
     const timer = this.metrics?.forkChoice.findHead.startTimer({caller});
 
     try {
-      return this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetCanonicalHead}).head;
+      const prevHead = this.forkChoice.getHead();
+      const head = this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetCanonicalHead}).head;
+
+      const headRootChanged = head.blockRoot !== prevHead.blockRoot;
+
+      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,
+          });
+        }
+
+        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
+        );
+      }
+
+      return head;
     } catch (e) {
       this.metrics?.forkChoice.errors.inc({entrypoint: UpdateHeadOpt.GetCanonicalHead});
       throw e;
@@ -1209,6 +1267,7 @@ export class BeaconChain implements IBeaconChain {
     const secFromSlot = this.clock.secFromSlot(slot);
 
     try {
+      // Do not emit head event here, when proposing we rely on the one emitted when importing our own block
       const {head, isHeadTimely, notReorgedReason} = this.forkChoice.updateAndGetHead({
         mode: UpdateHeadOpt.GetProposerHead,
         secFromSlot,