@lodestar/beacon-node 1.42.0-dev.5f2fffc2ce → 1.42.0-dev.70938e1eec

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

@@ -0,0 +1,336 @@
+import {NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {ColumnIndex, DataColumnSidecars, 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 {AddPayloadEnvelopeProps, ColumnWithSource, CreateFromBlockProps, SourceMeta} from "./types.js";
+
+export type PayloadEnvelopeInputState =
+  | {
+      hasPayload: false;
+      hasAllData: false;
+      hasComputedAllData: false;
+    }
+  | {
+      hasPayload: false;
+      hasAllData: true;
+      hasComputedAllData: boolean;
+    }
+  | {
+      hasPayload: true;
+      hasAllData: false;
+      hasComputedAllData: false;
+      payloadEnvelope: gloas.SignedExecutionPayloadEnvelope;
+      payloadEnvelopeSource: SourceMeta;
+    }
+  | {
+      hasPayload: true;
+      hasAllData: true;
+      hasComputedAllData: boolean;
+      payloadEnvelope: gloas.SignedExecutionPayloadEnvelope;
+      payloadEnvelopeSource: SourceMeta;
+      timeCompleteSec: number;
+    };
+
+type PromiseParts<T> = {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (e: Error) => void;
+};
+
+function createPromise<T>(): PromiseParts<T> {
+  let resolve!: (value: T) => void;
+  let reject!: (e: Error) => void;
+  const promise = new Promise<T>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return {promise, resolve, reject};
+}
+
+/**
+ * Tracks bid + payload envelope + data columns for a Gloas block.
+ *
+ * Created during block import from signedExecutionPayloadBid in block body.
+ * Always has bid (required for creation).
+ *
+ * Completion requires: payload envelope + all sampled columns
+ */
+export class PayloadEnvelopeInput {
+  readonly blockRootHex: RootHex;
+  readonly slot: Slot;
+  readonly proposerIndex: ValidatorIndex;
+  readonly bid: gloas.ExecutionPayloadBid;
+  readonly versionedHashes: VersionedHashes;
+
+  private columnsCache = new Map<ColumnIndex, ColumnWithSource>();
+
+  private readonly sampledColumns: ColumnIndex[];
+  private readonly custodyColumns: ColumnIndex[];
+
+  private timeCreatedSec: number;
+
+  private readonly payloadEnvelopeDataPromise: PromiseParts<gloas.SignedExecutionPayloadEnvelope>;
+  private readonly columnsDataPromise: PromiseParts<DataColumnSidecars>;
+
+  state: PayloadEnvelopeInputState;
+
+  private constructor(props: {
+    blockRootHex: RootHex;
+    slot: Slot;
+    proposerIndex: ValidatorIndex;
+    bid: gloas.ExecutionPayloadBid;
+    sampledColumns: ColumnIndex[];
+    custodyColumns: ColumnIndex[];
+    timeCreatedSec: number;
+  }) {
+    this.blockRootHex = props.blockRootHex;
+    this.slot = props.slot;
+    this.proposerIndex = props.proposerIndex;
+    this.bid = props.bid;
+    this.versionedHashes = props.bid.blobKzgCommitments.map(kzgCommitmentToVersionedHash);
+    this.sampledColumns = props.sampledColumns;
+    this.custodyColumns = props.custodyColumns;
+    this.timeCreatedSec = props.timeCreatedSec;
+    this.payloadEnvelopeDataPromise = createPromise();
+    this.columnsDataPromise = createPromise();
+
+    const noBlobs = props.bid.blobKzgCommitments.length === 0;
+    const noSampledColumns = props.sampledColumns.length === 0;
+    const hasAllData = noBlobs || noSampledColumns;
+
+    if (hasAllData) {
+      this.state = {hasPayload: false, hasAllData: true, hasComputedAllData: true};
+      this.columnsDataPromise.resolve(this.getSampledColumns());
+    } else {
+      this.state = {hasPayload: false, hasAllData: false, hasComputedAllData: false};
+    }
+  }
+
+  static createFromBlock(props: CreateFromBlockProps): PayloadEnvelopeInput {
+    const bid = (props.block.message.body as gloas.BeaconBlockBody).signedExecutionPayloadBid.message;
+    return new PayloadEnvelopeInput({
+      blockRootHex: props.blockRootHex,
+      slot: props.block.message.slot,
+      proposerIndex: props.block.message.proposerIndex,
+      bid,
+      sampledColumns: props.sampledColumns,
+      custodyColumns: props.custodyColumns,
+      timeCreatedSec: props.timeCreatedSec,
+    });
+  }
+
+  getBid(): gloas.ExecutionPayloadBid {
+    return this.bid;
+  }
+
+  getBuilderIndex(): ValidatorIndex {
+    return this.bid.builderIndex;
+  }
+
+  getBlockHashHex(): RootHex {
+    return toRootHex(this.bid.blockHash);
+  }
+
+  getBlobKzgCommitments(): deneb.BlobKzgCommitments {
+    return this.bid.blobKzgCommitments;
+  }
+
+  addPayloadEnvelope(props: AddPayloadEnvelopeProps): void {
+    if (this.state.hasPayload) {
+      throw new Error(`Payload envelope already set for block ${this.blockRootHex}`);
+    }
+    if (toRootHex(props.envelope.message.beaconBlockRoot) !== this.blockRootHex) {
+      throw new Error("Payload envelope beacon_block_root mismatch");
+    }
+
+    const source: SourceMeta = {
+      source: props.source,
+      seenTimestampSec: props.seenTimestampSec,
+      peerIdStr: props.peerIdStr,
+    };
+
+    if (this.state.hasAllData) {
+      // Complete state
+      this.state = {
+        hasPayload: true,
+        hasAllData: true,
+        hasComputedAllData: this.state.hasComputedAllData,
+        payloadEnvelope: props.envelope,
+        payloadEnvelopeSource: source,
+        timeCompleteSec: props.seenTimestampSec,
+      };
+      this.payloadEnvelopeDataPromise.resolve(props.envelope);
+    } else {
+      // Has payload, waiting for columns
+      this.state = {
+        hasPayload: true,
+        hasAllData: false,
+        hasComputedAllData: false,
+        payloadEnvelope: props.envelope,
+        payloadEnvelopeSource: source,
+      };
+    }
+  }
+
+  addColumn(columnWithSource: ColumnWithSource): void {
+    const {columnSidecar, seenTimestampSec} = columnWithSource;
+    this.columnsCache.set(columnSidecar.index, columnWithSource);
+
+    const sampledColumns = this.getSampledColumns();
+    const hasAllData =
+      // already hasAllData
+      this.state.hasAllData ||
+      // has all sampled columns
+      sampledColumns.length === this.sampledColumns.length ||
+      // has enough columns to reconstruct the rest
+      this.columnsCache.size >= NUMBER_OF_COLUMNS / 2;
+
+    const hasComputedAllData =
+      // has all sampled columns
+      sampledColumns.length === this.sampledColumns.length;
+
+    if (!hasAllData) {
+      return;
+    }
+
+    if (hasComputedAllData) {
+      this.columnsDataPromise.resolve(sampledColumns);
+    }
+
+    if (this.state.hasPayload) {
+      // Complete state
+      this.state = {
+        hasPayload: true,
+        hasAllData: true,
+        hasComputedAllData: hasComputedAllData || this.state.hasComputedAllData,
+        payloadEnvelope: this.state.payloadEnvelope,
+        payloadEnvelopeSource: this.state.payloadEnvelopeSource,
+        timeCompleteSec: seenTimestampSec,
+      };
+      this.payloadEnvelopeDataPromise.resolve(this.state.payloadEnvelope);
+    } else {
+      // No payload yet, all data ready
+      this.state = {
+        hasPayload: false,
+        hasAllData: true,
+        hasComputedAllData: hasComputedAllData || this.state.hasComputedAllData,
+      };
+    }
+  }
+
+  getVersionedHashes(): VersionedHashes {
+    return this.versionedHashes;
+  }
+
+  hasPayloadEnvelope(): boolean {
+    return this.state.hasPayload;
+  }
+
+  getPayloadEnvelope(): gloas.SignedExecutionPayloadEnvelope {
+    if (!this.state.hasPayload) throw new Error("Payload envelope not set");
+    return this.state.payloadEnvelope;
+  }
+
+  getPayloadEnvelopeSource(): SourceMeta {
+    if (!this.state.hasPayload) throw new Error("Payload envelope source not set");
+    return this.state.payloadEnvelopeSource;
+  }
+
+  getSampledColumns(): gloas.DataColumnSidecars {
+    const columns: gloas.DataColumnSidecars = [];
+    for (const index of this.sampledColumns) {
+      const column = this.columnsCache.get(index);
+      if (column) {
+        columns.push(column.columnSidecar);
+      }
+    }
+    return columns;
+  }
+
+  getSampledColumnsWithSource(): ColumnWithSource[] {
+    const columns: ColumnWithSource[] = [];
+    for (const index of this.sampledColumns) {
+      const column = this.columnsCache.get(index);
+      if (column) {
+        columns.push(column);
+      }
+    }
+    return columns;
+  }
+
+  getCustodyColumns(): gloas.DataColumnSidecars {
+    const columns: gloas.DataColumnSidecars = [];
+    for (const index of this.custodyColumns) {
+      const column = this.columnsCache.get(index);
+      if (column) {
+        columns.push(column.columnSidecar);
+      }
+    }
+    return columns;
+  }
+
+  hasComputedAllData(): boolean {
+    return this.state.hasComputedAllData;
+  }
+
+  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<DataColumnSidecars> {
+    if (this.state.hasComputedAllData) {
+      return Promise.resolve(this.getSampledColumns());
+    }
+    return withTimeout(() => this.columnsDataPromise.promise, timeout, signal);
+  }
+
+  getTimeCreated(): number {
+    return this.timeCreatedSec;
+  }
+
+  getTimeComplete(): number {
+    if (!this.state.hasPayload || !this.state.hasAllData) throw new Error("Not yet complete");
+    return this.state.timeCompleteSec;
+  }
+
+  isComplete(): boolean {
+    return this.state.hasPayload && this.state.hasAllData;
+  }
+
+  async waitForData(): Promise<gloas.SignedExecutionPayloadEnvelope> {
+    return this.payloadEnvelopeDataPromise.promise;
+  }
+
+  getSerializedCacheKeys(): object[] {
+    const objects: object[] = [];
+
+    if (this.state.hasPayload) {
+      objects.push(this.state.payloadEnvelope);
+    }
+
+    for (const {columnSidecar} of this.columnsCache.values()) {
+      objects.push(columnSidecar);
+    }
+
+    return objects;
+  }
+
+  getLogMeta(): {
+    slot: number;
+    blockRoot: string;
+    hasPayload: boolean;
+    hasAllData: boolean;
+    hasComputedAllData: boolean;
+    isComplete: boolean;
+    columnsCount: number;
+    sampledColumnsCount: number;
+  } {
+    return {
+      slot: this.slot,
+      blockRoot: this.blockRootHex,
+      hasPayload: this.state.hasPayload,
+      hasAllData: this.state.hasAllData,
+      hasComputedAllData: this.state.hasComputedAllData,
+      isComplete: this.isComplete(),
+      columnsCount: this.columnsCache.size,
+      sampledColumnsCount: this.sampledColumns.length,
+    };
+  }
+}

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

@@ -0,0 +1,33 @@
+import {ForkPostGloas} from "@lodestar/params";
+import {ColumnIndex, RootHex, SignedBeaconBlock, gloas} from "@lodestar/types";
+
+export enum PayloadEnvelopeInputSource {
+  gossip = "gossip",
+  api = "api",
+  engine = "engine",
+  byRange = "req_resp_by_range",
+  byRoot = "req_resp_by_root",
+  recovery = "recovery",
+}
+
+export type SourceMeta = {
+  source: PayloadEnvelopeInputSource;
+  seenTimestampSec: number;
+  peerIdStr?: string;
+};
+
+export type ColumnWithSource = SourceMeta & {
+  columnSidecar: gloas.DataColumnSidecar;
+};
+
+export type CreateFromBlockProps = {
+  blockRootHex: RootHex;
+  block: SignedBeaconBlock<ForkPostGloas>;
+  sampledColumns: ColumnIndex[];
+  custodyColumns: ColumnIndex[];
+  timeCreatedSec: number;
+};
+
+export type AddPayloadEnvelopeProps = SourceMeta & {
+  envelope: gloas.SignedExecutionPayloadEnvelope;
+};

package/src/chain/blocks/payloadEnvelopeProcessor.ts

@@ -0,0 +1,61 @@
+import {Metrics} from "../../metrics/metrics.js";
+import {JobItemQueue} from "../../util/queue/index.js";
+import type {BeaconChain} from "../chain.js";
+import {PayloadEnvelopeInput} from "../seenCache/seenPayloadEnvelopeInput.js";
+import {importExecutionPayload} from "./importExecutionPayload.js";
+import {ImportPayloadOpts} from "./types.js";
+
+// TODO GLOAS: Set to be equal to DEFAULT_MAX_PENDING_UNFINALIZED_PAYLOAD_ENVELOPE_WRITES for now
+const QUEUE_MAX_LENGTH = 16;
+
+enum PayloadEnvelopeImportStatus {
+  queued = "queued",
+  importing = "importing",
+  imported = "imported",
+}
+
+/**
+ * PayloadEnvelopeProcessor processes payload envelope jobs in a queued fashion, one after the other.
+ */
+export class PayloadEnvelopeProcessor {
+  readonly jobQueue: JobItemQueue<[PayloadEnvelopeInput, ImportPayloadOpts], void>;
+  private readonly importStatus = new WeakMap<PayloadEnvelopeInput, PayloadEnvelopeImportStatus>();
+
+  constructor(chain: BeaconChain, metrics: Metrics | null, signal: AbortSignal) {
+    this.jobQueue = new JobItemQueue<[PayloadEnvelopeInput, ImportPayloadOpts], void>(
+      (payloadInput, opts) => {
+        this.importStatus.set(payloadInput, PayloadEnvelopeImportStatus.importing);
+        return importExecutionPayload.call(chain, payloadInput, opts);
+      },
+      {maxLength: QUEUE_MAX_LENGTH, noYieldIfOneItem: true, signal},
+      metrics?.payloadEnvelopeProcessorQueue ?? undefined
+    );
+  }
+
+  async processPayloadEnvelopeJob(payloadInput: PayloadEnvelopeInput, opts: ImportPayloadOpts = {}): Promise<void> {
+    if (!payloadInput.isComplete()) {
+      return;
+    }
+
+    if (this.importStatus.get(payloadInput) !== undefined) {
+      return;
+    }
+
+    await this.jobQueue.waitForSpace();
+
+    // Re-check after await, as another call may have queued this payload.
+    if (this.importStatus.get(payloadInput) !== undefined) {
+      return;
+    }
+
+    this.importStatus.set(payloadInput, PayloadEnvelopeImportStatus.queued);
+
+    try {
+      await this.jobQueue.push(payloadInput, opts);
+      this.importStatus.set(payloadInput, PayloadEnvelopeImportStatus.imported);
+    } catch (e) {
+      this.importStatus.delete(payloadInput);
+      throw e;
+    }
+  }
+}

package/src/chain/blocks/types.ts

@@ -41,6 +41,14 @@ export enum BlobSidecarValidation {
   Full,
 }
 
+export type ImportPayloadOpts = {
+  /**
+   * Set to true if envelope signature was already verified (e.g., during gossip/API validation).
+   * When false/undefined, signature will be verified during import.
+   */
+  validSignature?: boolean;
+};
+
 export type ImportBlockOpts = {
   /**
    * TEMP: Review if this is safe, Lighthouse always imports attestations even in finalized sync.

package/src/chain/blocks/writePayloadEnvelopeInputToDb.ts

@@ -0,0 +1,55 @@
+import {BeaconChain} from "../chain.js";
+import {PayloadEnvelopeInput} from "../seenCache/seenPayloadEnvelopeInput.js";
+import {writeDataColumnsToDb} from "./writeBlockInputToDb.js";
+
+/**
+ * Persists payload envelope data to DB. This operation must be eventually completed if a payload is imported.
+ *
+ * TODO GLOAS: Persist envelope metadata (stateRoot, executionRequests, builderIndex, etc.) without the full
+ * execution payload body — only keep the blockHash reference. The EL already stores the payload.
+ * See https://github.com/ChainSafe/lodestar/issues/5671
+ */
+export async function writePayloadEnvelopeInputToDb(
+  this: BeaconChain,
+  payloadInput: PayloadEnvelopeInput
+): Promise<void> {
+  const envelope = payloadInput.getPayloadEnvelope();
+  const blockRootHex = payloadInput.blockRootHex;
+
+  const envelopeBytes = this.serializedCache.get(envelope);
+  const envelopePromise = envelopeBytes
+    ? this.db.executionPayloadEnvelope.putBinary(this.db.executionPayloadEnvelope.getId(envelope), envelopeBytes)
+    : this.db.executionPayloadEnvelope.add(envelope);
+
+  // Write envelope and data columns in parallel (reuses shared column writing logic)
+  await Promise.all([envelopePromise, writeDataColumnsToDb.call(this, payloadInput)]);
+  this.logger.debug("Persisted payload envelope to db", {
+    slot: payloadInput.slot,
+    root: blockRootHex,
+  });
+}
+
+export async function persistPayloadEnvelopeInput(
+  this: BeaconChain,
+  payloadInput: PayloadEnvelopeInput
+): Promise<void> {
+  await writePayloadEnvelopeInputToDb
+    .call(this, payloadInput)
+    .catch((e) => {
+      this.logger.error(
+        "Error persisting payload envelope in hot db",
+        {
+          slot: payloadInput.slot,
+          root: payloadInput.blockRootHex,
+        },
+        e
+      );
+    })
+    .finally(() => {
+      this.seenPayloadEnvelopeInputCache.prune(payloadInput.blockRootHex);
+      this.logger.debug("Pruned payload envelope input", {
+        slot: payloadInput.slot,
+        root: payloadInput.blockRootHex,
+      });
+    });
+}

package/src/chain/chain.ts

@@ -84,7 +84,10 @@ import {CheckpointBalancesCache} from "./balancesCache.js";
 import {BeaconProposerCache} from "./beaconProposerCache.js";
 import {IBlockInput, isBlockInputBlobs, isBlockInputColumns} from "./blocks/blockInput/index.js";
 import {BlockProcessor, ImportBlockOpts} from "./blocks/index.js";
+import {PayloadEnvelopeProcessor} from "./blocks/payloadEnvelopeProcessor.js";
+import {ImportPayloadOpts} from "./blocks/types.js";
 import {persistBlockInput} from "./blocks/writeBlockInputToDb.js";
+import {persistPayloadEnvelopeInput} from "./blocks/writePayloadEnvelopeInputToDb.js";
 import {BlsMultiThreadWorkerPool, BlsSingleThreadVerifier, IBlsVerifier} from "./bls/index.js";
 import {ColumnReconstructionTracker} from "./ColumnReconstructionTracker.js";
 import {ChainEvent, ChainEventEmitter} from "./emitter.js";
@@ -109,13 +112,14 @@ import {BlockAttributes, produceBlockBody, produceCommonBlockBody} from "./produ
 import {QueuedStateRegenerator, RegenCaller} from "./regen/index.js";
 import {ReprocessController} from "./reprocess.js";
 import {
+  PayloadEnvelopeInput,
   SeenAggregators,
   SeenAttesters,
   SeenBlockProposers,
   SeenContributionAndProof,
   SeenExecutionPayloadBids,
-  SeenExecutionPayloadEnvelopes,
   SeenPayloadAttesters,
+  SeenPayloadEnvelopeInput,
   SeenSyncCommitteeMessages,
 } from "./seenCache/index.js";
 import {SeenAggregatedAttestations} from "./seenCache/seenAggregateAndProof.js";
@@ -148,6 +152,13 @@ const DEFAULT_MAX_CACHED_PRODUCED_RESULTS = 4;
  */
 const DEFAULT_MAX_PENDING_UNFINALIZED_BLOCK_WRITES = 16;
 
+/**
+ * The maximum number of pending unfinalized payload envelope writes to the database before backpressure is applied.
+ * Payload envelope write queue entries hold references to payload inputs (including columns),
+ * keeping them in memory. Keep moderate to avoid OOM during sync.
+ */
+const DEFAULT_MAX_PENDING_UNFINALIZED_PAYLOAD_ENVELOPE_WRITES = 16;
+
 export class BeaconChain implements IBeaconChain {
   readonly genesisTime: UintNum64;
   readonly genesisValidatorsRoot: Root;
@@ -172,6 +183,7 @@ export class BeaconChain implements IBeaconChain {
   readonly reprocessController: ReprocessController;
   readonly archiveStore: ArchiveStore;
   readonly unfinalizedBlockWrites: JobItemQueue<[IBlockInput], void>;
+  readonly unfinalizedPayloadEnvelopeWrites: JobItemQueue<[PayloadEnvelopeInput], void>;
 
   // Ops pool
   readonly attestationPool: AttestationPool;
@@ -187,13 +199,13 @@ export class BeaconChain implements IBeaconChain {
   readonly seenAggregators = new SeenAggregators();
   readonly seenPayloadAttesters = new SeenPayloadAttesters();
   readonly seenAggregatedAttestations: SeenAggregatedAttestations;
-  readonly seenExecutionPayloadEnvelopes = new SeenExecutionPayloadEnvelopes();
   readonly seenExecutionPayloadBids = new SeenExecutionPayloadBids();
   readonly seenBlockProposers = new SeenBlockProposers();
   readonly seenSyncCommitteeMessages = new SeenSyncCommitteeMessages();
   readonly seenContributionAndProof: SeenContributionAndProof;
   readonly seenAttestationDatas: SeenAttestationDatas;
   readonly seenBlockInputCache: SeenBlockInput;
+  readonly seenPayloadEnvelopeInputCache: SeenPayloadEnvelopeInput;
   // Seen cache for liveness checks
   readonly seenBlockAttesters = new SeenBlockAttesters();
 
@@ -221,6 +233,7 @@ export class BeaconChain implements IBeaconChain {
   readonly opts: IChainOptions;
 
   protected readonly blockProcessor: BlockProcessor;
+  protected readonly payloadEnvelopeProcessor: PayloadEnvelopeProcessor;
   protected readonly db: IBeaconDb;
   // this is only available if nHistoricalStates is enabled
   private readonly cpStateDatastore?: CPStateDatastore;
@@ -334,6 +347,13 @@ export class BeaconChain implements IBeaconChain {
       metrics,
       logger,
     });
+    this.seenPayloadEnvelopeInputCache = new SeenPayloadEnvelopeInput({
+      chainEvents: emitter,
+      signal,
+      serializedCache: this.serializedCache,
+      metrics,
+      logger,
+    });
 
     this._earliestAvailableSlot = anchorState.slot;
 
@@ -411,6 +431,7 @@ export class BeaconChain implements IBeaconChain {
     this.reprocessController = new ReprocessController(this.metrics);
 
     this.blockProcessor = new BlockProcessor(this, metrics, opts, signal);
+    this.payloadEnvelopeProcessor = new PayloadEnvelopeProcessor(this, metrics, signal);
 
     this.forkChoice = forkChoice;
     this.clock = clock;
@@ -447,6 +468,15 @@ export class BeaconChain implements IBeaconChain {
       metrics?.unfinalizedBlockWritesQueue
     );
 
+    this.unfinalizedPayloadEnvelopeWrites = new JobItemQueue(
+      persistPayloadEnvelopeInput.bind(this),
+      {
+        maxLength: DEFAULT_MAX_PENDING_UNFINALIZED_PAYLOAD_ENVELOPE_WRITES,
+        signal,
+      },
+      metrics?.unfinalizedPayloadEnvelopeWritesQueue
+    );
+
     // always run PrepareNextSlotScheduler except for fork_choice spec tests
     if (!opts?.disablePrepareNextSlot) {
       new PrepareNextSlotScheduler(this, this.config, metrics, this.logger, signal);
@@ -477,6 +507,7 @@ export class BeaconChain implements IBeaconChain {
     // we can abort any ongoing unfinalized block writes.
     // TODO: persist fork choice to disk and allow unfinalized block writes to complete.
     this.unfinalizedBlockWrites.dropAllJobs();
+    this.unfinalizedPayloadEnvelopeWrites.dropAllJobs();
 
     this.abortController.abort();
   }
@@ -1010,6 +1041,10 @@ export class BeaconChain implements IBeaconChain {
     return this.blockProcessor.processBlocksJob(blocks, opts);
   }
 
+  async processExecutionPayload(payloadInput: PayloadEnvelopeInput, opts?: ImportPayloadOpts): Promise<void> {
+    return this.payloadEnvelopeProcessor.processPayloadEnvelopeJob(payloadInput, opts);
+  }
+
   getStatus(): Status {
     const head = this.forkChoice.getHead();
     const finalizedCheckpoint = this.forkChoice.getFinalizedCheckpoint();
@@ -1402,7 +1437,6 @@ export class BeaconChain implements IBeaconChain {
     this.logger.verbose("Fork choice finalized", {epoch: cp.epoch, root: cp.rootHex});
     const finalizedSlot = computeStartSlotAtEpoch(cp.epoch);
     this.seenBlockProposers.prune(finalizedSlot);
-    this.seenExecutionPayloadEnvelopes.prune(finalizedSlot);
 
     // Update validator custody to account for effective balance changes
     await this.updateValidatorsCustodyRequirement(cp);

package/src/chain/errors/executionPayloadEnvelope.ts

@@ -4,17 +4,21 @@ import {GossipActionError} from "./gossipValidation.js";
 export enum ExecutionPayloadEnvelopeErrorCode {
   BELONG_TO_FINALIZED_BLOCK = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BELONG_TO_FINALIZED_BLOCK",
   BLOCK_ROOT_UNKNOWN = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BLOCK_ROOT_UNKNOWN",
+  PARENT_UNKNOWN = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_PARENT_UNKNOWN",
+  UNKNOWN_BLOCK_STATE = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_UNKNOWN_BLOCK_STATE",
   ENVELOPE_ALREADY_KNOWN = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_ALREADY_KNOWN",
   INVALID_BLOCK = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_INVALID_BLOCK",
   SLOT_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_SLOT_MISMATCH",
   BUILDER_INDEX_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BUILDER_INDEX_MISMATCH",
   BLOCK_HASH_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BLOCK_HASH_MISMATCH",
   INVALID_SIGNATURE = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_INVALID_SIGNATURE",
-  CACHE_FAIL = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_CACHE_FAIL",
+  PAYLOAD_ENVELOPE_INPUT_MISSING = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_PAYLOAD_ENVELOPE_INPUT_MISSING",
 }
 export type ExecutionPayloadEnvelopeErrorType =
   | {code: ExecutionPayloadEnvelopeErrorCode.BELONG_TO_FINALIZED_BLOCK; envelopeSlot: Slot; finalizedSlot: Slot}
   | {code: ExecutionPayloadEnvelopeErrorCode.BLOCK_ROOT_UNKNOWN; blockRoot: RootHex}
+  | {code: ExecutionPayloadEnvelopeErrorCode.PARENT_UNKNOWN; parentRoot: RootHex; slot: Slot}
+  | {code: ExecutionPayloadEnvelopeErrorCode.UNKNOWN_BLOCK_STATE; blockRoot: RootHex; slot: Slot}
   | {
       code: ExecutionPayloadEnvelopeErrorCode.ENVELOPE_ALREADY_KNOWN;
       blockRoot: RootHex;
@@ -33,6 +37,6 @@ export type ExecutionPayloadEnvelopeErrorType =
       bidBlockHash: RootHex | null;
     }
   | {code: ExecutionPayloadEnvelopeErrorCode.INVALID_SIGNATURE}
-  | {code: ExecutionPayloadEnvelopeErrorCode.CACHE_FAIL; blockRoot: RootHex};
+  | {code: ExecutionPayloadEnvelopeErrorCode.PAYLOAD_ENVELOPE_INPUT_MISSING; blockRoot: RootHex};
 
 export class ExecutionPayloadEnvelopeError extends GossipActionError<ExecutionPayloadEnvelopeErrorType> {}

package/src/chain/forkChoice/index.ts

@@ -158,10 +158,6 @@ export function initializeForkChoiceFromFinalizedState(
 
         dataAvailabilityStatus: DataAvailabilityStatus.PreData,
         payloadStatus: isForkPostGloas ? PayloadStatus.PENDING : PayloadStatus.FULL, // TODO GLOAS: Post-gloas how do we know if the checkpoint payload is FULL or EMPTY?
-        builderIndex: isForkPostGloas ? (state as CachedBeaconStateGloas).latestExecutionPayloadBid.builderIndex : null,
-        blockHashFromBid: isForkPostGloas
-          ? toRootHex((state as CachedBeaconStateGloas).latestExecutionPayloadBid.blockHash)
-          : null,
         parentBlockHash: isForkPostGloas ? toRootHex((state as CachedBeaconStateGloas).latestBlockHash) : null,
       },
       currentSlot
@@ -255,12 +251,6 @@ export function initializeForkChoiceFromUnfinalizedState(
 
     dataAvailabilityStatus: DataAvailabilityStatus.PreData,
     payloadStatus: isForkPostGloas ? PayloadStatus.PENDING : PayloadStatus.FULL, // TODO GLOAS: Post-gloas how do we know if the checkpoint payload is FULL or EMPTY?
-    builderIndex: isForkPostGloas
-      ? (unfinalizedState as CachedBeaconStateGloas).latestExecutionPayloadBid.builderIndex
-      : null,
-    blockHashFromBid: isForkPostGloas
-      ? toRootHex((unfinalizedState as CachedBeaconStateGloas).latestExecutionPayloadBid.blockHash)
-      : null,
     parentBlockHash: isForkPostGloas ? toRootHex((unfinalizedState as CachedBeaconStateGloas).latestBlockHash) : null,
   };