@lodestar/beacon-node 1.43.0-dev.a140dd987e → 1.43.0-dev.a6d8600051

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

@@ -1,29 +1,118 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ssz} from "@lodestar/types";
+import {ProtoBlock} from "@lodestar/fork-choice";
+import {Slot, isGloasBeaconBlock, ssz} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
 import {BlockError, BlockErrorCode} from "../../errors/index.js";
 import {IBlockInput} from "../blockInput/types.js";
+import {PayloadEnvelopeInput} from "../payloadEnvelopeInput/payloadEnvelopeInput.js";
+
+export type OrphanedPayloadEnvelope = {
+  slot: Slot;
+  payloadEnvelopeInput: PayloadEnvelopeInput;
+};
+
+export type ChainSegmentResult = {warnings: OrphanedPayloadEnvelope[] | null};
 
 /**
- * Assert this chain segment of blocks is linear with slot numbers and hashes
+ * Assert this chain segment of blocks is linear with slot numbers and hashes,
+ * and that the provided envelopes are consistent with their respective blocks.
+ *
+ * Must be called after verifyBlocksSanityChecks so that parentBlock (from forkchoice)
+ * is available to seed the execution hash chain.
+ *
+ * For each block:
+ * - Verifies parent root + slot linearity
+ * - For gloas: verifies bid.parentBlockHash matches the tracked execution hash; if not, the
+ *   previous FULL envelope is treated as orphaned (segment continues as if previous slot was EMPTY)
+ * - If an envelope exists for this slot: verifies it references this block's root
+ * - Advances the tracked execution hash (FULL if envelope present, EMPTY if not)
  */
+export function assertLinearChainSegment(
+  config: ChainForkConfig,
+  blocks: IBlockInput[],
+  payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
+  parentBlock: ProtoBlock
+): ChainSegmentResult {
+  const warnings: OrphanedPayloadEnvelope[] = [];
 
-export function assertLinearChainSegment(config: ChainForkConfig, blocks: IBlockInput[]): void {
-  for (let i = 0; i < blocks.length - 1; i++) {
+  // Track the expected execution payload block hash through the segment.
+  // Starts from the known forkchoice parent's execution hash.
+  // - FULL variant (envelope present for slot): advances to envelope.payload.blockHash
+  // - EMPTY variant (no envelope for slot): execution hash is unchanged
+  // null only for pre-merge parents, which cannot precede gloas blocks.
+  let currentExecHash: string | null = parentBlock.executionPayloadBlockHash;
+  // Track the execution hash before the last FULL advancement so we can recover
+  // if the next block reveals that envelope was orphaned.
+  let prevExecHash: string | null = currentExecHash;
+  // The slot whose envelope last advanced currentExecHash (for warning context).
+  let lastFullSlot: Slot | null = null;
+
+  for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i].getBlock();
-    const child = blocks[i + 1].getBlock();
-    // If this block has a child in this chain segment, ensure that its parent root matches
-    // the root of this block.
-    if (
-      !ssz.Root.equals(
-        config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message),
-        child.message.parentRoot
-      )
-    ) {
-      throw new BlockError(block, {code: BlockErrorCode.NON_LINEAR_PARENT_ROOTS});
+    const slot = block.message.slot;
+
+    if (i > 0) {
+      const prevBlock = blocks[i - 1].getBlock();
+      // Ensure parent root matches the previous block's root
+      if (
+        !ssz.Root.equals(
+          config.getForkTypes(prevBlock.message.slot).BeaconBlock.hashTreeRoot(prevBlock.message),
+          block.message.parentRoot
+        )
+      ) {
+        throw new BlockError(block, {code: BlockErrorCode.NON_LINEAR_PARENT_ROOTS});
+      }
+      // Ensure slots are strictly increasing
+      if (slot <= prevBlock.message.slot) {
+        throw new BlockError(block, {code: BlockErrorCode.NON_LINEAR_SLOTS});
+      }
     }
-    // Ensure that the slots are strictly increasing throughout the chain segment.
-    if (child.message.slot <= block.message.slot) {
-      throw new BlockError(block, {code: BlockErrorCode.NON_LINEAR_SLOTS});
+
+    if (isGloasBeaconBlock(block.message) && currentExecHash !== null) {
+      // Verify the bid's parentBlockHash matches the tracked execution hash.
+      // This ensures the block was built on the correct FULL or EMPTY variant of its parent.
+      const bidParentHash = toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash);
+      if (bidParentHash !== currentExecHash) {
+        // Maybe the previous slot's FULL envelope was orphaned — try falling back.
+        // If even prevExecHash doesn't match, the segment is non-linear.
+        if (bidParentHash !== prevExecHash) {
+          throw new BlockError(block, {
+            code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+            parentRoot: toRootHex(block.message.parentRoot),
+            parentBlockHash: bidParentHash,
+          });
+        }
+        if (lastFullSlot !== null && payloadEnvelopes !== null) {
+          const orphanedInput = payloadEnvelopes.get(lastFullSlot);
+          if (orphanedInput != null) {
+            warnings.push({slot: lastFullSlot, payloadEnvelopeInput: orphanedInput});
+          }
+        }
+        currentExecHash = prevExecHash;
+      }
+
+      const payloadInput = payloadEnvelopes?.get(slot) ?? null;
+      const payloadEnvelope = payloadInput?.hasPayloadEnvelope() ? payloadInput.getPayloadEnvelope() : null;
+      if (payloadEnvelope !== null) {
+        // Verify the envelope references this block's root
+        const blockRoot = toRootHex(config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block.message));
+        const envelopeBlockRoot = toRootHex(payloadEnvelope.message.beaconBlockRoot);
+        if (blockRoot !== envelopeBlockRoot) {
+          throw new BlockError(block, {
+            code: BlockErrorCode.ENVELOPE_BLOCK_ROOT_MISMATCH,
+            envelopeBlockRoot,
+            blockRoot,
+          });
+        }
+
+        // FULL variant: save state before advancing, then advance
+        prevExecHash = currentExecHash;
+        lastFullSlot = slot;
+        currentExecHash = toRootHex(payloadEnvelope.message.payload.blockHash);
+      }
+      // EMPTY variant: currentExecHash unchanged
     }
   }
+
+  return {warnings: warnings.length > 0 ? warnings : null};
 }

package/src/chain/blocks/verifyBlock.ts

@@ -1,12 +1,14 @@
 import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
-import {ForkName, isForkPostFulu} from "@lodestar/params";
+import {ForkName, ForkSeq, isForkPostFulu} from "@lodestar/params";
 import {DataAvailabilityStatus, IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
-import {IndexedAttestation, deneb} from "@lodestar/types";
+import {IndexedAttestation, Slot, deneb} from "@lodestar/types";
+import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import type {BeaconChain} from "../chain.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {BlockProcessOpts} from "../options.js";
 import {RegenCaller} from "../regen/index.js";
 import {DAType, IBlockInput} from "./blockInput/index.js";
+import {PayloadEnvelopeInput} from "./payloadEnvelopeInput/payloadEnvelopeInput.js";
 import {ImportBlockOpts} from "./types.js";
 import {DENEB_BLOWFISH_BANNER} from "./utils/blowfishBanner.js";
 import {ELECTRA_GIRAFFE_BANNER} from "./utils/giraffeBanner.js";
@@ -16,6 +18,7 @@ import {verifyBlocksDataAvailability} from "./verifyBlocksDataAvailability.js";
 import {SegmentExecStatus, verifyBlocksExecutionPayload} from "./verifyBlocksExecutionPayloads.js";
 import {verifyBlocksSignatures} from "./verifyBlocksSignatures.js";
 import {verifyBlocksStateTransitionOnly} from "./verifyBlocksStateTransitionOnly.js";
+import {verifyPayloadsDataAvailability} from "./verifyPayloadsDataAvailability.js";
 
 /**
  * Verifies 1 or more blocks are fully valid; from a linear sequence of blocks.
@@ -32,12 +35,14 @@ export async function verifyBlocksInEpoch(
   this: BeaconChain,
   parentBlock: ProtoBlock,
   blockInputs: IBlockInput[],
+  payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
   opts: BlockProcessOpts & ImportBlockOpts
 ): Promise<{
   postStates: IBeaconStateView[];
   proposerBalanceDeltas: number[];
   segmentExecStatus: SegmentExecStatus;
-  dataAvailabilityStatuses: DataAvailabilityStatus[];
+  blockDAStatuses: DataAvailabilityStatus[];
+  payloadDAStatuses: Map<Slot, DataAvailabilityStatus>;
   indexedAttestationsByBlock: IndexedAttestation[][];
 }> {
   const blocks = blockInputs.map((blockInput) => blockInput.getBlock());
@@ -110,17 +115,59 @@ export async function verifyBlocksInEpoch(
       });
     }
 
+    // Pick the data-availability source by fork:
+    // - Pre-Gloas: blob/Fulu-column data lives in IBlockInput → verifyBlocksDataAvailability.
+    // - Post-Gloas: verifyPayloadsDataAvailability (payload-level DA, keyed by slot).
+    const daAvailabilityPromise: Promise<{
+      blockDAStatuses: DataAvailabilityStatus[];
+      payloadDAStatuses: Map<Slot, DataAvailabilityStatus>;
+      availableTime: number;
+    }> =
+      fork >= ForkSeq.gloas
+        ? (async () => {
+            const payloadInputsForDa: PayloadEnvelopeInput[] = [];
+            for (const input of blockInputs) {
+              const pi = payloadEnvelopes?.get(input.slot);
+              if (pi !== undefined) payloadInputsForDa.push(pi);
+            }
+            const {dataAvailabilityStatuses, availableTime} = await verifyPayloadsDataAvailability(
+              payloadInputsForDa,
+              abortController.signal
+            );
+            const payloadDAStatuses = new Map<Slot, DataAvailabilityStatus>();
+            for (let i = 0; i < payloadInputsForDa.length; i++) {
+              payloadDAStatuses.set(payloadInputsForDa[i].slot, dataAvailabilityStatuses[i]);
+            }
+            return {
+              // post-gloas, DataAvailabilityStatus is NotRequired for forkChoice.onBlock() ProtoBlock
+              blockDAStatuses: blockInputs.map(() => DataAvailabilityStatus.NotRequired),
+              payloadDAStatuses,
+              availableTime,
+            };
+          })()
+        : (async () => {
+            const {dataAvailabilityStatuses, availableTime} = await verifyBlocksDataAvailability(
+              blockInputs,
+              abortController.signal
+            );
+            return {
+              blockDAStatuses: dataAvailabilityStatuses,
+              payloadDAStatuses: new Map<Slot, DataAvailabilityStatus>(),
+              availableTime,
+            };
+          })();
+
     // batch all I/O operations to reduce overhead
     const [
       segmentExecStatus,
-      {dataAvailabilityStatuses, availableTime},
+      {blockDAStatuses, payloadDAStatuses, availableTime},
       {postStates, proposerBalanceDeltas, verifyStateTime},
       {verifySignaturesTime},
     ] = await Promise.all([
       verifyExecutionPayloadsPromise,
 
-      // data availability for the blobs
-      verifyBlocksDataAvailability(blockInputs, abortController.signal),
+      // data availability (fork-specific; see daAvailabilityPromise above)
+      daAvailabilityPromise,
 
       // Run state transition only
       // TODO: Ensure it yields to allow flushing to workers and engine API
@@ -149,6 +196,9 @@ export async function verifyBlocksInEpoch(
             opts
           )
         : Promise.resolve({verifySignaturesTime: Date.now()}),
+
+      // TODO GLOAS: can verify payload signatures in batch too
+      // maybe chain with the above verifyBlocksSignatures()
     ]);
 
     if (opts.verifyOnly !== true) {
@@ -200,7 +250,9 @@ export async function verifyBlocksInEpoch(
         blockInputs.length === 1 &&
         // gossip blocks have seenTimestampSec
         opts.seenTimestampSec !== undefined &&
+        // PreData (pre-deneb) and NoData (gloas) carry no blob data on the block — skip metric
         blockInputs[0].type !== DAType.PreData &&
+        blockInputs[0].type !== DAType.NoData &&
         executionStatuses[0] === ExecutionStatus.Valid
       ) {
         // Find the max time when the block was actually verified
@@ -209,8 +261,8 @@ export async function verifyBlocksInEpoch(
         this.metrics?.gossipBlock.receivedToFullyVerifiedTime.observe(recvTofullyVerifedTime);
 
         const verifiedToBlobsAvailabiltyTime = Math.max(availableTime - fullyVerifiedTime, 0) / 1000;
-        const block = blockInputs[0].getBlock() as deneb.SignedBeaconBlock;
-        const numBlobs = block.message.body.blobKzgCommitments.length;
+        const block = blockInputs[0].getBlock();
+        const numBlobs = getBlobKzgCommitments(blockInputs[0].forkName, block as deneb.SignedBeaconBlock).length;
 
         this.metrics?.gossipBlock.verifiedToBlobsAvailabiltyTime.observe({numBlobs}, verifiedToBlobsAvailabiltyTime);
         this.logger.verbose("Verified blockInput fully with blobs availability", {
@@ -229,7 +281,14 @@ export async function verifyBlocksInEpoch(
       );
     }
 
-    return {postStates, dataAvailabilityStatuses, proposerBalanceDeltas, segmentExecStatus, indexedAttestationsByBlock};
+    return {
+      postStates,
+      blockDAStatuses,
+      payloadDAStatuses,
+      proposerBalanceDeltas,
+      segmentExecStatus,
+      indexedAttestationsByBlock,
+    };
   } finally {
     abortController.abort();
   }

package/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -90,15 +90,24 @@ export function verifyBlocksSanityChecks(
     } else {
       // When importing a block segment, only the first NON-IGNORED block must be known to the fork-choice.
       const parentRoot = toRootHex(block.message.parentRoot);
-      parentBlock = isGloasBeaconBlock(block.message)
-        ? chain.forkChoice.getBlockHexAndBlockHash(
-            parentRoot,
-            toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash)
-          )
-        : chain.forkChoice.getBlockHexDefaultStatus(parentRoot);
-      if (!parentBlock) {
+      const parentBlockDefaultStatus = chain.forkChoice.getBlockHexDefaultStatus(parentRoot);
+      if (!parentBlockDefaultStatus) {
         throw new BlockError(block, {code: BlockErrorCode.PARENT_UNKNOWN, parentRoot});
       }
+
+      parentBlock = parentBlockDefaultStatus;
+      if (isGloasBeaconBlock(block.message)) {
+        const parentBlockHash = toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash);
+        const parentBlockWithPayload = chain.forkChoice.getBlockHexAndBlockHash(parentRoot, parentBlockHash);
+        if (!parentBlockWithPayload) {
+          throw new BlockError(block, {
+            code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+            parentRoot,
+            parentBlockHash,
+          });
+        }
+        parentBlock = parentBlockWithPayload;
+      }
       // Parent is known to the fork-choice
       parentBlockSlot = parentBlock.slot;
     }

package/src/chain/blocks/verifyExecutionPayloadEnvelope.ts

@@ -32,8 +32,8 @@ export function verifyExecutionPayloadEnvelope(
   const payload = envelope.payload;
 
   // Verify consistency with the beacon block.
-  // Compute header root on a copy of latestBlockHeader to avoid mutating state.
-  const headerValue = {...state.latestBlockHeader};
+  // Compute header root on a clone of latestBlockHeader to avoid mutating state.
+  const headerValue = ssz.phase0.BeaconBlockHeader.clone(state.latestBlockHeader);
   if (byteArrayEquals(headerValue.stateRoot, ssz.Root.defaultValue())) {
     headerValue.stateRoot = state.hashTreeRoot();
   }

package/src/chain/blocks/verifyPayloadsDataAvailability.ts

@@ -28,11 +28,14 @@ export async function verifyPayloadsDataAvailability(
   await Promise.all(promises);
 
   const availableTime = Math.max(0, Math.max(...payloadInputs.map((payloadInput) => payloadInput.getTimeComplete())));
-  const dataAvailabilityStatuses: DataAvailabilityStatus[] = payloadInputs.map((payloadInput) =>
-    payloadInput.getBlobKzgCommitments().length === 0
+  const dataAvailabilityStatuses: DataAvailabilityStatus[] = payloadInputs.map((payloadInput) => {
+    if (payloadInput.daOutOfRange) {
+      return DataAvailabilityStatus.OutOfRange;
+    }
+    return payloadInput.getBlobKzgCommitments().length === 0
       ? DataAvailabilityStatus.NotRequired
-      : DataAvailabilityStatus.Available
-  );
+      : DataAvailabilityStatus.Available;
+  });
 
   return {dataAvailabilityStatuses, availableTime};
 }

package/src/chain/chain.ts

@@ -106,6 +106,7 @@ import {
   SeenExecutionPayloadBids,
   SeenPayloadAttesters,
   SeenPayloadEnvelopeInput,
+  SeenProposerPreferences,
   SeenSyncCommitteeMessages,
 } from "./seenCache/index.js";
 import {SeenAggregatedAttestations} from "./seenCache/seenAggregateAndProof.js";
@@ -186,6 +187,7 @@ export class BeaconChain implements IBeaconChain {
   readonly seenPayloadAttesters = new SeenPayloadAttesters();
   readonly seenAggregatedAttestations: SeenAggregatedAttestations;
   readonly seenExecutionPayloadBids = new SeenExecutionPayloadBids();
+  readonly seenProposerPreferences = new SeenProposerPreferences();
   readonly seenBlockProposers = new SeenBlockProposers();
   readonly seenSyncCommitteeMessages = new SeenSyncCommitteeMessages();
   readonly seenContributionAndProof: SeenContributionAndProof;
@@ -334,6 +336,8 @@ export class BeaconChain implements IBeaconChain {
       logger,
     });
     this.seenPayloadEnvelopeInputCache = new SeenPayloadEnvelopeInput({
+      config,
+      clock,
       chainEvents: emitter,
       signal,
       serializedCache: this.serializedCache,
@@ -891,6 +895,10 @@ export class BeaconChain implements IBeaconChain {
     parentBlockSlot: Slot,
     parentBlockRootHex: RootHex
   ): Promise<electra.ExecutionRequests> {
+    // at the fork boundary, parent is pre-gloas
+    if (!isForkPostGloas(this.config.getForkName(parentBlockSlot))) {
+      return ssz.electra.ExecutionRequests.defaultValue();
+    }
     const envelope = await this.getExecutionPayloadEnvelope(parentBlockSlot, parentBlockRootHex);
     if (envelope === null) {
       throw Error(`Parent execution payload envelope not found slot=${parentBlockSlot}, root=${parentBlockRootHex}`);
@@ -1094,11 +1102,15 @@ export class BeaconChain implements IBeaconChain {
   }
 
   async processBlock(block: IBlockInput, opts?: ImportBlockOpts): Promise<void> {
-    return this.blockProcessor.processBlocksJob([block], opts);
+    return this.blockProcessor.processBlocksJob([block], null, opts);
   }
 
-  async processChainSegment(blocks: IBlockInput[], opts?: ImportBlockOpts): Promise<void> {
-    return this.blockProcessor.processBlocksJob(blocks, opts);
+  async processChainSegment(
+    blocks: IBlockInput[],
+    payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
+    opts?: ImportBlockOpts
+  ): Promise<void> {
+    await this.blockProcessor.processBlocksJob(blocks, payloadEnvelopes, opts);
   }
 
   async processExecutionPayload(payloadInput: PayloadEnvelopeInput, opts?: ImportPayloadOpts): Promise<void> {
@@ -1429,6 +1441,7 @@ export class BeaconChain implements IBeaconChain {
     this.payloadAttestationPool.prune(slot);
     this.executionPayloadBidPool.prune(slot);
     this.seenExecutionPayloadBids.prune(slot);
+    this.seenProposerPreferences.prune(slot);
     this.seenAttestationDatas.onSlot(slot);
     this.reprocessController.onSlot(slot);
 

package/src/chain/errors/blockError.ts

@@ -74,6 +74,8 @@ export enum BlockErrorCode {
   PARENT_EXECUTION_INVALID = "BLOCK_ERROR_PARENT_EXECUTION_INVALID",
   /** The block's parent execution payload (defined by bid.parent_block_hash) has not been seen */
   PARENT_PAYLOAD_UNKNOWN = "BLOCK_ERROR_PARENT_PAYLOAD_UNKNOWN",
+  /** An execution payload envelope in the chain segment references a block root that does not match its slot's block */
+  ENVELOPE_BLOCK_ROOT_MISMATCH = "BLOCK_ERROR_ENVELOPE_BLOCK_ROOT_MISMATCH",
 }
 
 type ExecutionErrorStatus = Exclude<
@@ -107,6 +109,7 @@ export type BlockErrorType =
   | {code: BlockErrorCode.NOT_LATER_THAN_PARENT; parentSlot: Slot; slot: Slot}
   | {code: BlockErrorCode.NON_LINEAR_PARENT_ROOTS}
   | {code: BlockErrorCode.NON_LINEAR_SLOTS}
+  | {code: BlockErrorCode.ENVELOPE_BLOCK_ROOT_MISMATCH; envelopeBlockRoot: RootHex; blockRoot: RootHex}
   | {code: BlockErrorCode.PER_BLOCK_PROCESSING_ERROR; error: Error}
   | {code: BlockErrorCode.BEACON_CHAIN_ERROR; error: Error}
   | {code: BlockErrorCode.KNOWN_BAD_BLOCK}
@@ -120,7 +123,7 @@ export type BlockErrorType =
   | {code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS; blobKzgCommitmentsLen: number; commitmentLimit: number}
   | {code: BlockErrorCode.BID_PARENT_ROOT_MISMATCH; bidParentRoot: RootHex; blockParentRoot: RootHex}
   | {code: BlockErrorCode.PARENT_EXECUTION_INVALID; parentRoot: RootHex}
-  | {code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN; parentBlockHash: RootHex};
+  | {code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN; parentRoot: RootHex; parentBlockHash: RootHex};
 
 export class BlockGossipError extends GossipActionError<BlockErrorType> {}
 

package/src/chain/errors/index.ts

@@ -8,6 +8,7 @@ export * from "./executionPayloadBid.js";
 export * from "./executionPayloadEnvelope.js";
 export * from "./gossipValidation.js";
 export * from "./payloadAttestation.js";
+export * from "./proposerPreferences.js";
 export * from "./proposerSlashingError.js";
 export * from "./syncCommitteeError.js";
 export * from "./voluntaryExitError.js";

package/src/chain/errors/proposerPreferences.ts

@@ -0,0 +1,39 @@
+import {Slot, ValidatorIndex} from "@lodestar/types";
+import {GossipActionError} from "./gossipValidation.js";
+
+export enum ProposerPreferencesErrorCode {
+  INVALID_EPOCH = "PROPOSER_PREFERENCES_ERROR_INVALID_EPOCH",
+  PROPOSAL_SLOT_PASSED = "PROPOSER_PREFERENCES_ERROR_PROPOSAL_SLOT_PASSED",
+  INVALID_PROPOSER = "PROPOSER_PREFERENCES_ERROR_INVALID_PROPOSER",
+  ALREADY_KNOWN = "PROPOSER_PREFERENCES_ERROR_ALREADY_KNOWN",
+  INVALID_SIGNATURE = "PROPOSER_PREFERENCES_ERROR_INVALID_SIGNATURE",
+}
+
+export type ProposerPreferencesErrorType =
+  | {
+      code: ProposerPreferencesErrorCode.INVALID_EPOCH;
+      proposalSlot: Slot;
+      currentEpoch: number;
+    }
+  | {
+      code: ProposerPreferencesErrorCode.PROPOSAL_SLOT_PASSED;
+      proposalSlot: Slot;
+      currentSlot: Slot;
+    }
+  | {
+      code: ProposerPreferencesErrorCode.INVALID_PROPOSER;
+      proposalSlot: Slot;
+      validatorIndex: ValidatorIndex;
+    }
+  | {
+      code: ProposerPreferencesErrorCode.ALREADY_KNOWN;
+      proposalSlot: Slot;
+      validatorIndex: ValidatorIndex;
+    }
+  | {
+      code: ProposerPreferencesErrorCode.INVALID_SIGNATURE;
+      proposalSlot: Slot;
+      validatorIndex: ValidatorIndex;
+    };
+
+export class ProposerPreferencesError extends GossipActionError<ProposerPreferencesErrorType> {}

package/src/chain/interface.ts

@@ -61,6 +61,7 @@ import {
   SeenContributionAndProof,
   SeenExecutionPayloadBids,
   SeenPayloadAttesters,
+  SeenProposerPreferences,
   SeenSyncCommitteeMessages,
 } from "./seenCache/index.js";
 import {SeenAggregatedAttestations} from "./seenCache/seenAggregateAndProof.js";
@@ -131,6 +132,7 @@ export interface IBeaconChain {
   readonly seenPayloadAttesters: SeenPayloadAttesters;
   readonly seenAggregatedAttestations: SeenAggregatedAttestations;
   readonly seenExecutionPayloadBids: SeenExecutionPayloadBids;
+  readonly seenProposerPreferences: SeenProposerPreferences;
   readonly seenBlockProposers: SeenBlockProposers;
   readonly seenSyncCommitteeMessages: SeenSyncCommitteeMessages;
   readonly seenContributionAndProof: SeenContributionAndProof;
@@ -250,7 +252,11 @@ export interface IBeaconChain {
   /** Process a block until complete */
   processBlock(block: IBlockInput, opts?: ImportBlockOpts): Promise<void>;
   /** Process a chain of blocks until complete */
-  processChainSegment(blocks: IBlockInput[], opts?: ImportBlockOpts): Promise<void>;
+  processChainSegment(
+    blocks: IBlockInput[],
+    payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
+    opts?: ImportBlockOpts
+  ): Promise<void>;
 
   /** Process execution payload envelope: verify, import to fork choice, and persist to DB */
   processExecutionPayload(payloadInput: PayloadEnvelopeInput, opts?: ImportPayloadOpts): Promise<void>;

package/src/chain/opPools/payloadAttestationPool.ts

@@ -1,7 +1,7 @@
 import {Signature, aggregateSignatures} from "@chainsafe/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
-import {MAX_COMMITTEES_PER_SLOT, PTC_SIZE} from "@lodestar/params";
+import {MAX_COMMITTEES_PER_SLOT, MAX_PAYLOAD_ATTESTATIONS, PTC_SIZE} from "@lodestar/params";
 import {RootHex, Slot, gloas} from "@lodestar/types";
 import {MapDef, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
@@ -95,13 +95,9 @@ export class PayloadAttestationPool {
 
   /**
    * Get payload attestations to be included in a block.
-   * Pick the top `maxAttestation` number of attestations with the most votes
+   * Pick the top `MAX_PAYLOAD_ATTESTATIONS` aggregates with the most votes.
    */
-  getPayloadAttestationsForBlock(
-    beaconBlockRoot: BlockRootHex,
-    slot: Slot,
-    maxAttestation: number
-  ): gloas.PayloadAttestation[] {
+  getPayloadAttestationsForBlock(beaconBlockRoot: BlockRootHex, slot: Slot): gloas.PayloadAttestation[] {
     const aggregateByDataRootByBlockRoot = this.aggregateByDataRootByBlockRootBySlot.get(slot);
 
     if (!aggregateByDataRootByBlockRoot) {
@@ -119,7 +115,32 @@ export class PayloadAttestationPool {
     return Array.from(aggregateByDataRoot.values())
       .slice()
       .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
-      .slice(0, maxAttestation)
+      .slice(0, MAX_PAYLOAD_ATTESTATIONS)
+      .map(fastToPayloadAttestation);
+  }
+
+  getAll(slot?: Slot): gloas.PayloadAttestation[] {
+    const aggregates: AggregateFast[] = [];
+
+    const addAggregates = (aggregateByDataRootByBlockRoot: Map<BlockRootHex, Map<DataRootHex, AggregateFast>>) => {
+      for (const aggregateByDataRoot of aggregateByDataRootByBlockRoot.values()) {
+        aggregates.push(...aggregateByDataRoot.values());
+      }
+    };
+
+    if (slot !== undefined) {
+      const aggregateByDataRootByBlockRoot = this.aggregateByDataRootByBlockRootBySlot.get(slot);
+      if (aggregateByDataRootByBlockRoot) {
+        addAggregates(aggregateByDataRootByBlockRoot);
+      }
+    } else {
+      for (const aggregateByDataRootByBlockRoot of this.aggregateByDataRootByBlockRootBySlot.values()) {
+        addAggregates(aggregateByDataRootByBlockRoot);
+      }
+    }
+
+    return aggregates
+      .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
       .map(fastToPayloadAttestation);
   }