@lodestar/beacon-node 1.42.0-dev.7df0e2c8fa → 1.42.0-dev.8300b502a6

package/src/chain/blocks/payloadEnvelopeInput/payloadEnvelopeInput.ts

@@ -1,8 +1,9 @@
-import {NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {ColumnIndex, DataColumnSidecars, RootHex, Slot, ValidatorIndex, deneb, gloas} from "@lodestar/types";
+import {ForkName, NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {ColumnIndex, RootHex, Slot, ValidatorIndex, deneb, gloas} from "@lodestar/types";
 import {toRootHex, withTimeout} from "@lodestar/utils";
 import {VersionedHashes} from "../../../execution/index.js";
 import {kzgCommitmentToVersionedHash} from "../../../util/blobs.js";
+import {MissingColumnMeta} from "../blockInput/types.js";
 import {AddPayloadEnvelopeProps, ColumnWithSource, CreateFromBlockProps, SourceMeta} from "./types.js";
 
 export type PayloadEnvelopeInputState =
@@ -59,6 +60,7 @@ function createPromise<T>(): PromiseParts<T> {
 export class PayloadEnvelopeInput {
   readonly blockRootHex: RootHex;
   readonly slot: Slot;
+  readonly forkName: ForkName;
   readonly proposerIndex: ValidatorIndex;
   readonly bid: gloas.ExecutionPayloadBid;
   readonly versionedHashes: VersionedHashes;
@@ -71,13 +73,14 @@ export class PayloadEnvelopeInput {
   private timeCreatedSec: number;
 
   private readonly payloadEnvelopeDataPromise: PromiseParts<gloas.SignedExecutionPayloadEnvelope>;
-  private readonly columnsDataPromise: PromiseParts<DataColumnSidecars>;
+  private readonly columnsDataPromise: PromiseParts<gloas.DataColumnSidecar[]>;
 
   state: PayloadEnvelopeInputState;
 
   private constructor(props: {
     blockRootHex: RootHex;
     slot: Slot;
+    forkName: ForkName;
     proposerIndex: ValidatorIndex;
     bid: gloas.ExecutionPayloadBid;
     sampledColumns: ColumnIndex[];
@@ -86,6 +89,7 @@ export class PayloadEnvelopeInput {
   }) {
     this.blockRootHex = props.blockRootHex;
     this.slot = props.slot;
+    this.forkName = props.forkName;
     this.proposerIndex = props.proposerIndex;
     this.bid = props.bid;
     this.versionedHashes = props.bid.blobKzgCommitments.map(kzgCommitmentToVersionedHash);
@@ -112,6 +116,7 @@ export class PayloadEnvelopeInput {
     return new PayloadEnvelopeInput({
       blockRootHex: props.blockRootHex,
       slot: props.block.message.slot,
+      forkName: props.forkName,
       proposerIndex: props.block.message.proposerIndex,
       bid,
       sampledColumns: props.sampledColumns,
@@ -173,8 +178,12 @@ export class PayloadEnvelopeInput {
     }
   }
 
-  addColumn(columnWithSource: ColumnWithSource): void {
+  addColumn(columnWithSource: ColumnWithSource): boolean {
     const {columnSidecar, seenTimestampSec} = columnWithSource;
+    if (this.columnsCache.has(columnSidecar.index)) {
+      return false;
+    }
+
     this.columnsCache.set(columnSidecar.index, columnWithSource);
 
     const sampledColumns = this.getSampledColumns();
@@ -191,7 +200,7 @@ export class PayloadEnvelopeInput {
       sampledColumns.length === this.sampledColumns.length;
 
     if (!hasAllData) {
-      return;
+      return true;
     }
 
     if (hasComputedAllData) {
@@ -217,6 +226,20 @@ export class PayloadEnvelopeInput {
         hasComputedAllData: hasComputedAllData || this.state.hasComputedAllData,
       };
     }
+
+    return true;
+  }
+
+  hasColumn(index: ColumnIndex): boolean {
+    return this.columnsCache.has(index);
+  }
+
+  getColumn(index: ColumnIndex): gloas.DataColumnSidecar | undefined {
+    return this.columnsCache.get(index)?.columnSidecar;
+  }
+
+  getAllColumns(): gloas.DataColumnSidecar[] {
+    return [...this.columnsCache.values()].map(({columnSidecar}) => columnSidecar);
   }
 
   getVersionedHashes(): VersionedHashes {
@@ -237,8 +260,8 @@ export class PayloadEnvelopeInput {
     return this.state.payloadEnvelopeSource;
   }
 
-  getSampledColumns(): gloas.DataColumnSidecars {
-    const columns: gloas.DataColumnSidecars = [];
+  getSampledColumns(): gloas.DataColumnSidecar[] {
+    const columns: gloas.DataColumnSidecar[] = [];
     for (const index of this.sampledColumns) {
       const column = this.columnsCache.get(index);
       if (column) {
@@ -259,8 +282,8 @@ export class PayloadEnvelopeInput {
     return columns;
   }
 
-  getCustodyColumns(): gloas.DataColumnSidecars {
-    const columns: gloas.DataColumnSidecars = [];
+  getCustodyColumns(): gloas.DataColumnSidecar[] {
+    const columns: gloas.DataColumnSidecar[] = [];
     for (const index of this.custodyColumns) {
       const column = this.columnsCache.get(index);
       if (column) {
@@ -270,11 +293,29 @@ export class PayloadEnvelopeInput {
     return columns;
   }
 
+  hasAllData(): boolean {
+    return this.state.hasAllData;
+  }
+
+  getMissingSampledColumnMeta(): MissingColumnMeta {
+    if (this.state.hasAllData) {
+      return {missing: [], versionedHashes: this.versionedHashes};
+    }
+
+    const missing: ColumnIndex[] = [];
+    for (const index of this.sampledColumns) {
+      if (!this.columnsCache.has(index)) {
+        missing.push(index);
+      }
+    }
+    return {missing, versionedHashes: this.versionedHashes};
+  }
+
   hasComputedAllData(): boolean {
     return this.state.hasComputedAllData;
   }
 
-  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<DataColumnSidecars> {
+  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<gloas.DataColumnSidecar[]> {
     if (this.state.hasComputedAllData) {
       return Promise.resolve(this.getSampledColumns());
     }
@@ -319,7 +360,7 @@ export class PayloadEnvelopeInput {
     hasAllData: boolean;
     hasComputedAllData: boolean;
     isComplete: boolean;
-    columnsCount: number;
+    receivedColumns: number;
     sampledColumnsCount: number;
   } {
     return {
@@ -329,7 +370,7 @@ export class PayloadEnvelopeInput {
       hasAllData: this.state.hasAllData,
       hasComputedAllData: this.state.hasComputedAllData,
       isComplete: this.isComplete(),
-      columnsCount: this.columnsCache.size,
+      receivedColumns: this.columnsCache.size,
       sampledColumnsCount: this.sampledColumns.length,
     };
   }

package/src/chain/blocks/payloadEnvelopeInput/types.ts

@@ -1,4 +1,4 @@
-import {ForkPostGloas} from "@lodestar/params";
+import {ForkName, ForkPostGloas} from "@lodestar/params";
 import {ColumnIndex, RootHex, SignedBeaconBlock, gloas} from "@lodestar/types";
 
 export enum PayloadEnvelopeInputSource {
@@ -23,6 +23,7 @@ export type ColumnWithSource = SourceMeta & {
 export type CreateFromBlockProps = {
   blockRootHex: RootHex;
   block: SignedBeaconBlock<ForkPostGloas>;
+  forkName: ForkName;
   sampledColumns: ColumnIndex[];
   custodyColumns: ColumnIndex[];
   timeCreatedSec: number;

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 `postPayloadState`:
+ * - `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 &
+  (
+    | {
+        postPayloadState: null;
+        /** If the execution payload couldn't be verified because of EL syncing status, used in optimistic sync or for merge block */
+        executionStatus: BlockExecutionStatus;
+      }
+    | {
+        postPayloadState: IBeaconStateView;
+        executionStatus: PayloadExecutionStatus;
+      }
+  );

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -1,14 +1,14 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {
+  BlockExecutionStatus,
   ExecutionStatus,
   IForkChoice,
   LVHInvalidResponse,
   LVHValidResponse,
-  MaybeValidExecutionStatus,
   ProtoBlock,
 } from "@lodestar/fork-choice";
 import {ForkSeq} from "@lodestar/params";
-import {IBeaconStateView, isExecutionBlockBodyType} from "@lodestar/state-transition";
+import {IBeaconStateView, isExecutionBlockBodyType, isStatePostBellatrix} from "@lodestar/state-transition";
 import {bellatrix, electra} from "@lodestar/types";
 import {ErrorAborted, Logger, toRootHex} from "@lodestar/utils";
 import {ExecutionPayloadStatus, IExecutionEngine} from "../../execution/engine/interface.js";
@@ -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);
   }
@@ -152,6 +152,7 @@ export async function verifyBlockExecutionPayload(
 
   /** Not null if execution is enabled */
   const executionPayloadEnabled =
+    isStatePostBellatrix(preState0) &&
     preState0.isExecutionStateType &&
     isExecutionBlockBodyType(block.message.body) &&
     preState0.isExecutionEnabled(block.message)

package/src/chain/blocks/verifyBlocksSignatures.ts

@@ -1,5 +1,10 @@
 import {BeaconConfig} from "@lodestar/config";
-import {IBeaconStateView, getBlockSignatureSets} from "@lodestar/state-transition";
+import {
+  IBeaconStateView,
+  SyncCommitteeCacheEmpty,
+  getBlockSignatureSets,
+  isStatePostAltair,
+} from "@lodestar/state-transition";
 import {IndexedAttestation, SignedBeaconBlock} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
@@ -27,7 +32,9 @@ export async function verifyBlocksSignatures(
 ): Promise<{verifySignaturesTime: number}> {
   const isValidPromises: Promise<boolean>[] = [];
   const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
-  const currentSyncCommitteeIndexed = preState0.currentSyncCommitteeIndexed;
+  const currentSyncCommitteeIndexed = isStatePostAltair(preState0)
+    ? preState0.currentSyncCommitteeIndexed
+    : new SyncCommitteeCacheEmpty();
 
   // Verifies signatures after running state transition, so all SyncCommittee signed roots are known at this point.
   // We must ensure block.slot <= state.slot before running getAllBlockSignatureSets().

package/src/chain/chain.ts

@@ -15,9 +15,9 @@ import {
   BUILDER_INDEX_SELF_BUILD,
   EFFECTIVE_BALANCE_INCREMENT,
   type ForkPostFulu,
+  type ForkPostGloas,
   GENESIS_SLOT,
   SLOTS_PER_EPOCH,
-  isForkPostElectra,
   isForkPostGloas,
 } from "@lodestar/params";
 import {
@@ -29,12 +29,15 @@ import {
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   getEffectiveBalancesFromStateBytes,
+  isStatePostAltair,
+  isStatePostElectra,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {
   BeaconBlock,
   BlindedBeaconBlock,
   BlindedBeaconBlockBody,
-  DataColumnSidecars,
+  DataColumnSidecar,
   Epoch,
   Root,
   RootHex,
@@ -97,7 +100,7 @@ import {
 } from "./opPools/index.js";
 import {IChainOptions} from "./options.js";
 import {PrepareNextSlotScheduler} from "./prepareNextSlot.js";
-import {computeEnvelopeStateRoot, computeNewStateRoot} from "./produceBlock/computeNewStateRoot.js";
+import {computeNewStateRoot, computePayloadEnvelopeStateRoot} from "./produceBlock/computeNewStateRoot.js";
 import {AssembledBlockType, BlockType, ProduceFullGloas, ProduceResult} from "./produceBlock/index.js";
 import {BlockAttributes, produceBlockBody, produceCommonBlockBody} from "./produceBlock/produceBlockBody.js";
 import {QueuedStateRegenerator, RegenCaller} from "./regen/index.js";
@@ -504,7 +507,11 @@ export class BeaconChain implements IBeaconChain {
   }
 
   seenBlock(blockRoot: RootHex): boolean {
-    return this.seenBlockInputCache.has(blockRoot) || this.forkChoice.hasBlockHex(blockRoot);
+    return this.seenBlockInputCache.hasBlock(blockRoot) || this.forkChoice.hasBlockHexUnsafe(blockRoot);
+  }
+
+  seenPayloadEnvelope(blockRoot: RootHex): boolean {
+    return this.seenPayloadEnvelopeInputCache.hasPayload(blockRoot) || this.forkChoice.hasPayloadHexUnsafe(blockRoot);
   }
 
   regenCanAcceptWork(): boolean {
@@ -873,20 +880,32 @@ export class BeaconChain implements IBeaconChain {
     );
   }
 
-  async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecars> {
-    const blockInput = this.seenBlockInputCache.get(blockRootHex);
-    if (blockInput) {
-      if (!isBlockInputColumns(blockInput)) {
-        throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
+  async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecar[]> {
+    const fork = this.config.getForkName(blockSlot);
+
+    if (isForkPostGloas(fork)) {
+      // After gloas, columns are tracked in PayloadEnvelopeInput
+      const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
+      if (payloadInput) {
+        return payloadInput.getAllColumns();
+      }
+    } else {
+      // Before gloas, columns are tracked in BlockInput
+      const blockInput = this.seenBlockInputCache.get(blockRootHex);
+      if (blockInput) {
+        if (!isBlockInputColumns(blockInput)) {
+          throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
+        }
+        return blockInput.getAllColumns();
       }
-      return blockInput.getAllColumns();
     }
+
     const sidecarsUnfinalized = await this.db.dataColumnSidecar.values(fromHex(blockRootHex));
     if (sidecarsUnfinalized.length > 0) {
-      return sidecarsUnfinalized as DataColumnSidecars;
+      return sidecarsUnfinalized;
     }
     const sidecarsFinalized = await this.db.dataColumnSidecarArchive.values(blockSlot);
-    return sidecarsFinalized as DataColumnSidecars;
+    return sidecarsFinalized;
   }
 
   async getSerializedDataColumnSidecars(
@@ -894,23 +913,45 @@ export class BeaconChain implements IBeaconChain {
     blockRootHex: string,
     indices: number[]
   ): Promise<(Uint8Array | undefined)[]> {
-    const blockInput = this.seenBlockInputCache.get(blockRootHex);
-    if (blockInput) {
-      if (!isBlockInputColumns(blockInput)) {
-        throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
+    const fork = this.config.getForkName(blockSlot);
+
+    if (isForkPostGloas(fork)) {
+      // After gloas, columns are tracked in PayloadEnvelopeInput
+      const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
+      if (payloadInput) {
+        return indices.map((index) => {
+          const sidecar = payloadInput.getColumn(index);
+          if (!sidecar) {
+            return undefined;
+          }
+          const serialized = this.serializedCache.get(sidecar);
+          if (serialized) {
+            return serialized;
+          }
+          return sszTypesFor(fork as ForkPostGloas).DataColumnSidecar.serialize(sidecar);
+        });
       }
-      return indices.map((index) => {
-        const sidecar = blockInput.getColumn(index);
-        if (!sidecar) {
-          return undefined;
-        }
-        const serialized = this.serializedCache.get(sidecar);
-        if (serialized) {
-          return serialized;
+    } else {
+      // Before gloas, columns are tracked in BlockInput
+      const blockInput = this.seenBlockInputCache.get(blockRootHex);
+      if (blockInput) {
+        if (!isBlockInputColumns(blockInput)) {
+          throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
         }
-        return sszTypesFor(blockInput.forkName as ForkPostFulu).DataColumnSidecar.serialize(sidecar);
-      });
+        return indices.map((index) => {
+          const sidecar = blockInput.getColumn(index);
+          if (!sidecar) {
+            return undefined;
+          }
+          const serialized = this.serializedCache.get(sidecar);
+          if (serialized) {
+            return serialized;
+          }
+          return sszTypesFor(blockInput.forkName as ForkPostFulu).DataColumnSidecar.serialize(sidecar);
+        });
+      }
     }
+
     const sidecarsUnfinalized = await this.db.dataColumnSidecar.getManyBinary(fromHex(blockRootHex), indices);
     if (sidecarsUnfinalized.some((sidecar) => sidecar != null)) {
       return sidecarsUnfinalized;
@@ -1013,7 +1054,7 @@ export class BeaconChain implements IBeaconChain {
       body,
     } as AssembledBlockType<T>;
 
-    const {newStateRoot, proposerReward, postState} = computeNewStateRoot(this.metrics, state, block);
+    const {newStateRoot, proposerReward, postBlockState} = computeNewStateRoot(this.metrics, state, block);
     block.stateRoot = newStateRoot;
     const blockRoot =
       produceResult.type === BlockType.Full
@@ -1037,8 +1078,11 @@ export class BeaconChain implements IBeaconChain {
         slot,
         stateRoot: ZERO_HASH,
       };
-      const envelopeStateRoot = computeEnvelopeStateRoot(this.metrics, postState, envelope);
-      gloasResult.envelopeStateRoot = envelopeStateRoot;
+      if (!isStatePostGloas(postBlockState)) {
+        throw Error(`Expected gloas+ post-state for execution payload envelope, got fork=${postBlockState.forkName}`);
+      }
+      const payloadEnvelopeStateRoot = computePayloadEnvelopeStateRoot(this.metrics, postBlockState, envelope);
+      gloasResult.payloadEnvelopeStateRoot = payloadEnvelopeStateRoot;
     }
 
     // Track the produced block for consensus broadcast validations, later validation, etc.
@@ -1365,9 +1409,7 @@ export class BeaconChain implements IBeaconChain {
     metrics.chain.blacklistedBlocks.set(this.blacklistedBlocks.size);
 
     const headState = this.getHeadState();
-    const fork = this.config.getForkName(headState.slot);
-
-    if (isForkPostElectra(fork)) {
+    if (isStatePostElectra(headState)) {
       metrics.pendingDeposits.set(headState.pendingDepositsCount);
       metrics.pendingPartialWithdrawals.set(headState.pendingPartialWithdrawalsCount);
       metrics.pendingConsolidations.set(headState.pendingConsolidationsCount);
@@ -1614,6 +1656,9 @@ export class BeaconChain implements IBeaconChain {
     }
 
     preState = preState.processSlots(block.slot); // Dial preState's slot to block.slot
+    if (!isStatePostAltair(preState)) {
+      throw new Error("Sync committee rewards are not supported before Altair");
+    }
 
     return preState.computeSyncCommitteeRewards(block, validatorIds ?? []);
   }

package/src/chain/emitter.ts

@@ -3,7 +3,8 @@ import {StrictEventEmitter} from "strict-event-emitter-types";
 import {routes} from "@lodestar/api";
 import {CheckpointWithPayloadStatus} from "@lodestar/fork-choice";
 import {IBeaconStateView} from "@lodestar/state-transition";
-import {DataColumnSidecars, RootHex, deneb, phase0} from "@lodestar/types";
+import {DataColumnSidecar, RootHex, deneb, phase0} from "@lodestar/types";
+import {SignedExecutionPayloadEnvelope} from "@lodestar/types/gloas";
 import {PeerIdStr} from "../util/peerId.js";
 import {BlockInputSource, IBlockInput} from "./blocks/blockInput/types.js";
 
@@ -54,13 +55,22 @@ export enum ChainEvent {
    */
   updateStatus = "updateStatus",
   /**
-   * Trigger a BlockInputSync for blocks where the parentRoot is not known to fork choice
+   * Trigger BlockInputSync to find parent of a SignedBeaconBlock received
+   * Post-gloas, missing parent could be a SignedBeaconBlock and/or a SignedExecutionPayloadEnvelope
    */
-  unknownParent = "unknownParent",
+  blockUnknownParent = "blockUnknownParent",
   /**
-   * Trigger BlockInputSync for objects that correspond to a block that is not known to fork choice
+   * Trigger BlockInputSync to find a SignedBeaconBlock given a SignedExecutionPayloadEnvelop received
+   */
+  envelopeUnknownBlock = "envelopeUnknownBlock",
+  /**
+   * Trigger BlockInputSync to find a SignedBeaconBlock with specified block root.
    */
   unknownBlockRoot = "unknownBlockRoot",
+  /**
+   * Trigger BlockInputSync to find a SignedExecutionPayloadEnvelope with specified block root.
+   */
+  unknownEnvelopeBlockRoot = "unknownEnvelopeBlockRoot",
   /**
    * Trigger BlockInputSync for blocks that are partially received via gossip but are not complete by time the
    * cut-off window passes for waiting on gossip
@@ -75,9 +85,15 @@ export type ReorgEventData = routes.events.EventData[routes.events.EventType.cha
 type ApiEvents = {[K in routes.events.EventType]: (data: routes.events.EventData[K]) => void};
 
 export type ChainEventData = {
-  [ChainEvent.unknownParent]: {blockInput: IBlockInput; peer: PeerIdStr; source: BlockInputSource};
+  [ChainEvent.blockUnknownParent]: {blockInput: IBlockInput; peer: PeerIdStr; source: BlockInputSource};
+  [ChainEvent.envelopeUnknownBlock]: {
+    envelope: SignedExecutionPayloadEnvelope;
+    peer?: PeerIdStr;
+    source: BlockInputSource;
+  };
   [ChainEvent.unknownBlockRoot]: {rootHex: RootHex; peer?: PeerIdStr; source: BlockInputSource};
   [ChainEvent.incompleteBlockInput]: {blockInput: IBlockInput; peer: PeerIdStr; source: BlockInputSource};
+  [ChainEvent.unknownEnvelopeBlockRoot]: {rootHex: RootHex; peer?: PeerIdStr; source: BlockInputSource};
 };
 
 export type IChainEvents = ApiEvents & {
@@ -88,7 +104,7 @@ export type IChainEvents = ApiEvents & {
 
   [ChainEvent.updateTargetCustodyGroupCount]: (targetGroupCount: number) => void;
 
-  [ChainEvent.publishDataColumns]: (sidecars: DataColumnSidecars) => void;
+  [ChainEvent.publishDataColumns]: (sidecars: DataColumnSidecar[]) => void;
 
   [ChainEvent.publishBlobSidecars]: (sidecars: deneb.BlobSidecar[]) => void;
 
@@ -96,9 +112,11 @@ export type IChainEvents = ApiEvents & {
 
   // Sync events that are chain->chain. Initiated from network requests but do not cross the network
   // barrier so are considered ChainEvent(s).
-  [ChainEvent.unknownParent]: (data: ChainEventData[ChainEvent.unknownParent]) => void;
+  [ChainEvent.blockUnknownParent]: (data: ChainEventData[ChainEvent.blockUnknownParent]) => void;
+  [ChainEvent.envelopeUnknownBlock]: (data: ChainEventData[ChainEvent.envelopeUnknownBlock]) => void;
   [ChainEvent.unknownBlockRoot]: (data: ChainEventData[ChainEvent.unknownBlockRoot]) => void;
   [ChainEvent.incompleteBlockInput]: (data: ChainEventData[ChainEvent.incompleteBlockInput]) => void;
+  [ChainEvent.unknownEnvelopeBlockRoot]: (data: ChainEventData[ChainEvent.unknownEnvelopeBlockRoot]) => void;
 };
 
 /**

package/src/chain/errors/blockError.ts

@@ -70,6 +70,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",
+  /** The block's parent execution payload (defined by bid.parent_block_hash) has not been seen */
+  PARENT_PAYLOAD_UNKNOWN = "BLOCK_ERROR_PARENT_PAYLOAD_UNKNOWN",
 }
 
 type ExecutionErrorStatus = Exclude<
@@ -114,7 +116,8 @@ export type BlockErrorType =
   | {code: BlockErrorCode.EXECUTION_ENGINE_ERROR; execStatus: ExecutionErrorStatus; errorMessage: string}
   | {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.BID_PARENT_ROOT_MISMATCH; bidParentRoot: RootHex; blockParentRoot: RootHex}
+  | {code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN; parentBlockHash: RootHex};
 
 export class BlockGossipError extends GossipActionError<BlockErrorType> {}