@lodestar/beacon-node 1.43.0-dev.4fb05c546d → 1.43.0-dev.549a5b8115

package/src/chain/produceBlock/produceBlockBody.ts

@@ -46,9 +46,10 @@ import {
   electra,
   fulu,
   gloas,
+  ssz,
 } from "@lodestar/types";
 import {Logger, byteArrayEquals, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
-import {ZERO_HASH_HEX} from "../../constants/index.js";
+import {ZERO_HASH, ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../execution/engine/utils.js";
 import {
   IExecutionBuilder,
@@ -213,9 +214,19 @@ export async function produceBlockBody<T extends BlockType>(
     });
 
     // Get execution payload from EL
-    const parentBlockHash = this.forkChoice.shouldExtendPayload(toRootHex(parentBlockRoot))
+    const isExtendingPayload = this.forkChoice.shouldExtendPayload(toRootHex(parentBlockRoot));
+    let parentBlockHash = isExtendingPayload
       ? currentState.latestExecutionPayloadBid.blockHash
       : currentState.latestExecutionPayloadBid.parentBlockHash;
+    // At gloas genesis the committed bid has no prior EL block to reference
+    // (`bid.parentBlockHash` is zero). Fall back to `bid.blockHash` (= eth1 genesis hash) so the
+    // FCU to the EL carries a valid head. Post-genesis bids always reference a non-zero parent.
+    if (isStatePostGloas(currentState) && byteArrayEquals(parentBlockHash, ZERO_HASH)) {
+      parentBlockHash = currentState.latestExecutionPayloadBid.blockHash;
+    }
+    const parentExecutionRequests = isExtendingPayload
+      ? await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot)
+      : ssz.electra.ExecutionRequests.defaultValue();
     const prepareRes = await prepareExecutionPayload(
       this,
       this.logger,
@@ -225,7 +236,8 @@ export async function produceBlockBody<T extends BlockType>(
       safeBlockHash,
       finalizedBlockHash ?? ZERO_HASH_HEX,
       currentState,
-      feeRecipient
+      feeRecipient,
+      parentExecutionRequests
     );
 
     const {prepType, payloadId} = prepareRes;
@@ -269,6 +281,7 @@ export async function produceBlockBody<T extends BlockType>(
       value: 0,
       executionPayment: 0,
       blobKzgCommitments: blobsBundle.commitments,
+      executionRequestsRoot: ssz.electra.ExecutionRequests.hashTreeRoot(executionRequests),
     };
     const signedBid: gloas.SignedExecutionPayloadBid = {
       message: bid,
@@ -278,8 +291,11 @@ export async function produceBlockBody<T extends BlockType>(
     const commonBlockBody = await commonBlockBodyPromise;
     const gloasBody = Object.assign({}, commonBlockBody) as gloas.BeaconBlockBody;
     gloasBody.signedExecutionPayloadBid = signedBid;
-    // TODO GLOAS: Get payload attestations from pool for previous slot
-    gloasBody.payloadAttestations = [];
+    gloasBody.payloadAttestations = this.payloadAttestationPool.getPayloadAttestationsForBlock(
+      parentBlock.blockRoot,
+      blockSlot - 1
+    );
+    gloasBody.parentExecutionRequests = parentExecutionRequests;
     blockBody = gloasBody as AssembledBodyType<T>;
 
     // Store execution payload data required to construct execution payload envelope later
@@ -616,7 +632,8 @@ export async function prepareExecutionPayload(
   safeBlockHash: RootHex,
   finalizedBlockHash: RootHex,
   state: IBeaconStateViewBellatrix,
-  suggestedFeeRecipient: string
+  suggestedFeeRecipient: string,
+  parentExecutionRequests?: electra.ExecutionRequests
 ): Promise<{prepType: PayloadPreparationType; payloadId: PayloadId}> {
   const timestamp = computeTimeAtSlot(chain.config, state.slot, state.genesisTime);
   const prevRandao = state.getRandaoMix(state.epoch);
@@ -653,6 +670,7 @@ export async function prepareExecutionPayload(
       parentBlockRoot,
       parentBlockHash,
       feeRecipient: suggestedFeeRecipient,
+      parentExecutionRequests,
     });
 
     payloadId = await chain.executionEngine.notifyForkchoiceUpdate(
@@ -711,12 +729,14 @@ export function getPayloadAttributesForSSE(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
+    parentExecutionRequests,
   }: {
     prepareState: IBeaconStateViewBellatrix;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     parentBlockHash: Bytes32;
     feeRecipient: string;
+    parentExecutionRequests?: electra.ExecutionRequests;
   }
 ): SSEPayloadAttributes {
   const payloadAttributes = preparePayloadAttributes(fork, chain, {
@@ -725,6 +745,7 @@ export function getPayloadAttributesForSSE(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
+    parentExecutionRequests,
   });
 
   let parentBlockNumber: number;
@@ -763,12 +784,14 @@ function preparePayloadAttributes(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
+    parentExecutionRequests,
   }: {
     prepareState: IBeaconStateViewBellatrix;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     parentBlockHash: Bytes32;
     feeRecipient: string;
+    parentExecutionRequests?: electra.ExecutionRequests;
   }
 ): SSEPayloadAttributes["payloadAttributes"] {
   const timestamp = computeTimeAtSlot(chain.config, prepareSlot, prepareState.genesisTime);
@@ -786,13 +809,20 @@ function preparePayloadAttributes(
 
     if (isStatePostGloas(prepareState)) {
       const isExtendingPayload = byteArrayEquals(parentBlockHash, prepareState.latestExecutionPayloadBid.blockHash);
-      // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
-      // already deducted from CL balances but never credited on the EL (the envelope
-      // was not delivered). The next payload must carry those same withdrawals to
-      // restore CL/EL consistency, otherwise validators permanently lose that balance.
-      (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals = isExtendingPayload
-        ? prepareState.getExpectedWithdrawals().expectedWithdrawals
-        : prepareState.payloadExpectedWithdrawals;
+      if (isExtendingPayload) {
+        if (parentExecutionRequests === undefined) {
+          throw new Error("parentExecutionRequests required when extending full parent");
+        }
+        (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+          prepareState.getExpectedWithdrawalsForFullParent(parentExecutionRequests);
+      } else {
+        // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
+        // already deducted from CL balances but never credited on the EL (the envelope
+        // was not delivered). The next payload must carry those same withdrawals to
+        // restore CL/EL consistency, otherwise validators permanently lose that balance.
+        (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+          prepareState.payloadExpectedWithdrawals;
+      }
     } else {
       // withdrawals logic is now fork aware as it changes on electra fork post capella
       (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
@@ -804,6 +834,10 @@ function preparePayloadAttributes(
     (payloadAttributes as deneb.SSEPayloadAttributes["payloadAttributes"]).parentBeaconBlockRoot = parentBlockRoot;
   }
 
+  if (ForkSeq[fork] >= ForkSeq.gloas) {
+    (payloadAttributes as gloas.SSEPayloadAttributes["payloadAttributes"]).slotNumber = prepareSlot;
+  }
+
   return payloadAttributes;
 }
 

package/src/chain/regen/interface.ts

@@ -21,6 +21,7 @@ export enum RegenCaller {
   validateGossipAttestation = "validateGossipAttestation",
   validateGossipVoluntaryExit = "validateGossipVoluntaryExit",
   validateGossipExecutionPayloadBid = "validateGossipExecutionPayloadBid",
+  validateGossipProposerPreferences = "validateGossipProposerPreferences",
   onForkChoiceFinalized = "onForkChoiceFinalized",
   restApi = "restApi",
 }

package/src/chain/seenCache/index.ts

@@ -5,3 +5,4 @@ export {SeenContributionAndProof} from "./seenCommitteeContribution.js";
 export {SeenExecutionPayloadBids} from "./seenExecutionPayloadBids.js";
 export {SeenBlockInput} from "./seenGossipBlockInput.js";
 export {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenPayloadEnvelopeInput.js";
+export {SeenProposerPreferences} from "./seenProposerPreferences.js";

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -1,9 +1,12 @@
+import {ChainForkConfig} from "@lodestar/config";
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {RootHex} from "@lodestar/types";
+import {RootHex, Slot} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
+import {IClock} from "../../util/clock.js";
 import {SerializedCache} from "../../util/serializedCache.js";
+import {isDaOutOfRange} from "../blocks/blockInput/index.js";
 import {CreateFromBlockProps, PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 import {ChainEvent, ChainEventEmitter} from "../emitter.js";
 
@@ -11,6 +14,8 @@ export type {PayloadEnvelopeInputState} from "../blocks/payloadEnvelopeInput/ind
 export {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 
 export type SeenPayloadEnvelopeInputModules = {
+  config: ChainForkConfig;
+  clock: IClock;
   chainEvents: ChainEventEmitter;
   signal: AbortSignal;
   serializedCache: SerializedCache;
@@ -21,10 +26,19 @@ export type SeenPayloadEnvelopeInputModules = {
 /**
  * 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.
+ * Created during block import when a block is processed. Two pruning paths:
+ *   - `prepareNextSlot` calls `pruneBelow(headParentSlot)` every slot once the head we'll build
+ *     on is known.
+ *   - `onFinalized` calls `pruneBelow(finalizedSlot)` on every finalization for bulk cleanup.
+ *
+ * Steady state (linear chain, healthy progression): the cache holds ~2 entries — the head
+ * (parent for next-slot production) and its parent (proposer-boost-reorg fallback). It can
+ * transiently hold more during forks, range-sync bursts, or when `prepareNextSlot` skips
+ * ticks; subsequent ticks settle it back.
  */
 export class SeenPayloadEnvelopeInput {
+  private readonly config: ChainForkConfig;
+  private readonly clock: IClock;
   private readonly chainEvents: ChainEventEmitter;
   private readonly signal: AbortSignal;
   private readonly serializedCache: SerializedCache;
@@ -32,7 +46,9 @@ export class SeenPayloadEnvelopeInput {
   private readonly logger?: Logger;
   private payloadInputs = new Map<RootHex, PayloadEnvelopeInput>();
 
-  constructor({chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+  constructor({config, clock, chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+    this.config = config;
+    this.clock = clock;
     this.chainEvents = chainEvents;
     this.signal = signal;
     this.serializedCache = serializedCache;
@@ -58,23 +74,15 @@ export class SeenPayloadEnvelopeInput {
   }
 
   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});
+    this.pruneBelow(computeStartSlotAtEpoch(checkpoint.epoch));
   };
 
-  add(props: CreateFromBlockProps): PayloadEnvelopeInput {
+  add(props: Omit<CreateFromBlockProps, "daOutOfRange">): PayloadEnvelopeInput {
     if (this.payloadInputs.has(props.blockRootHex)) {
       throw new Error(`PayloadEnvelopeInput already exists for block ${props.blockRootHex}`);
     }
-    const input = PayloadEnvelopeInput.createFromBlock(props);
+    const daOutOfRange = isDaOutOfRange(this.config, props.forkName, props.block.message.slot, this.clock.currentEpoch);
+    const input = PayloadEnvelopeInput.createFromBlock({...props, daOutOfRange});
     this.payloadInputs.set(props.blockRootHex, input);
     this.metrics?.seenCache.payloadEnvelopeInput.created.inc();
     return input;
@@ -88,17 +96,21 @@ export class SeenPayloadEnvelopeInput {
     return this.payloadInputs.get(blockRootHex)?.hasPayloadEnvelope() ?? false;
   }
 
-  prune(blockRootHex: RootHex): void {
-    const payloadInput = this.payloadInputs.get(blockRootHex);
-    if (payloadInput) {
-      this.evictPayloadInput(payloadInput);
-    }
-  }
-
   size(): number {
     return this.payloadInputs.size;
   }
 
+  pruneBelow(slot: Slot): void {
+    let deletedCount = 0;
+    for (const [, input] of this.payloadInputs) {
+      if (input.slot < slot) {
+        this.evictPayloadInput(input);
+        deletedCount++;
+      }
+    }
+    this.logger?.debug("SeenPayloadEnvelopeInput.pruneBelow deleted entries", {slot, deletedCount});
+  }
+
   private evictPayloadInput(payloadInput: PayloadEnvelopeInput): void {
     this.serializedCache.delete(payloadInput.getSerializedCacheKeys());
     this.payloadInputs.delete(payloadInput.blockRootHex);

package/src/chain/seenCache/seenProposerPreferences.ts

@@ -0,0 +1,29 @@
+import {Slot, ValidatorIndex} from "@lodestar/types";
+import {MapDef} from "@lodestar/utils";
+
+/**
+ * Tracks signed proposer preferences we've already seen per (proposal_slot, validator_index).
+ */
+export class SeenProposerPreferences {
+  private readonly validatorIndexesBySlot = new MapDef<Slot, Set<ValidatorIndex>>(() => new Set<ValidatorIndex>());
+
+  isKnown(proposalSlot: Slot, validatorIndex: ValidatorIndex): boolean {
+    return this.validatorIndexesBySlot.get(proposalSlot)?.has(validatorIndex) === true;
+  }
+
+  add(proposalSlot: Slot, validatorIndex: ValidatorIndex): void {
+    this.validatorIndexesBySlot.getOrDefault(proposalSlot).add(validatorIndex);
+  }
+
+  /**
+   * Entries are only load-bearing while `proposal_slot > state.slot`. Once the slot has passed the
+   * `[IGNORE] proposal_slot > state.slot` gossip rule takes over, so drop them on each slot tick.
+   */
+  prune(currentSlot: Slot): void {
+    for (const slot of this.validatorIndexesBySlot.keys()) {
+      if (slot < currentSlot) {
+        this.validatorIndexesBySlot.delete(slot);
+      }
+    }
+  }
+}

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -226,7 +226,10 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       }
       sszTimer?.();
       const timer = this.metrics?.cpStateCache.stateReloadDuration.startTimer();
-      const newCachedState = seedState.loadOtherState(stateBytes, validatorsBytes);
+      // preload validators and balances for faster state transition
+      const newCachedState = seedState.loadOtherState(stateBytes, validatorsBytes, {
+        preloadValidatorsAndBalances: true,
+      });
       // hashTreeRoot() calls the commit() inside
       // there is no modification inside the state, it's just that we want to compute and cache all roots
       const stateRoot = toRootHex(newCachedState.hashTreeRoot());

package/src/chain/validation/block.ts

@@ -103,6 +103,7 @@ export async function validateGossipBlock(
     if (chain.forkChoice.getBlockHexAndBlockHash(parentRoot, parentBlockHashHex) === null) {
       throw new BlockGossipError(GossipAction.IGNORE, {
         code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+        parentRoot,
         parentBlockHash: parentBlockHashHex,
       });
     }

package/src/chain/validation/executionPayloadBid.ts

@@ -1,5 +1,6 @@
 import {PublicKey} from "@chainsafe/blst";
 import {
+  computeEpochAtSlot,
   createSingleSignatureSetFromComponents,
   getExecutionPayloadBidSigningRoot,
   isActiveBuilder,
@@ -76,6 +77,19 @@ async function validateExecutionPayloadBid(
   // `SignedProposerPreferences` associated with `bid.slot`.
   // TODO GLOAS: Implement this along with proposer preference
 
+  // [REJECT] The length of KZG commitments is less than or equal to the limitation defined in the
+  // consensus layer -- i.e. validate that
+  // `len(bid.blob_kzg_commitments) <= get_blob_parameters(compute_epoch_at_slot(bid.slot)).max_blobs_per_block`.
+  const blobKzgCommitmentsLen = bid.blobKzgCommitments.length;
+  const maxBlobsPerBlock = chain.config.getMaxBlobsPerBlock(computeEpochAtSlot(bid.slot));
+  if (blobKzgCommitmentsLen > maxBlobsPerBlock) {
+    throw new ExecutionPayloadBidError(GossipAction.REJECT, {
+      code: ExecutionPayloadBidErrorCode.TOO_MANY_KZG_COMMITMENTS,
+      blobKzgCommitmentsLen,
+      commitmentLimit: maxBlobsPerBlock,
+    });
+  }
+
   // [IGNORE] this is the first signed bid seen with a valid signature from the given builder for this slot.
   if (chain.seenExecutionPayloadBids.isKnown(bid.slot, bid.builderIndex)) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -4,8 +4,8 @@ import {
   getExecutionPayloadEnvelopeSignatureSet,
   isStatePostGloas,
 } from "@lodestar/state-transition";
-import {gloas} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
+import {gloas, ssz} from "@lodestar/types";
+import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {ExecutionPayloadEnvelopeError, ExecutionPayloadEnvelopeErrorCode, GossipAction} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
 import {RegenCaller} from "../regen/index.js";
@@ -53,7 +53,7 @@ async function validateExecutionPayloadEnvelope(
     throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
       code: ExecutionPayloadEnvelopeErrorCode.ENVELOPE_ALREADY_KNOWN,
       blockRoot: blockRootHex,
-      slot: envelope.slot,
+      slot: payload.slotNumber,
     });
   }
 
@@ -65,13 +65,13 @@ async function validateExecutionPayloadEnvelope(
     });
   }
 
-  // [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)`
+  // [IGNORE] The envelope is from a slot greater than or equal to the latest finalized slot -- i.e. validate that `payload.slotNumber >= compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)`
   const finalizedCheckpoint = chain.forkChoice.getFinalizedCheckpoint();
   const finalizedSlot = computeStartSlotAtEpoch(finalizedCheckpoint.epoch);
-  if (envelope.slot < finalizedSlot) {
+  if (payload.slotNumber < finalizedSlot) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
       code: ExecutionPayloadEnvelopeErrorCode.BELONG_TO_FINALIZED_BLOCK,
-      envelopeSlot: envelope.slot,
+      envelopeSlot: payload.slotNumber,
       finalizedSlot,
     });
   }
@@ -80,11 +80,11 @@ async function validateExecutionPayloadEnvelope(
   // TODO GLOAS: implement this. Technically if we cannot get proto block from fork choice,
   // it is possible that the block didn't pass the validation
 
-  // [REJECT] `block.slot` equals `envelope.slot`.
-  if (block.slot !== envelope.slot) {
+  // [REJECT] `block.slot` equals `payload.slotNumber`.
+  if (block.slot !== payload.slotNumber) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
       code: ExecutionPayloadEnvelopeErrorCode.SLOT_MISMATCH,
-      envelopeSlot: envelope.slot,
+      envelopeSlot: payload.slotNumber,
       blockSlot: block.slot,
     });
   }
@@ -107,6 +107,16 @@ async function validateExecutionPayloadEnvelope(
     });
   }
 
+  // [REJECT] `hash_tree_root(envelope.execution_requests) == bid.execution_requests_root`
+  const requestsRoot = ssz.electra.ExecutionRequests.hashTreeRoot(envelope.executionRequests);
+  if (!byteArrayEquals(requestsRoot, payloadInput.getBid().executionRequestsRoot)) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
+      code: ExecutionPayloadEnvelopeErrorCode.EXECUTION_REQUESTS_ROOT_MISMATCH,
+      envelopeRequestsRoot: toRootHex(requestsRoot),
+      bidRequestsRoot: toRootHex(payloadInput.getBid().executionRequestsRoot),
+    });
+  }
+
   // Get the block state to verify the builder's signature.
   const blockState = await chain.regen
     .getState(block.stateRoot, RegenCaller.validateGossipPayloadEnvelope)
@@ -114,7 +124,7 @@ async function validateExecutionPayloadEnvelope(
       throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
         code: ExecutionPayloadEnvelopeErrorCode.UNKNOWN_BLOCK_STATE,
         blockRoot: blockRootHex,
-        slot: envelope.slot,
+        slot: payload.slotNumber,
       });
     });
   if (!isStatePostGloas(blockState)) {

package/src/chain/validation/proposerPreferences.ts

@@ -0,0 +1,91 @@
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {
+  computeEpochAtSlot,
+  createSingleSignatureSetFromComponents,
+  getProposerPreferencesSigningRoot,
+  isStatePostGloas,
+} from "@lodestar/state-transition";
+import {gloas} from "@lodestar/types";
+import {GossipAction, ProposerPreferencesError, ProposerPreferencesErrorCode} from "../errors/index.js";
+import {IBeaconChain} from "../index.js";
+import {RegenCaller} from "../regen/index.js";
+
+/**
+ * Validates a gossiped `SignedProposerPreferences` per
+ * https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/p2p-interface.md#proposer_preferences
+ */
+export async function validateGossipProposerPreferences(
+  chain: IBeaconChain,
+  signedProposerPreferences: gloas.SignedProposerPreferences
+): Promise<void> {
+  const preferences = signedProposerPreferences.message;
+  const {proposalSlot, validatorIndex} = preferences;
+  const proposalEpoch = computeEpochAtSlot(proposalSlot);
+
+  // [IGNORE] `preferences.proposal_slot` is in the current or next epoch.
+  const currentEpoch = chain.clock.currentEpoch;
+  if (proposalEpoch < currentEpoch || proposalEpoch > currentEpoch + 1) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.INVALID_EPOCH,
+      proposalSlot,
+      currentEpoch,
+    });
+  }
+
+  // [IGNORE] `preferences.proposal_slot` has not already passed.
+  const currentSlot = chain.clock.currentSlot;
+  if (proposalSlot <= currentSlot) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.PROPOSAL_SLOT_PASSED,
+      proposalSlot,
+      currentSlot,
+    });
+  }
+
+  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipProposerPreferences);
+  if (!isStatePostGloas(state)) {
+    throw new Error(`Expected gloas+ state for proposer preferences validation, got fork=${state.forkName}`);
+  }
+
+  // [REJECT] `preferences.validator_index` is present at the correct slot in the current or next
+  // epoch's portion of `state.proposer_lookahead` — i.e. `is_valid_proposal_slot(state, preferences)`
+  // returns True.
+  const epochOffset = proposalEpoch - state.epoch;
+  const proposers = epochOffset === 0 ? state.currentProposers : state.nextProposers;
+  const expectedProposer = proposers[proposalSlot % SLOTS_PER_EPOCH];
+  if (epochOffset < 0 || epochOffset > 1 || expectedProposer !== validatorIndex) {
+    throw new ProposerPreferencesError(GossipAction.REJECT, {
+      code: ProposerPreferencesErrorCode.INVALID_PROPOSER,
+      proposalSlot,
+      validatorIndex,
+    });
+  }
+
+  // [IGNORE] The `signed_proposer_preferences` is the first valid message received from the validator
+  // with index `preferences.validator_index` and the given slot `preferences.proposal_slot`.
+  if (chain.seenProposerPreferences.isKnown(proposalSlot, validatorIndex)) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.ALREADY_KNOWN,
+      proposalSlot,
+      validatorIndex,
+    });
+  }
+
+  // [REJECT] `signed_proposer_preferences.signature` is valid with respect to the validator's public key.
+  const signatureSet = createSingleSignatureSetFromComponents(
+    chain.pubkeyCache.getOrThrow(validatorIndex),
+    getProposerPreferencesSigningRoot(chain.config, preferences),
+    signedProposerPreferences.signature
+  );
+
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true}))) {
+    throw new ProposerPreferencesError(GossipAction.REJECT, {
+      code: ProposerPreferencesErrorCode.INVALID_SIGNATURE,
+      proposalSlot,
+      validatorIndex,
+    });
+  }
+
+  // Valid
+  chain.seenProposerPreferences.add(proposalSlot, validatorIndex);
+}

package/src/db/repositories/executionPayloadEnvelopeArchive.ts

@@ -19,7 +19,7 @@ export class ExecutionPayloadEnvelopeArchiveRepository extends Repository<Slot,
    * Id is the slot from the envelope
    */
   getId(value: gloas.SignedExecutionPayloadEnvelope): Slot {
-    return value.message.slot;
+    return value.message.payload.slotNumber;
   }
 
   encodeKey(id: Slot): Uint8Array {

package/src/execution/engine/http.ts

@@ -216,13 +216,15 @@ export class ExecutionEngineHttp implements IExecutionEngine {
     executionRequests?: ExecutionRequests
   ): Promise<ExecutePayloadResponse> {
     const method =
-      ForkSeq[fork] >= ForkSeq.electra
-        ? "engine_newPayloadV4"
-        : ForkSeq[fork] >= ForkSeq.deneb
-          ? "engine_newPayloadV3"
-          : ForkSeq[fork] >= ForkSeq.capella
-            ? "engine_newPayloadV2"
-            : "engine_newPayloadV1";
+      ForkSeq[fork] >= ForkSeq.gloas
+        ? "engine_newPayloadV5"
+        : ForkSeq[fork] >= ForkSeq.electra
+          ? "engine_newPayloadV4"
+          : ForkSeq[fork] >= ForkSeq.deneb
+            ? "engine_newPayloadV3"
+            : ForkSeq[fork] >= ForkSeq.capella
+              ? "engine_newPayloadV2"
+              : "engine_newPayloadV1";
 
     const serializedExecutionPayload = serializeExecutionPayload(fork, executionPayload);
 
@@ -244,7 +246,7 @@ export class ExecutionEngineHttp implements IExecutionEngine {
         }
         const serializedExecutionRequests = serializeExecutionRequests(executionRequests);
         engineRequest = {
-          method: "engine_newPayloadV4",
+          method: ForkSeq[fork] >= ForkSeq.gloas ? "engine_newPayloadV5" : "engine_newPayloadV4",
           params: [
             serializedExecutionPayload,
             serializedVersionedHashes,
@@ -348,11 +350,13 @@ export class ExecutionEngineHttp implements IExecutionEngine {
     // Once on capella, should this need to be permanently switched to v2 when payload attrs
     // not provided
     const method =
-      ForkSeq[fork] >= ForkSeq.deneb
-        ? "engine_forkchoiceUpdatedV3"
-        : ForkSeq[fork] >= ForkSeq.capella
-          ? "engine_forkchoiceUpdatedV2"
-          : "engine_forkchoiceUpdatedV1";
+      ForkSeq[fork] >= ForkSeq.gloas
+        ? "engine_forkchoiceUpdatedV4"
+        : ForkSeq[fork] >= ForkSeq.deneb
+          ? "engine_forkchoiceUpdatedV3"
+          : ForkSeq[fork] >= ForkSeq.capella
+            ? "engine_forkchoiceUpdatedV2"
+            : "engine_forkchoiceUpdatedV1";
     const payloadAttributesRpc = payloadAttributes ? serializePayloadAttributes(payloadAttributes) : undefined;
     // If we are just fcUing and not asking execution for payload, retry is not required
     // and we can move on, as the next fcU will be issued soon on the new slot
@@ -438,9 +442,12 @@ export class ExecutionEngineHttp implements IExecutionEngine {
       case ForkName.electra:
         method = "engine_getPayloadV4";
         break;
-      default:
+      case ForkName.fulu:
         method = "engine_getPayloadV5";
         break;
+      default:
+        method = "engine_getPayloadV6";
+        break;
     }
     const payloadResponse = await this.rpc.fetchWithRetries<
       EngineApiRpcReturnTypes[typeof method],

package/src/execution/engine/interface.ts

@@ -87,6 +87,7 @@ export type PayloadAttributes = {
   suggestedFeeRecipient: string;
   withdrawals?: capella.Withdrawal[];
   parentBeaconBlockRoot?: Uint8Array;
+  slotNumber?: number; // EIP-7843
 };
 
 export type VersionedHashes = Uint8Array[];

package/src/execution/engine/mock.ts

@@ -11,7 +11,7 @@ import {
   SLOTS_PER_EPOCH,
 } from "@lodestar/params";
 import {computeTimeAtSlot} from "@lodestar/state-transition";
-import {ExecutionPayload, RootHex, bellatrix, deneb, ssz} from "@lodestar/types";
+import {ExecutionPayload, RootHex, bellatrix, deneb, gloas, ssz} from "@lodestar/types";
 import {fromHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {INTEROP_BLOCK_HASH} from "../../node/utils/interop/state.js";
@@ -132,14 +132,17 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
       engine_newPayloadV2: this.notifyNewPayload.bind(this),
       engine_newPayloadV3: this.notifyNewPayload.bind(this),
       engine_newPayloadV4: this.notifyNewPayload.bind(this),
+      engine_newPayloadV5: this.notifyNewPayload.bind(this),
       engine_forkchoiceUpdatedV1: this.notifyForkchoiceUpdate.bind(this),
       engine_forkchoiceUpdatedV2: this.notifyForkchoiceUpdate.bind(this),
       engine_forkchoiceUpdatedV3: this.notifyForkchoiceUpdate.bind(this),
+      engine_forkchoiceUpdatedV4: this.notifyForkchoiceUpdate.bind(this),
       engine_getPayloadV1: this.getPayloadV1.bind(this),
       engine_getPayloadV2: this.getPayloadV5.bind(this),
       engine_getPayloadV3: this.getPayloadV5.bind(this),
       engine_getPayloadV4: this.getPayloadV5.bind(this),
       engine_getPayloadV5: this.getPayloadV5.bind(this),
+      engine_getPayloadV6: this.getPayloadV5.bind(this),
       engine_getPayloadBodiesByHashV1: this.getPayloadBodiesByHash.bind(this),
       engine_getPayloadBodiesByRangeV1: this.getPayloadBodiesByRange.bind(this),
       engine_getClientVersionV1: this.getClientVersionV1.bind(this),
@@ -379,6 +382,10 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
         (executionPayload as ExecutionPayload<ForkPostCapella>).withdrawals = ssz.capella.Withdrawals.defaultValue();
       }
 
+      if (ForkSeq[fork] >= ForkSeq.gloas && payloadAttributes.slotNumber != null) {
+        (executionPayload as gloas.ExecutionPayload).slotNumber = payloadAttributes.slotNumber;
+      }
+
       this.preparingPayloads.set(payloadId, {
         executionPayload: serializeExecutionPayload(fork, executionPayload),
         blobsBundle: serializeBlobsBundle({