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

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

package/src/chain/interface.ts

@@ -32,7 +32,7 @@ import {IArchiveStore} from "./archiveStore/interface.js";
 import {CheckpointBalancesCache} from "./balancesCache.js";
 import {BeaconProposerCache, ProposerPreparationData} from "./beaconProposerCache.js";
 import {IBlockInput} from "./blocks/blockInput/index.js";
-import {ImportBlockOpts} from "./blocks/types.js";
+import {ImportBlockOpts, ImportPayloadOpts} from "./blocks/types.js";
 import {IBlsVerifier} from "./bls/index.js";
 import {ColumnReconstructionTracker} from "./ColumnReconstructionTracker.js";
 import {ChainEventEmitter} from "./emitter.js";
@@ -58,7 +58,6 @@ import {
   SeenBlockProposers,
   SeenContributionAndProof,
   SeenExecutionPayloadBids,
-  SeenExecutionPayloadEnvelopes,
   SeenPayloadAttesters,
   SeenSyncCommitteeMessages,
 } from "./seenCache/index.js";
@@ -66,6 +65,7 @@ import {SeenAggregatedAttestations} from "./seenCache/seenAggregateAndProof.js";
 import {SeenAttestationDatas} from "./seenCache/seenAttestationData.js";
 import {SeenBlockAttesters} from "./seenCache/seenBlockAttesters.js";
 import {SeenBlockInput} from "./seenCache/seenGossipBlockInput.js";
+import {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenCache/seenPayloadEnvelopeInput.js";
 import {ShufflingCache} from "./shufflingCache.js";
 import {ValidatorMonitor} from "./validatorMonitor.js";
 
@@ -128,13 +128,13 @@ export interface IBeaconChain {
   readonly seenAggregators: SeenAggregators;
   readonly seenPayloadAttesters: SeenPayloadAttesters;
   readonly seenAggregatedAttestations: SeenAggregatedAttestations;
-  readonly seenExecutionPayloadEnvelopes: SeenExecutionPayloadEnvelopes;
   readonly seenExecutionPayloadBids: SeenExecutionPayloadBids;
   readonly seenBlockProposers: SeenBlockProposers;
   readonly seenSyncCommitteeMessages: SeenSyncCommitteeMessages;
   readonly seenContributionAndProof: SeenContributionAndProof;
   readonly seenAttestationDatas: SeenAttestationDatas;
   readonly seenBlockInputCache: SeenBlockInput;
+  readonly seenPayloadEnvelopeInputCache: SeenPayloadEnvelopeInput;
   // Seen cache for liveness checks
   readonly seenBlockAttesters: SeenBlockAttesters;
 
@@ -242,6 +242,9 @@ export interface IBeaconChain {
   /** Process a chain of blocks until complete */
   processChainSegment(blocks: IBlockInput[], opts?: ImportBlockOpts): Promise<void>;
 
+  /** Process execution payload envelope: verify, import to fork choice, and persist to DB */
+  processExecutionPayload(payloadInput: PayloadEnvelopeInput, opts?: ImportPayloadOpts): Promise<void>;
+
   getStatus(): Status;
 
   recomputeForkChoiceHead(caller: ForkchoiceCaller): ProtoBlock;

package/src/chain/opPools/utils.ts

@@ -41,7 +41,7 @@ export function isValidBlsToExecutionChangeForBlockInclusion(
   state: CachedBeaconStateAllForks,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange
 ): boolean {
-  // For each condition from https://github.com/ethereum/consensus-specs/blob/dev/specs/capella/beacon-chain.md#new-process_bls_to_execution_change
+  // For each condition from https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/capella/beacon-chain.md#new-process_bls_to_execution_change
   //
   // 1. assert address_change.validator_index < len(state.validators):
   //    If valid before will always be valid in the future, no need to check

package/src/chain/produceBlock/computeNewStateRoot.ts

@@ -73,7 +73,12 @@ export function computeEnvelopeStateRoot(
   };
 
   const processEnvelopeTimer = metrics?.blockPayload.executionPayloadEnvelopeProcessingTime.startTimer();
-  const postEnvelopeState = processExecutionPayloadEnvelope(postBlockState, signedEnvelope, false, {
+  const postEnvelopeState = processExecutionPayloadEnvelope(postBlockState, signedEnvelope, {
+    // Signature is zero-ed (G2_POINT_AT_INFINITY), skip verification
+    verifySignature: false,
+    // State root is being computed here, the envelope doesn't have it yet
+    verifyStateRoot: false,
+    // Preserve cache in source state, since the resulting state is not added to the state cache
     dontTransferCache: true,
   });
   processEnvelopeTimer?.();

package/src/chain/produceBlock/produceBlockBody.ts

@@ -441,7 +441,7 @@ export async function produceBlockBody<T extends BlockType>(
           parentBlockRoot: toRootHex(parentBlockRoot),
           feeRecipient,
         });
-        // https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/validator.md#constructing-the-beaconblockbody
+        // https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/deneb/validator.md#constructing-the-beaconblockbody
         const prepareRes = await prepareExecutionPayload(
           this,
           this.logger,

package/src/chain/regen/interface.ts

@@ -9,8 +9,10 @@ export enum RegenCaller {
   processBlock = "processBlock",
   produceBlock = "produceBlock",
   validateGossipBlock = "validateGossipBlock",
+  validateGossipPayloadEnvelope = "validateGossipPayloadEnvelope",
   validateGossipBlob = "validateGossipBlob",
   validateGossipDataColumn = "validateGossipDataColumn",
+  validateGossipExecutionPayloadEnvelope = "validateGossipExecutionPayloadEnvelope",
   precomputeEpoch = "precomputeEpoch",
   predictProposerHead = "predictProposerHead",
   produceAttestationData = "produceAttestationData",

package/src/chain/seenCache/index.ts

@@ -3,5 +3,5 @@ export {SeenBlockProposers} from "./seenBlockProposers.js";
 export {SeenSyncCommitteeMessages} from "./seenCommittee.js";
 export {SeenContributionAndProof} from "./seenCommitteeContribution.js";
 export {SeenExecutionPayloadBids} from "./seenExecutionPayloadBids.js";
-export {SeenExecutionPayloadEnvelopes} from "./seenExecutionPayloadEnvelope.js";
 export {SeenBlockInput} from "./seenGossipBlockInput.js";
+export {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenPayloadEnvelopeInput.js";

package/src/chain/seenCache/seenGossipBlockInput.ts

@@ -180,7 +180,7 @@ export class SeenBlockInput {
       blockInput = this.blockInputs.get(parentRootHex ?? "");
       parentRootHex = blockInput?.parentRootHex;
     }
-    this.logger?.debug(`BlockInputCache.prune deleted ${deletedCount} cached BlockInputs`);
+    this.logger?.debug("BlockInputCache.prune deleted cached BlockInputs", {deletedCount});
     this.pruneToMaxSize();
   }
 
@@ -193,7 +193,7 @@ export class SeenBlockInput {
         this.evictBlockInput(blockInput);
       }
     }
-    this.logger?.debug(`BlockInputCache.onFinalized deleted ${deletedCount} cached BlockInputs`);
+    this.logger?.debug("BlockInputCache.onFinalized deleted cached BlockInputs", {deletedCount});
     this.pruneToMaxSize();
   };
 

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -0,0 +1,106 @@
+import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
+import {RootHex} from "@lodestar/types";
+import {Logger} from "@lodestar/utils";
+import {Metrics} from "../../metrics/metrics.js";
+import {SerializedCache} from "../../util/serializedCache.js";
+import {CreateFromBlockProps, PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
+import {ChainEvent, ChainEventEmitter} from "../emitter.js";
+
+export type {PayloadEnvelopeInputState} from "../blocks/payloadEnvelopeInput/index.js";
+export {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
+
+export type SeenPayloadEnvelopeInputModules = {
+  chainEvents: ChainEventEmitter;
+  signal: AbortSignal;
+  serializedCache: SerializedCache;
+  metrics: Metrics | null;
+  logger?: Logger;
+};
+
+/**
+ * Cache for tracking PayloadEnvelopeInput instances, keyed by beacon block root.
+ *
+ * Created during block import when a block is processed.
+ * Pruned on finalization and after payload is written to DB.
+ */
+export class SeenPayloadEnvelopeInput {
+  private readonly chainEvents: ChainEventEmitter;
+  private readonly signal: AbortSignal;
+  private readonly serializedCache: SerializedCache;
+  private readonly metrics: Metrics | null;
+  private readonly logger?: Logger;
+  private payloadInputs = new Map<RootHex, PayloadEnvelopeInput>();
+
+  constructor({chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+    this.chainEvents = chainEvents;
+    this.signal = signal;
+    this.serializedCache = serializedCache;
+    this.metrics = metrics;
+    this.logger = logger;
+
+    if (metrics) {
+      metrics.seenCache.payloadEnvelopeInput.count.addCollect(() => {
+        metrics.seenCache.payloadEnvelopeInput.count.set(this.payloadInputs.size);
+        metrics.seenCache.payloadEnvelopeInput.serializedObjectRefs.set(
+          Array.from(this.payloadInputs.values()).reduce(
+            (count, payloadInput) => count + payloadInput.getSerializedCacheKeys().length,
+            0
+          )
+        );
+      });
+    }
+
+    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.onFinalized);
+    this.signal.addEventListener("abort", () => {
+      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.onFinalized);
+    });
+  }
+
+  private onFinalized = (checkpoint: CheckpointWithHex): void => {
+    // Prune all entries with slot < finalized slot
+    const finalizedSlot = computeStartSlotAtEpoch(checkpoint.epoch);
+    let deletedCount = 0;
+    for (const [, input] of this.payloadInputs) {
+      if (input.slot < finalizedSlot) {
+        this.evictPayloadInput(input);
+        deletedCount++;
+      }
+    }
+    this.logger?.debug("SeenPayloadEnvelopeInput.onFinalized deleted cached entries", {deletedCount});
+  };
+
+  add(props: CreateFromBlockProps): PayloadEnvelopeInput {
+    if (this.payloadInputs.has(props.blockRootHex)) {
+      throw new Error(`PayloadEnvelopeInput already exists for block ${props.blockRootHex}`);
+    }
+    const input = PayloadEnvelopeInput.createFromBlock(props);
+    this.payloadInputs.set(props.blockRootHex, input);
+    this.metrics?.seenCache.payloadEnvelopeInput.created.inc();
+    return input;
+  }
+
+  get(blockRootHex: RootHex): PayloadEnvelopeInput | undefined {
+    return this.payloadInputs.get(blockRootHex);
+  }
+
+  has(blockRootHex: RootHex): boolean {
+    return this.payloadInputs.has(blockRootHex);
+  }
+
+  prune(blockRootHex: RootHex): void {
+    const payloadInput = this.payloadInputs.get(blockRootHex);
+    if (payloadInput) {
+      this.evictPayloadInput(payloadInput);
+    }
+  }
+
+  size(): number {
+    return this.payloadInputs.size;
+  }
+
+  private evictPayloadInput(payloadInput: PayloadEnvelopeInput): void {
+    this.serializedCache.delete(payloadInput.getSerializedCacheKeys());
+    this.payloadInputs.delete(payloadInput.blockRootHex);
+  }
+}

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -1,14 +1,15 @@
-import {PublicKey} from "@chainsafe/blst";
+import {PayloadStatus} from "@lodestar/fork-choice";
 import {
+  BeaconStateView,
   CachedBeaconStateGloas,
   computeStartSlotAtEpoch,
-  createSingleSignatureSetFromComponents,
-  getExecutionPayloadEnvelopeSigningRoot,
+  getExecutionPayloadEnvelopeSignatureSet,
 } from "@lodestar/state-transition";
 import {gloas} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {ExecutionPayloadEnvelopeError, ExecutionPayloadEnvelopeErrorCode, GossipAction} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
+import {RegenCaller} from "../regen/index.js";
 
 export async function validateApiExecutionPayloadEnvelope(
   chain: IBeaconChain,
@@ -47,7 +48,9 @@ async function validateExecutionPayloadEnvelope(
 
   // [IGNORE] The node has not seen another valid
   // `SignedExecutionPayloadEnvelope` for this block root from this builder.
-  if (chain.seenExecutionPayloadEnvelopes.isKnown(blockRootHex)) {
+  const envelopeBlock = chain.forkChoice.getBlockHex(blockRootHex, PayloadStatus.FULL);
+  const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
+  if (envelopeBlock || payloadInput?.hasPayloadEnvelope()) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
       code: ExecutionPayloadEnvelopeErrorCode.ENVELOPE_ALREADY_KNOWN,
       blockRoot: blockRootHex,
@@ -55,6 +58,14 @@ async function validateExecutionPayloadEnvelope(
     });
   }
 
+  if (!payloadInput) {
+    // PayloadEnvelopeInput should have been created during block import
+    throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
+      code: ExecutionPayloadEnvelopeErrorCode.PAYLOAD_ENVELOPE_INPUT_MISSING,
+      blockRoot: blockRootHex,
+    });
+  }
+
   // [IGNORE] The envelope is from a slot greater than or equal to the latest finalized slot -- i.e. validate that `envelope.slot >= compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)`
   const finalizedCheckpoint = chain.forkChoice.getFinalizedCheckpoint();
   const finalizedSlot = computeStartSlotAtEpoch(finalizedCheckpoint.epoch);
@@ -79,45 +90,47 @@ async function validateExecutionPayloadEnvelope(
     });
   }
 
-  if (block.builderIndex == null || block.blockHashFromBid == null) {
-    // This indicates this block is a pre-gloas block which is wrong
-    throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
-      code: ExecutionPayloadEnvelopeErrorCode.CACHE_FAIL,
-      blockRoot: blockRootHex,
-    });
-  }
-
   // [REJECT] `envelope.builder_index == bid.builder_index`
-  if (envelope.builderIndex !== block.builderIndex) {
+  if (envelope.builderIndex !== payloadInput.getBuilderIndex()) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
       code: ExecutionPayloadEnvelopeErrorCode.BUILDER_INDEX_MISMATCH,
       envelopeBuilderIndex: envelope.builderIndex,
-      bidBuilderIndex: block.builderIndex,
+      bidBuilderIndex: payloadInput.getBuilderIndex(),
     });
   }
 
   // [REJECT] `payload.block_hash == bid.block_hash`
-  if (toRootHex(payload.blockHash) !== block.blockHashFromBid) {
+  if (toRootHex(payload.blockHash) !== payloadInput.getBlockHashHex()) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
       code: ExecutionPayloadEnvelopeErrorCode.BLOCK_HASH_MISMATCH,
       envelopeBlockHash: toRootHex(payload.blockHash),
-      bidBlockHash: block.blockHashFromBid,
+      bidBlockHash: payloadInput.getBlockHashHex(),
     });
   }
 
-  // [REJECT] `signed_execution_payload_envelope.signature` is valid with respect to the builder's public key.
-  const state = chain.getHeadState() as CachedBeaconStateGloas;
-  const signatureSet = createSingleSignatureSetFromComponents(
-    PublicKey.fromBytes(state.builders.getReadonly(envelope.builderIndex).pubkey),
-    getExecutionPayloadEnvelopeSigningRoot(chain.config, envelope),
-    executionPayloadEnvelope.signature
+  // Get the post block state which is the pre-payload state to verify the builder's signature.
+  const blockState = await chain.regen
+    .getState(block.stateRoot, RegenCaller.validateGossipPayloadEnvelope)
+    .catch(() => {
+      throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
+        code: ExecutionPayloadEnvelopeErrorCode.UNKNOWN_BLOCK_STATE,
+        blockRoot: blockRootHex,
+        slot: envelope.slot,
+      });
+    });
+
+  const state = blockState as CachedBeaconStateGloas;
+  const signatureSet = getExecutionPayloadEnvelopeSignatureSet(
+    chain.config,
+    chain.pubkeyCache,
+    new BeaconStateView(state),
+    executionPayloadEnvelope,
+    payloadInput.proposerIndex
   );
 
-  if (!(await chain.bls.verifySignatureSets([signatureSet]))) {
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
       code: ExecutionPayloadEnvelopeErrorCode.INVALID_SIGNATURE,
     });
   }
-
-  chain.seenExecutionPayloadEnvelopes.add(blockRootHex, envelope.slot);
 }

package/src/chain/validation/lightClientFinalityUpdate.ts

@@ -6,7 +6,7 @@ import {LightClientError, LightClientErrorCode} from "../errors/lightClientError
 import {IBeaconChain} from "../interface.js";
 import {updateReceivedTooEarly} from "./lightClientOptimisticUpdate.js";
 
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/p2p-interface.md#light_client_finality_update
+// https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/altair/light-client/p2p-interface.md#light_client_finality_update
 export function validateLightClientFinalityUpdate(
   config: ChainForkConfig,
   chain: IBeaconChain,

package/src/chain/validation/lightClientOptimisticUpdate.ts

@@ -6,7 +6,7 @@ import {GossipAction} from "../errors/index.js";
 import {LightClientError, LightClientErrorCode} from "../errors/lightClientError.js";
 import {IBeaconChain} from "../interface.js";
 
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/p2p-interface.md#light_client_optimistic_update
+// https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/altair/light-client/p2p-interface.md#light_client_optimistic_update
 export function validateLightClientOptimisticUpdate(
   config: ChainForkConfig,
   chain: IBeaconChain,

package/src/chain/validatorMonitor.ts

@@ -23,6 +23,7 @@ import {
   ValidatorIndex,
   altair,
   deneb,
+  gloas,
 } from "@lodestar/types";
 import {LogData, LogHandler, LogLevel, Logger, MapDef, MapDefMax, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {GENESIS_SLOT} from "../constants/constants.js";
@@ -61,6 +62,11 @@ export type ValidatorMonitor = {
   ): void;
   registerBeaconBlock(src: OpSource, delaySec: Seconds, block: BeaconBlock): void;
   registerBlobSidecar(src: OpSource, seenTimestampSec: Seconds, blob: deneb.BlobSidecar): void;
+  registerExecutionPayloadEnvelope(
+    src: OpSource,
+    delaySec: Seconds,
+    envelope: gloas.SignedExecutionPayloadEnvelope
+  ): void;
   registerImportedBlock(block: BeaconBlock, data: {proposerBalanceDelta: number}): void;
   onPoolSubmitUnaggregatedAttestation(
     seenTimestampSec: number,
@@ -450,6 +456,10 @@ export function createValidatorMonitor(
       //TODO: freetheblobs
     },
 
+    registerExecutionPayloadEnvelope(_src, _delaySec, _envelope) {
+      // TODO GLOAS: implement execution payload envelope monitoring
+    },
+
     registerImportedBlock(block, {proposerBalanceDelta}) {
       const validator = validators.get(block.proposerIndex);
       if (validator) {
@@ -889,7 +899,7 @@ function renderAttestationSummary(
   summary: AttestationSummary | undefined,
   flags: ParticipationFlags
 ): string {
-  // Reference https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/beacon-chain.md#get_attestation_participation_flag_indices
+  // Reference https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/altair/beacon-chain.md#get_attestation_participation_flag_indices
   //
   // is_matching_source = data.source == justified_checkpoint
   // is_matching_target = is_matching_source and data.target.root == get_block_root(state, data.target.epoch)