@lodestar/beacon-node 1.42.0-dev.83dedda569 → 1.42.0-dev.84f3b9f030

package/src/chain/blocks/importExecutionPayload.ts

@@ -1,5 +1,6 @@
 import {routes} from "@lodestar/api";
-import {ForkName} from "@lodestar/params";
+import {ExecutionStatus, PayloadExecutionStatus} from "@lodestar/fork-choice";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {getExecutionPayloadEnvelopeSignatureSet} from "@lodestar/state-transition";
 import {byteArrayEquals, fromHex, toRootHex} from "@lodestar/utils";
 import {ExecutionPayloadStatus} from "../../execution/index.js";
@@ -51,18 +52,33 @@ export class PayloadError extends Error {
   }
 }
 
+function toForkChoiceExecutionStatus(status: ExecutionPayloadStatus): PayloadExecutionStatus {
+  switch (status) {
+    case ExecutionPayloadStatus.VALID:
+      return ExecutionStatus.Valid;
+    // TODO GLOAS: Handle optimistic import for payload
+    case ExecutionPayloadStatus.SYNCING:
+    case ExecutionPayloadStatus.ACCEPTED:
+      return ExecutionStatus.Syncing;
+    default:
+      throw new Error(`Unexpected execution payload status for fork choice: ${status}`);
+  }
+}
+
 /**
  * Import an execution payload envelope after all data is available.
  *
  * This function:
- * 1. Gets the ProtoBlock from fork choice
- * 2. Applies write-queue backpressure (waitForSpace) early, before verification
- * 3. Regenerates the block state
- * 4. Runs EL verification (notifyNewPayload) in parallel with signature verification and processExecutionPayloadEnvelope
- * 5. Persists verified payload envelope to hot DB
- * 6. Updates fork choice
- * 7. Caches the post-execution payload state
- * 8. Records metrics for column sources
+ * 1. Emits `execution_payload_available` if payload is for current slot
+ * 2. Gets the ProtoBlock from fork choice
+ * 3. Applies write-queue backpressure (waitForSpace) early, before verification
+ * 4. Regenerates the block state
+ * 5. Runs EL verification (notifyNewPayload) in parallel with signature verification and processExecutionPayloadEnvelope
+ * 6. Persists verified payload envelope to hot DB
+ * 7. Updates fork choice
+ * 8. Caches the post-execution payload state
+ * 9. Records metrics for column sources
+ * 10. Emits `execution_payload` for recent enough payloads after successful import
  *
  */
 export async function importExecutionPayload(
@@ -70,10 +86,24 @@ export async function importExecutionPayload(
   payloadInput: PayloadEnvelopeInput,
   opts: ImportPayloadOpts = {}
 ): Promise<void> {
-  const envelope = payloadInput.getPayloadEnvelope();
+  const signedEnvelope = payloadInput.getPayloadEnvelope();
+  const envelope = signedEnvelope.message;
   const blockRootHex = payloadInput.blockRootHex;
+  const blockHashHex = payloadInput.getBlockHashHex();
+  const fork = this.config.getForkName(envelope.slot);
 
-  // 1. Get ProtoBlock for parent root lookup
+  // 1. Emit `execution_payload_available` event at the start of import. At this point the payload input
+  // is already complete, so the payload and required data are available for payload attestation.
+  // This event is only about availability, not validity of the execution payload, hence we can emit
+  // it before getting a response from the execution client on whether the payload is valid or not.
+  if (this.clock.currentSlot === envelope.slot) {
+    this.emitter.emit(routes.events.EventType.executionPayloadAvailable, {
+      slot: envelope.slot,
+      blockRoot: blockRootHex,
+    });
+  }
+
+  // 2. Get ProtoBlock for parent root lookup
   const protoBlock = this.forkChoice.getBlockHexDefaultStatus(blockRootHex);
   if (!protoBlock) {
     throw new PayloadError({
@@ -82,11 +112,11 @@ export async function importExecutionPayload(
     });
   }
 
-  // 2. Apply backpressure from the write queue early, before doing verification work.
+  // 3. Apply backpressure from the write queue early, before doing verification work.
   // The actual DB write is deferred until after verification succeeds.
   await this.unfinalizedPayloadEnvelopeWrites.waitForSpace();
 
-  // 3. Get pre-state for processExecutionPayloadEnvelope
+  // 4. Get pre-state for processExecutionPayloadEnvelope
   // We need the block state (post-block, pre-payload) to process the envelope
   const blockState = await this.regen.getBlockSlotState(
     protoBlock,
@@ -95,16 +125,16 @@ export async function importExecutionPayload(
     RegenCaller.processBlock
   );
 
-  // 4. Run verification steps in parallel
+  // 5. Run verification steps in parallel
   // Note: No data availability check needed here - importExecutionPayload is only
   // called when payloadInput.isComplete() is true, so all data is already available.
   const [execResult, signatureValid, postPayloadResult] = await Promise.all([
     this.executionEngine.notifyNewPayload(
-      ForkName.gloas,
-      envelope.message.payload,
+      fork,
+      envelope.payload,
       payloadInput.getVersionedHashes(),
       fromHex(protoBlock.parentRoot),
-      envelope.message.executionRequests
+      envelope.executionRequests
     ),
 
     opts.validSignature === true
@@ -114,7 +144,7 @@ export async function importExecutionPayload(
             this.config,
             this.pubkeyCache,
             blockState,
-            envelope,
+            signedEnvelope,
             payloadInput.proposerIndex
           );
           return this.bls.verifySignatureSets([signatureSet]);
@@ -125,7 +155,7 @@ export async function importExecutionPayload(
     (async () => {
       try {
         return {
-          postPayloadState: blockState.processExecutionPayloadEnvelope(envelope, {
+          postPayloadState: blockState.processExecutionPayloadEnvelope(signedEnvelope, {
             verifySignature: false,
             verifyStateRoot: false,
           }),
@@ -142,12 +172,12 @@ export async function importExecutionPayload(
     })(),
   ]);
 
-  // 4b. Check signature verification result
+  // 5a. Check signature verification result
   if (!signatureValid) {
     throw new PayloadError({code: PayloadErrorCode.INVALID_SIGNATURE});
   }
 
-  // 5. Handle EL response
+  // 5b. Handle EL response
   switch (execResult.status) {
     case ExecutionPayloadStatus.VALID:
       break;
@@ -161,12 +191,7 @@ export async function importExecutionPayload(
 
     case ExecutionPayloadStatus.ACCEPTED:
     case ExecutionPayloadStatus.SYNCING:
-      // TODO GLOAS: Handle optimistic import for payload - for now treat as error
-      throw new PayloadError({
-        code: PayloadErrorCode.EXECUTION_ENGINE_ERROR,
-        execStatus: execResult.status,
-        errorMessage: execResult.validationError ?? "EL syncing, payload not yet validated",
-      });
+      break;
 
     case ExecutionPayloadStatus.INVALID_BLOCK_HASH:
     case ExecutionPayloadStatus.ELERROR:
@@ -178,59 +203,65 @@ export async function importExecutionPayload(
       });
   }
 
-  // 5b. Verify envelope state root matches post-state
+  // 5c. Verify envelope state root matches post-state
   const postPayloadState = postPayloadResult.postPayloadState;
   const postPayloadStateRoot = postPayloadState.hashTreeRoot();
-  if (!byteArrayEquals(envelope.message.stateRoot, postPayloadStateRoot)) {
+  if (!byteArrayEquals(envelope.stateRoot, postPayloadStateRoot)) {
     throw new PayloadError({
       code: PayloadErrorCode.STATE_TRANSITION_ERROR,
-      message: `Envelope state root mismatch expected=${toRootHex(envelope.message.stateRoot)} actual=${toRootHex(postPayloadStateRoot)}`,
+      message: `Envelope state root mismatch expected=${toRootHex(envelope.stateRoot)} actual=${toRootHex(postPayloadStateRoot)}`,
     });
   }
 
-  // 5c. Persist payload envelope to hot DB (performed asynchronously to avoid blocking)
+  // 6. Persist payload envelope to hot DB (performed asynchronously to avoid blocking)
   this.unfinalizedPayloadEnvelopeWrites.push(payloadInput).catch((e) => {
     if (!isQueueErrorAborted(e)) {
       this.logger.error(
         "Error pushing payload envelope to unfinalized write queue",
-        {slot: payloadInput.slot, root: blockRootHex},
+        {slot: envelope.slot, root: blockRootHex},
         e as Error
       );
     }
   });
 
-  // 6. Update fork choice
+  // 7. Update fork choice
   this.forkChoice.onExecutionPayload(
     blockRootHex,
-    payloadInput.getBlockHashHex(),
-    envelope.message.payload.blockNumber,
-    toRootHex(postPayloadStateRoot)
+    blockHashHex,
+    envelope.payload.blockNumber,
+    toRootHex(postPayloadStateRoot),
+    toForkChoiceExecutionStatus(execResult.status)
   );
 
-  // 7. Cache payload state
-  // TODO GLOAS: Enable when PR #8868 merged (adds processPayloadState)
-  // this.regen.processPayloadState(postPayloadState);
-  // if epoch boundary also call
-  // this.regen.addCheckpointState(cp, checkpointState, true);
+  // 8. Cache payload state
+  this.regen.processPayloadState(postPayloadState);
+  if (postPayloadState.slot % SLOTS_PER_EPOCH === 0) {
+    const {checkpoint} = postPayloadState.computeAnchorCheckpoint();
+    this.regen.addCheckpointState(checkpoint, postPayloadState, true);
+  }
 
-  // 8. Record metrics for payload envelope and column sources
+  // 9. Record metrics for payload envelope and column sources
   this.metrics?.importPayload.bySource.inc({source: payloadInput.getPayloadEnvelopeSource().source});
   for (const {source} of payloadInput.getSampledColumnsWithSource()) {
     this.metrics?.importPayload.columnsBySource.inc({source});
   }
 
-  this.logger.verbose("Execution payload imported", {
-    slot: payloadInput.slot,
-    root: blockRootHex,
-    blockHash: payloadInput.getBlockHashHex(),
-  });
-
-  // 9. Emit event after payload is fully verified and imported to fork choice, only for recent enough payloads
-  const currentSlot = this.clock.currentSlot;
-  if (currentSlot - payloadInput.slot < EVENTSTREAM_EMIT_RECENT_EXECUTION_PAYLOAD_SLOTS) {
-    this.emitter.emit(routes.events.EventType.executionPayloadAvailable, {
-      slot: payloadInput.slot,
+  // 10. Emit event after payload is fully verified and imported to fork choice, only for recent enough payloads
+  if (this.clock.currentSlot - envelope.slot < EVENTSTREAM_EMIT_RECENT_EXECUTION_PAYLOAD_SLOTS) {
+    this.emitter.emit(routes.events.EventType.executionPayload, {
+      slot: envelope.slot,
+      builderIndex: envelope.builderIndex,
+      blockHash: blockHashHex,
       blockRoot: blockRootHex,
+      stateRoot: toRootHex(envelope.stateRoot),
+      // TODO GLOAS: revisit once we support optimistic import
+      executionOptimistic: false,
     });
   }
+
+  this.logger.verbose("Execution payload imported", {
+    slot: envelope.slot,
+    root: blockRootHex,
+    blockHash: blockHashHex,
+  });
 }

package/src/chain/blocks/index.ts

@@ -88,7 +88,8 @@ export async function processBlocks(
     const fullyVerifiedBlocks = relevantBlocks.map(
       (block, i): FullyVerifiedBlock => ({
         blockInput: block,
-        postState: postStates[i],
+        postBlockState: postStates[i],
+        postEnvelopeState: null,
         parentBlockSlot: parentSlots[i],
         executionStatus: executionStatuses[i],
         // start supporting optimistic syncing/processing

package/src/chain/blocks/types.ts

@@ -1,5 +1,5 @@
 import type {ChainForkConfig} from "@lodestar/config";
-import {MaybeValidExecutionStatus} from "@lodestar/fork-choice";
+import {BlockExecutionStatus, PayloadExecutionStatus} from "@lodestar/fork-choice";
 import {ForkSeq} from "@lodestar/params";
 import {DataAvailabilityStatus, IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
 import type {IndexedAttestation, Slot, fulu} from "@lodestar/types";
@@ -88,24 +88,35 @@ export type ImportBlockOpts = {
   seenTimestampSec?: number;
 };
 
-/**
- * A wrapper around a `SignedBeaconBlock` that indicates that this block is fully verified and ready to import
- */
-export type FullyVerifiedBlock = {
+type FullyVerifiedBlockBase = {
   blockInput: IBlockInput;
-  postState: IBeaconStateView;
+  postBlockState: IBeaconStateView;
   parentBlockSlot: Slot;
   proposerBalanceDelta: number;
-  /**
-   * If the execution payload couldnt be verified because of EL syncing status,
-   * used in optimistic sync or for merge block
-   */
-  executionStatus: MaybeValidExecutionStatus;
   dataAvailabilityStatus: DataAvailabilityStatus;
-  /**
-   * Pre-computed indexed attestations from signature verification to avoid duplicate work
-   */
+  /** Pre-computed indexed attestations from signature verification to avoid duplicate work */
   indexedAttestations: IndexedAttestation[];
   /** Seen timestamp seconds */
   seenTimestampSec: number;
 };
+
+/**
+ * A wrapper around a `SignedBeaconBlock` that indicates that this block is fully verified and ready to import.
+ *
+ * Discriminated union on `postEnvelopeState`:
+ * - `null`  → block has no pre-verified envelope; `executionStatus` is any `BlockExecutionStatus`
+ * - non-null → envelope was pre-verified during state transition; `executionStatus` is narrowed to
+ *              `Valid | Syncing` (matching what `forkChoice.onExecutionPayload` expects)
+ */
+export type FullyVerifiedBlock = FullyVerifiedBlockBase &
+  (
+    | {
+        postEnvelopeState: null;
+        /** If the execution payload couldn't be verified because of EL syncing status, used in optimistic sync or for merge block */
+        executionStatus: BlockExecutionStatus;
+      }
+    | {
+        postEnvelopeState: IBeaconStateView;
+        executionStatus: PayloadExecutionStatus;
+      }
+  );

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -1,10 +1,10 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {
+  BlockExecutionStatus,
   ExecutionStatus,
   IForkChoice,
   LVHInvalidResponse,
   LVHValidResponse,
-  MaybeValidExecutionStatus,
   ProtoBlock,
 } from "@lodestar/fork-choice";
 import {ForkSeq} from "@lodestar/params";
@@ -33,7 +33,7 @@ type ExecAbortType = {blockIndex: number; execError: BlockError};
 export type SegmentExecStatus =
   | {
       execAborted: null;
-      executionStatuses: MaybeValidExecutionStatus[];
+      executionStatuses: BlockExecutionStatus[];
       executionTime: number;
     }
   | {execAborted: ExecAbortType; invalidSegmentLVH?: LVHInvalidResponse};
@@ -62,7 +62,7 @@ export async function verifyBlocksExecutionPayload(
   signal: AbortSignal,
   opts: BlockProcessOpts & ImportBlockOpts
 ): Promise<SegmentExecStatus> {
-  const executionStatuses: MaybeValidExecutionStatus[] = [];
+  const executionStatuses: BlockExecutionStatus[] = [];
   const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
   const lastBlock = blockInputs.at(-1);
 
@@ -103,7 +103,7 @@ export async function verifyBlocksExecutionPayload(
       return getSegmentErrorResponse({verifyResponse, blockIndex}, parentBlock, blockInputs);
     }
 
-    // If we are here then its because executionStatus is one of MaybeValidExecutionStatus
+    // If we are here then its because executionStatus is one of BlockExecutionStatus
     const {executionStatus} = verifyResponse;
     executionStatuses.push(executionStatus);
   }

package/src/chain/options.ts

@@ -47,6 +47,7 @@ export type IChainOptions = BlockProcessOpts &
     minSameMessageSignatureSetsToBatch: number;
     archiveDateEpochs?: number;
     nHistoricalStatesFileDataStore?: boolean;
+    nativeStateView?: boolean;
   };
 
 export type BlockProcessOpts = {
@@ -124,6 +125,7 @@ export const defaultChainOptions: IChainOptions = {
   //   - users can prune the persisted checkpoint state files manually to save disc space
   //   - it helps debug easier when network is unfinalized
   nHistoricalStatesFileDataStore: true,
+  nativeStateView: false,
   maxBlockStates: DEFAULT_MAX_BLOCK_STATES,
   maxCPStateEpochsInMemory: DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY,
   maxCPStateEpochsOnDisk: DEFAULT_MAX_CP_STATE_ON_DISK,

package/src/network/processor/gossipHandlers.ts

@@ -841,16 +841,17 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       seenTimestampSec,
     }: GossipHandlerParamGeneric<GossipType.execution_payload>) => {
       const {serializedData} = gossipData;
-      const executionPayloadEnvelope = sszDeserialize(topic, serializedData);
+      const signedEnvelope = sszDeserialize(topic, serializedData);
+      const envelope = signedEnvelope.message;
       // TODO GLOAS: handle BLOCK_ROOT_UNKNOWN error to trigger sync
-      await validateGossipExecutionPayloadEnvelope(chain, executionPayloadEnvelope);
+      await validateGossipExecutionPayloadEnvelope(chain, signedEnvelope);
 
-      const slot = executionPayloadEnvelope.message.slot;
+      const slot = envelope.slot;
       const delaySec = seenTimestampSec - computeTimeAtSlot(config, slot, chain.genesisTime);
       metrics?.gossipExecutionPayloadEnvelope.elapsedTimeTillReceived.observe({source: OpSource.gossip}, delaySec);
-      chain.validatorMonitor?.registerExecutionPayloadEnvelope(OpSource.gossip, delaySec, executionPayloadEnvelope);
+      chain.validatorMonitor?.registerExecutionPayloadEnvelope(OpSource.gossip, delaySec, signedEnvelope);
 
-      const blockRootHex = toRootHex(executionPayloadEnvelope.message.beaconBlockRoot);
+      const blockRootHex = toRootHex(envelope.beaconBlockRoot);
       const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
 
       if (!payloadInput) {
@@ -861,16 +862,23 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         });
       }
 
-      chain.serializedCache.set(executionPayloadEnvelope, serializedData);
+      chain.serializedCache.set(signedEnvelope, serializedData);
 
       payloadInput.addPayloadEnvelope({
-        envelope: executionPayloadEnvelope,
+        envelope: signedEnvelope,
         source: PayloadEnvelopeInputSource.gossip,
         seenTimestampSec,
         peerIdStr,
       });
 
-      // TODO GLOAS: Emit execution_payload_gossip event for gossip receipt.
+      chain.emitter.emit(routes.events.EventType.executionPayloadGossip, {
+        slot,
+        builderIndex: envelope.builderIndex,
+        blockHash: toRootHex(envelope.payload.blockHash),
+        blockRoot: blockRootHex,
+        stateRoot: toRootHex(envelope.stateRoot),
+      });
+
       chain.processExecutionPayload(payloadInput, {validSignature: true}).catch((e) => {
         chain.logger.debug("Error processing execution payload from gossip", {slot, root: blockRootHex}, e as Error);
       });