@lodestar/beacon-node 1.51.0-dev.99edacec52 → 1.51.0-dev.a736f94f66

package/src/chain/validation/inclusionList.ts

@@ -0,0 +1,183 @@
+import {ProtoBlock} from "@lodestar/fork-choice";
+import {GENESIS_SLOT, MIN_SEED_LOOKAHEAD, isForkPostHeze} from "@lodestar/params";
+import {
+  EpochShuffling,
+  computeEpochAtSlot,
+  computeStartSlotAtEpoch,
+  getInclusionListCommittee,
+  getInclusionListSignatureSet,
+} from "@lodestar/state-transition";
+import {Epoch, RootHex, heze} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+import {InclusionListError, InclusionListErrorCode} from "../errors/inclusionList.js";
+import {GossipAction} from "../errors/index.js";
+import {IBeaconChain} from "../interface.js";
+import {RegenCaller} from "../regen/index.js";
+import {isValidDependentRoot} from "./proposerPreferences.js";
+
+export type InclusionListValidationResult = {
+  /** Positions of `validator_index` in `get_inclusion_list_committee(state, slot)`, several when the committee cycles */
+  committeeIndices: number[];
+  /** Sum of the byte lengths of `message.transactions` */
+  totalBytes: number;
+};
+
+/**
+ * Gossip validation for the `inclusion_list` topic, in spec rule order. Also applied to inclusion lists
+ * submitted over the API before they are published.
+ */
+export async function validateGossipInclusionList(
+  chain: IBeaconChain,
+  signedInclusionList: heze.SignedInclusionList
+): Promise<InclusionListValidationResult> {
+  const {slot, validatorIndex, transactions, dependentRoot} = signedInclusionList.message;
+  const totalBytes = transactions.reduce((total, transaction) => total + transaction.byteLength, 0);
+
+  // A pre-heze slot has no inclusion list committee to validate against
+  if (!isForkPostHeze(chain.config.getForkName(slot))) {
+    throw new InclusionListError(GossipAction.IGNORE, {
+      code: InclusionListErrorCode.PRE_HEZE_SLOT,
+      inclusionListSlot: slot,
+    });
+  }
+
+  // [IGNORE] The message is either the first or second valid message received from validatorIndex
+  // for (message.slot, message.dependent_root)
+  const dependentRootHex = toRootHex(dependentRoot);
+  if (chain.inclusionListStore.seenTwice(slot, dependentRootHex, validatorIndex)) {
+    throw new InclusionListError(GossipAction.IGNORE, {
+      code: InclusionListErrorCode.MORE_THAN_TWO,
+      validatorIndex,
+    });
+  }
+
+  // [IGNORE] message.slot is equal to the current slot, with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance
+  if (!chain.clock.isCurrentSlotGivenGossipDisparity(slot)) {
+    throw new InclusionListError(GossipAction.IGNORE, {
+      code: InclusionListErrorCode.INVALID_SLOT,
+      inclusionListSlot: slot,
+      currentSlot: chain.clock.currentSlot,
+    });
+  }
+
+  // [IGNORE] The size of message.transactions is greater than 0
+  if (totalBytes === 0) {
+    throw new InclusionListError(GossipAction.IGNORE, {code: InclusionListErrorCode.EMPTY_TRANSACTIONS});
+  }
+
+  // [REJECT] The size of message.transactions is within upperbound MAX_TRANSACTIONS_BYTES_PER_INCLUSION_LIST
+  if (totalBytes > chain.config.MAX_TRANSACTIONS_BYTES_PER_INCLUSION_LIST) {
+    throw new InclusionListError(GossipAction.REJECT, {
+      code: InclusionListErrorCode.MAXIMUM_SIZE_EXCEEDED,
+      totalBytes,
+      maxBytes: chain.config.MAX_TRANSACTIONS_BYTES_PER_INCLUSION_LIST,
+    });
+  }
+
+  // [REJECT] Every transaction in message.transactions is non-empty
+  const emptyTransactionIndex = transactions.findIndex((transaction) => transaction.byteLength === 0);
+  if (emptyTransactionIndex !== -1) {
+    throw new InclusionListError(GossipAction.REJECT, {
+      code: InclusionListErrorCode.EMPTY_TRANSACTION,
+      transactionIndex: emptyTransactionIndex,
+    });
+  }
+
+  // [IGNORE] The block with root message.dependent_root has been seen
+  const dependentBlock = chain.forkChoice.getBlockHexDefaultStatus(dependentRootHex);
+  if (dependentBlock === null) {
+    throw new InclusionListError(GossipAction.IGNORE, {
+      code: InclusionListErrorCode.UNKNOWN_DEPENDENT_ROOT,
+      dependentRoot: dependentRootHex,
+    });
+  }
+
+  // [REJECT] The slot of the block with root message.dependent_root is strictly less than
+  // compute_start_slot_at_epoch(compute_epoch_at_slot(message.slot) - MIN_SEED_LOOKAHEAD),
+  // clamped to genesis like compute_shuffling_dependent_slot
+  const epoch = computeEpochAtSlot(slot);
+  const dependentEpoch = epoch - MIN_SEED_LOOKAHEAD;
+  const maxDependentSlot = Math.max(GENESIS_SLOT, computeStartSlotAtEpoch(dependentEpoch) - 1);
+  if (dependentBlock.slot > maxDependentSlot) {
+    throw new InclusionListError(GossipAction.REJECT, {
+      code: InclusionListErrorCode.INVALID_DEPENDENT_ROOT_SLOT,
+      dependentRoot: dependentRootHex,
+      dependentSlot: dependentBlock.slot,
+      maxSlot: maxDependentSlot,
+    });
+  }
+
+  // [IGNORE] is_valid_dependent_root(store, message.dependent_root, epoch - MIN_SEED_LOOKAHEAD)
+  if (!isValidDependentRoot(chain.forkChoice, dependentBlock, dependentEpoch)) {
+    throw new InclusionListError(GossipAction.IGNORE, {
+      code: InclusionListErrorCode.INVALID_DEPENDENT_ROOT,
+      dependentRoot: dependentRootHex,
+      epoch: dependentEpoch,
+    });
+  }
+
+  // [REJECT] validatorIndex is in get_inclusion_list_committee(state, message.slot), where state is the
+  // state of the block with root message.dependent_root, i.e. the shuffling of `epoch` keyed by `dependent_root`
+  const shuffling = await getShuffling(chain, epoch, dependentRootHex, dependentBlock);
+  if (shuffling === null) {
+    throw new InclusionListError(GossipAction.IGNORE, {
+      code: InclusionListErrorCode.MISSING_SHUFFLING,
+      dependentRoot: dependentRootHex,
+      epoch,
+    });
+  }
+  const committeeIndices = getInclusionListCommittee(shuffling, slot).getCommitteeIndices(validatorIndex);
+  if (committeeIndices.length === 0) {
+    throw new InclusionListError(GossipAction.REJECT, {
+      code: InclusionListErrorCode.VALIDATOR_NOT_IN_COMMITTEE,
+      validatorIndex,
+    });
+  }
+
+  // [REJECT] The signature is valid with respect to the validator's public key
+  // Domain from the list's own slot, so a list for the first Heze slot verifies while the clock is still in Gloas
+  const signatureSet = getInclusionListSignatureSet(chain.config, slot, signedInclusionList);
+  // With only 16 inclusion list committee members per slot, batching can delay gossip by 100ms.
+  // Verify without batching so inclusion lists can be forwarded sooner.
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: false}))) {
+    throw new InclusionListError(GossipAction.REJECT, {code: InclusionListErrorCode.INVALID_SIGNATURE});
+  }
+
+  // Check again after the async validation so concurrent lists of the same validator cannot all pass
+  if (chain.inclusionListStore.seenTwice(slot, dependentRootHex, validatorIndex)) {
+    throw new InclusionListError(GossipAction.IGNORE, {
+      code: InclusionListErrorCode.MORE_THAN_TWO,
+      validatorIndex,
+    });
+  }
+  chain.inclusionListStore.markSeen(slot, dependentRootHex, validatorIndex);
+
+  return {committeeIndices, totalBytes};
+}
+
+/**
+ * The shuffling of `epoch` on the branch of `dependentBlock`. Usually cached from the head state; when the
+ * dependent block is the head across empty epochs that state has not reached the lookahead start slot, so
+ * the spec's `process_slots` step is a state regen
+ */
+async function getShuffling(
+  chain: IBeaconChain,
+  epoch: Epoch,
+  dependentRootHex: RootHex,
+  dependentBlock: ProtoBlock
+): Promise<EpochShuffling | null> {
+  const cached = await chain.shufflingCache.get(epoch, dependentRootHex);
+  if (cached !== null) {
+    return cached;
+  }
+  try {
+    return await chain.regenStateForAttestationVerification(
+      epoch,
+      dependentRootHex,
+      dependentBlock,
+      RegenCaller.validateGossipInclusionList
+    );
+  } catch {
+    return null;
+  }
+}

package/src/chain/validation/index.ts

@@ -3,6 +3,7 @@ export * from "./attestation.js";
 export * from "./attesterSlashing.js";
 export * from "./block.js";
 export * from "./blsToExecutionChange.js";
+export * from "./inclusionList.js";
 export * from "./proposerSlashing.js";
 export * from "./syncCommittee.js";
 export * from "./syncCommitteeContributionAndProof.js";

package/src/execution/builder/validateBid.ts

@@ -1,6 +1,6 @@
 import {routes} from "@lodestar/api";
 import {ProtoBlock} from "@lodestar/fork-choice";
-import {MAX_EXECUTION_PAYMENT, PAYLOAD_BUILDER_VERSION} from "@lodestar/params";
+import {MAX_EXECUTION_PAYMENT, PAYLOAD_BUILDER_VERSION, isForkPostHeze} from "@lodestar/params";
 import {
   computeEpochAtSlot,
   createSingleSignatureSetFromComponents,
@@ -9,7 +9,7 @@ import {
   isGasLimitTargetCompatible,
   isStatePostGloas,
 } from "@lodestar/state-transition";
-import {RootHex, Slot, gloas} from "@lodestar/types";
+import {RootHex, Slot, gloas, heze} from "@lodestar/types";
 import {bigIntMin, byteArrayEquals, prettyGweiToEth, toHex, toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../chain/index.js";
 import {RegenCaller} from "../../chain/regen/index.js";
@@ -41,6 +41,7 @@ export async function validateBuilderApiExecutionPayloadBid(
   }
 ): Promise<void> {
   const bid = signedExecutionPayloadBid.message;
+  const fork = chain.config.getForkName(bid.slot);
   const {slot, parentBlock, parentBlockHash, parentBlockRoot, entry, getParentExecutionRequests} = request;
 
   if (bid.slot !== slot) {
@@ -76,6 +77,26 @@ export async function validateBuilderApiExecutionPayloadBid(
     );
   }
 
+  // Same check as bid gossip (only_timely=True), not the proposer's full view from validator.md: a list released
+  // after the deadline would void every bid, and a high bid that went stale after gossip could crowd out the rest unpaid
+  if (isForkPostHeze(fork)) {
+    const {inclusionListBits} = bid as heze.ExecutionPayloadBid;
+    const inclusionListSlot = bid.slot - 1;
+    const dependentRoot = getShufflingDependentRoot(
+      chain.forkChoice,
+      computeEpochAtSlot(inclusionListSlot),
+      computeEpochAtSlot(parentBlock.slot),
+      parentBlock
+    );
+    if (!chain.inclusionListStore.isInclusionListBitsInclusive(inclusionListSlot, dependentRoot, inclusionListBits)) {
+      const expectedBits = chain.inclusionListStore.getInclusionListBits(inclusionListSlot, dependentRoot);
+      throw Error(
+        `Bid inclusionListBits=${toHex(inclusionListBits.uint8Array)} is not inclusive of ` +
+          `timely inclusion lists expected=${toHex(expectedBits.uint8Array)}`
+      );
+    }
+  }
+
   const state = await chain.regen
     .getBlockSlotState(parentBlock, slot, {dontTransferCache: true}, RegenCaller.validateGossipExecutionPayloadBid)
     .catch((e: Error) => {

package/src/execution/engine/disabled.ts

@@ -28,4 +28,8 @@ export class ExecutionEngineDisabled implements IExecutionEngine {
   getBlobs(): Promise<never> {
     throw Error("Execution engine disabled");
   }
+
+  getInclusionList(): Promise<never> {
+    throw Error("Execution engine disabled");
+  }
 }

package/src/execution/engine/http.ts

@@ -8,7 +8,7 @@ import {
   isForkPostBellatrix,
   isForkPostFulu,
 } from "@lodestar/params";
-import {BlobsBundle, ExecutionPayload, ExecutionRequests, Root, RootHex, Wei} from "@lodestar/types";
+import {BlobsBundle, ExecutionPayload, ExecutionRequests, Root, RootHex, Wei, bellatrix} from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
 import {isErrorAborted} from "@lodestar/utils";
@@ -224,9 +224,13 @@ export class ExecutionEngineHttp implements IExecutionEngine {
     executionPayload: ExecutionPayload,
     versionedHashes?: VersionedHashes,
     parentBlockRoot?: Root,
-    executionRequests?: ExecutionRequests
+    executionRequests?: ExecutionRequests,
+    inclusionListTransactions?: bellatrix.Transactions
   ): Promise<ExecutePayloadResponse> {
     // Validate before queueing, argument errors must not be reported as an unavailable execution client
+    if (ForkSeq[fork] >= ForkSeq.heze && inclusionListTransactions === undefined) {
+      throw Error(`inclusionListTransactions required in notifyNewPayload for fork=${fork}`);
+    }
     if (ForkSeq[fork] >= ForkSeq.deneb) {
       if (versionedHashes === undefined) {
         throw Error(`versionedHashes required in notifyNewPayload for fork=${fork}`);
@@ -243,7 +247,14 @@ export class ExecutionEngineHttp implements IExecutionEngine {
     try {
       result = await this.enqueue(() =>
         this.withTransport(fork, undefined, (transport) =>
-          transport.newPayload(fork, executionPayload, versionedHashes, parentBlockRoot, executionRequests)
+          transport.newPayload(
+            fork,
+            executionPayload,
+            versionedHashes,
+            parentBlockRoot,
+            executionRequests,
+            inclusionListTransactions
+          )
         )
       );
     } catch (e) {
@@ -264,7 +275,12 @@ export class ExecutionEngineHttp implements IExecutionEngine {
 
     switch (status) {
       case ExecutionPayloadStatus.VALID:
-        return {status, latestValidHash: latestValidHash ?? "0x0", validationError: null};
+        return {
+          status,
+          latestValidHash: latestValidHash ?? "0x0",
+          validationError: null,
+          inclusionListSatisfied: result.inclusionListSatisfied ?? null,
+        };
 
       case ExecutionPayloadStatus.INVALID:
         // As per latest specs if latestValidHash can be null and it would mean only
@@ -348,7 +364,15 @@ export class ExecutionEngineHttp implements IExecutionEngine {
           }
 
           const payloadAttributesRpc = serializePayloadAttributes(payloadAttributes);
-          this.payloadIdCache.add({headBlockHash, finalizedBlockHash, ...payloadAttributesRpc}, payloadId);
+          this.payloadIdCache.add(
+            {
+              headBlockHash,
+              finalizedBlockHash,
+              ...payloadAttributesRpc,
+              inclusionListTransactions: payloadAttributes.inclusionListTransactions,
+            },
+            payloadId
+          );
           void this.prunePayloadIdCache();
         }
         return payloadId;
@@ -423,6 +447,18 @@ export class ExecutionEngineHttp implements IExecutionEngine {
     return this.withTransport(undefined, "v1", (transport) => transport.getBlobsV1(versionedHashes));
   }
 
+  /**
+   * `engine_getInclusionListV1`, JSON-RPC only as the REST engine API defines no inclusion list route.
+   * Queued so it runs after the forkchoiceUpdated of a payload imported just before, which prunes that
+   * payload's transactions from the mempool the list is built from.
+   */
+  async getInclusionList(): Promise<bellatrix.Transactions> {
+    return this.enqueue(() => {
+      this.metrics?.engineApiRequests.inc({transport: "json-rpc"});
+      return this.jsonRpc.getInclusionList();
+    });
+  }
+
   private enqueue<T>(job: () => Promise<T>): Promise<T> {
     return this.queue.push(job) as Promise<T>;
   }

package/src/execution/engine/interface.ts

@@ -9,7 +9,16 @@ import {
   ForkPreFulu,
   WITHDRAWAL_REQUEST_TYPE,
 } from "@lodestar/params";
-import {BlobsBundle, ExecutionPayload, ExecutionRequests, Root, RootHex, Wei, capella} from "@lodestar/types";
+import {
+  BlobsBundle,
+  ExecutionPayload,
+  ExecutionRequests,
+  Root,
+  RootHex,
+  Wei,
+  bellatrix,
+  capella,
+} from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
 import {PayloadId, PayloadIdCache, WithdrawalV1} from "./payloadIdCache.js";
@@ -73,7 +82,13 @@ export type ExecutePayloadResponse =
       latestValidHash: null;
       validationError: null;
     }
-  | {status: ExecutionPayloadStatus.VALID; latestValidHash: RootHex; validationError: null}
+  | {
+      status: ExecutionPayloadStatus.VALID;
+      latestValidHash: RootHex;
+      validationError: null;
+      /** PayloadStatusV2: whether the payload satisfied the inclusion list constraints */
+      inclusionListSatisfied?: boolean | null;
+    }
   | {status: ExecutionPayloadStatus.INVALID; latestValidHash: RootHex | null; validationError: string | null}
   | {
       status:
@@ -99,6 +114,8 @@ export type PayloadAttributes = {
   parentBeaconBlockRoot?: Uint8Array;
   slotNumber?: number; // EIP-7843
   targetGasLimit?: bigint; // GLOAS (PayloadAttributesV4, execution-apis#796)
+  /** Transactions the built payload must include (PayloadAttributesV5, HEZE:EIP-7805) */
+  inclusionListTransactions?: bellatrix.Transactions;
 };
 
 export type VersionedHashes = Uint8Array[];
@@ -129,9 +146,16 @@ export interface IExecutionEngine {
     executionPayload: ExecutionPayload,
     versionedHashes?: VersionedHashes,
     parentBeaconBlockRoot?: Root,
-    executionRequests?: ExecutionRequests
+    executionRequests?: ExecutionRequests,
+    inclusionListTransactions?: bellatrix.Transactions
   ): Promise<ExecutePayloadResponse>;
 
+  /**
+   * Transactions the execution layer wants included in the next payload. Parameterless since
+   * execution-apis#609: the execution layer builds against its own view of the head.
+   */
+  getInclusionList(): Promise<bellatrix.Transactions>;
+
   /**
    * Signal fork choice updates
    * This function performs two actions atomically:

package/src/execution/engine/jsonRpcTransport.ts

@@ -1,5 +1,5 @@
 import {ForkName, ForkSeq} from "@lodestar/params";
-import {ExecutionPayload, ExecutionRequests, Root, RootHex} from "@lodestar/types";
+import {ExecutionPayload, ExecutionRequests, Root, RootHex, bellatrix} from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
 import {strip0xPrefix} from "@lodestar/utils";
@@ -16,10 +16,12 @@ import {
   deserializeBlobAndProofsV2,
   deserializeBlobAndProofsV2IntoBytes,
   deserializeExecutionPayloadBodyV2,
+  deserializeInclusionList,
   parseExecutionPayload,
   serializeBeaconBlockRoot,
   serializeExecutionPayload,
   serializeExecutionRequests,
+  serializeInclusionList,
   serializePayloadAttributes,
   serializeVersionedHashes,
 } from "./types.js";
@@ -40,6 +42,7 @@ const getPayloadBodiesByHashOpts: ReqOpts = {routeId: "getPayloadBodiesByHash"};
 const getBlobsV1Opts: ReqOpts = {routeId: "getBlobsV1"};
 const getBlobsV2Opts: ReqOpts = {routeId: "getBlobsV2"};
 const getClientVersionOpts: ReqOpts = {routeId: "getClientVersion"};
+const getInclusionListOpts: ReqOpts = {routeId: "getInclusionList"};
 
 /**
  * Legacy `engine_*` JSON-RPC methods
@@ -57,7 +60,8 @@ export class JsonRpcEngineTransport implements IEngineTransport {
     executionPayload: ExecutionPayload,
     versionedHashes?: VersionedHashes,
     parentBeaconBlockRoot?: Root,
-    executionRequests?: ExecutionRequests
+    executionRequests?: ExecutionRequests,
+    inclusionListTransactions?: bellatrix.Transactions
   ): Promise<PayloadStatusResult> {
     const serializedExecutionPayload = serializeExecutionPayload(fork, executionPayload);
 
@@ -76,6 +80,28 @@ export class JsonRpcEngineTransport implements IEngineTransport {
         if (executionRequests === undefined) {
           throw Error(`executionRequests required in notifyNewPayload for fork=${fork}`);
         }
+        if (ForkSeq[fork] >= ForkSeq.heze) {
+          if (inclusionListTransactions === undefined) {
+            throw Error(`inclusionListTransactions required in notifyNewPayload for fork=${fork}`);
+          }
+          const method = "engine_newPayloadV6";
+          return this.rpc.fetchWithRetries<
+            EngineApiRpcReturnTypes[typeof method],
+            EngineApiRpcParamTypes[typeof method]
+          >(
+            {
+              method,
+              params: [
+                serializedExecutionPayload,
+                serializedVersionedHashes,
+                serializedParentBeaconBlockRoot,
+                serializeExecutionRequests(fork, executionRequests),
+                serializeInclusionList(inclusionListTransactions),
+              ],
+            },
+            notifyNewPayloadOpts
+          );
+        }
         const method = ForkSeq[fork] >= ForkSeq.gloas ? "engine_newPayloadV5" : "engine_newPayloadV4";
         return this.rpc.fetchWithRetries<EngineApiRpcReturnTypes[typeof method], EngineApiRpcParamTypes[typeof method]>(
           {
@@ -113,13 +139,15 @@ export class JsonRpcEngineTransport implements IEngineTransport {
     payloadAttributes?: PayloadAttributes
   ): Promise<ForkchoiceUpdatedResult> {
     const method =
-      ForkSeq[fork] >= ForkSeq.gloas
-        ? "engine_forkchoiceUpdatedV4"
-        : ForkSeq[fork] >= ForkSeq.deneb
-          ? "engine_forkchoiceUpdatedV3"
-          : ForkSeq[fork] >= ForkSeq.capella
-            ? "engine_forkchoiceUpdatedV2"
-            : "engine_forkchoiceUpdatedV1";
+      ForkSeq[fork] >= ForkSeq.heze
+        ? "engine_forkchoiceUpdatedV5"
+        : 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
@@ -244,4 +272,13 @@ export class JsonRpcEngineTransport implements IEngineTransport {
       return {code, name: cv.name, version: cv.version, commit: strip0xPrefix(cv.commit)};
     });
   }
+
+  async getInclusionList(): Promise<bellatrix.Transactions> {
+    const method = "engine_getInclusionListV1";
+    const response = await this.rpc.fetchWithRetries<
+      EngineApiRpcReturnTypes[typeof method],
+      EngineApiRpcParamTypes[typeof method]
+    >({method, params: []}, getInclusionListOpts);
+    return deserializeInclusionList(response);
+  }
 }

package/src/execution/engine/mock.ts

@@ -137,10 +137,12 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
       engine_newPayloadV3: this.notifyNewPayload.bind(this),
       engine_newPayloadV4: this.notifyNewPayload.bind(this),
       engine_newPayloadV5: this.notifyNewPayload.bind(this),
+      engine_newPayloadV6: 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_forkchoiceUpdatedV5: this.notifyForkchoiceUpdate.bind(this),
       engine_getPayloadV1: this.getPayloadV1.bind(this),
       engine_getPayloadV2: this.getPayloadV5.bind(this),
       engine_getPayloadV3: this.getPayloadV5.bind(this),
@@ -151,6 +153,7 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
       engine_getClientVersionV1: this.getClientVersionV1.bind(this),
       engine_getBlobsV1: this.getBlobs.bind(this),
       engine_getBlobsV2: this.getBlobsV2.bind(this),
+      engine_getInclusionListV1: this.getInclusionList.bind(this),
     };
   }
 
@@ -234,7 +237,13 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
     // IF the payload has been fully validated while processing the call
     // RETURN payload status from the Payload validation process
     // If validation succeeds, the response MUST contain {status: VALID, latestValidHash: payload.blockHash}
-    return {status: ExecutionPayloadStatus.VALID, latestValidHash: blockHash, validationError: null};
+    // The mock does not check inclusion list constraints, so every payload satisfies them (PayloadStatusV2)
+    return {
+      status: ExecutionPayloadStatus.VALID,
+      latestValidHash: blockHash,
+      validationError: null,
+      inclusionListSatisfied: true,
+    };
   }
 
   /**
@@ -409,7 +418,12 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
       // IF the payload is deemed VALID and the build process has begun
       // {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash, validationError: null}, payloadId: buildProcessId}
       return {
-        payloadStatus: {status: ExecutionPayloadStatus.VALID, latestValidHash: null, validationError: null},
+        payloadStatus: {
+          status: ExecutionPayloadStatus.VALID,
+          latestValidHash: null,
+          validationError: null,
+          inclusionListSatisfied: true,
+        },
         payloadId: String(payloadId as number),
       };
     }
@@ -418,7 +432,12 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
     // IF the payload is deemed VALID and a build process hasn't been started
     // {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash, validationError: null}, payloadId: null}
     return {
-      payloadStatus: {status: ExecutionPayloadStatus.VALID, latestValidHash: null, validationError: null},
+      payloadStatus: {
+        status: ExecutionPayloadStatus.VALID,
+        latestValidHash: null,
+        validationError: null,
+        inclusionListSatisfied: true,
+      },
       payloadId: null,
     };
   }
@@ -487,6 +506,10 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
     return null;
   }
 
+  private getInclusionList(): EngineApiRpcReturnTypes["engine_getInclusionListV1"] {
+    return [];
+  }
+
   private timestampToFork(timestamp: number): ForkPostBellatrix {
     if (timestamp >= this.gloasForkTimestamp) return ForkName.gloas;
     if (timestamp >= this.fuluForkTimestamp) return ForkName.fulu;

package/src/execution/engine/payloadIdCache.ts

@@ -1,4 +1,6 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {bellatrix} from "@lodestar/types";
 import {pruneSetToMax} from "@lodestar/utils";
 import {PayloadAttributesRpc} from "./types.js";
 import {DATA, QUANTITY} from "./utils.js";
@@ -17,10 +19,16 @@ export type WithdrawalV1 = {
   amount: QUANTITY;
 };
 
-type FcuAttributes = {headBlockHash: DATA; finalizedBlockHash: DATA} & Omit<PayloadAttributesRpc, "withdrawals">;
+type FcuAttributes = {headBlockHash: DATA; finalizedBlockHash: DATA} & Omit<
+  PayloadAttributesRpc,
+  "withdrawals" | "inclusionListTransactions"
+> & {inclusionListTransactions?: bellatrix.Transactions};
 
 export class PayloadIdCache {
-  private readonly payloadIdByFcuAttributes = new Map<string, {payloadId: PayloadId; fullKey: string}>();
+  private readonly payloadIdByFcuAttributes = new Map<
+    string,
+    {payloadId: PayloadId; fullKey: string; inclusionListTransactions?: bellatrix.Transactions}
+  >();
 
   getFullKey({headBlockHash, finalizedBlockHash, timestamp, prevRandao, suggestedFeeRecipient}: FcuAttributes): string {
     return `${headBlockHash}-${finalizedBlockHash}-${timestamp}-${prevRandao}-${suggestedFeeRecipient}`;
@@ -37,7 +45,8 @@ export class PayloadIdCache {
   add(fcuAttributes: FcuAttributes, payloadId: PayloadId): void {
     const key = this.getKey(fcuAttributes);
     const fullKey = this.getFullKey(fcuAttributes);
-    this.payloadIdByFcuAttributes.set(key, {payloadId, fullKey});
+    const {inclusionListTransactions} = fcuAttributes;
+    this.payloadIdByFcuAttributes.set(key, {payloadId, fullKey, inclusionListTransactions});
   }
 
   prune(): void {
@@ -49,6 +58,16 @@ export class PayloadIdCache {
     const key = this.getKey(fcuAttributes);
     const fullKey = this.getFullKey(fcuAttributes);
     const payloadInfo = this.payloadIdByFcuAttributes.get(key);
-    return payloadInfo?.fullKey === fullKey ? payloadInfo.payloadId : undefined;
+    return payloadInfo?.fullKey === fullKey &&
+      isSameInclusionList(payloadInfo.inclusionListTransactions, fcuAttributes.inclusionListTransactions)
+      ? payloadInfo.payloadId
+      : undefined;
   }
 }
+
+function isSameInclusionList(a?: bellatrix.Transactions, b?: bellatrix.Transactions): boolean {
+  if (a === undefined || b === undefined) {
+    return a === b;
+  }
+  return a.length === b.length && a.every((transaction, i) => byteArrayEquals(transaction, b[i]));
+}

package/src/execution/engine/restTransport.ts

@@ -1,6 +1,16 @@
 import {Type} from "@chainsafe/ssz";
 import {CELLS_PER_EXT_BLOB, ForkName, ForkSeq, isForkPostBellatrix} from "@lodestar/params";
-import {ExecutionPayload, ExecutionRequests, Root, RootHex, capella, deneb, electra, gloas} from "@lodestar/types";
+import {
+  ExecutionPayload,
+  ExecutionRequests,
+  Root,
+  RootHex,
+  bellatrix,
+  capella,
+  deneb,
+  electra,
+  gloas,
+} from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
 import {EndTimer, LodestarError, fromHex, strip0xPrefix, toHex, toRootHex} from "@lodestar/utils";
@@ -454,6 +464,10 @@ export class RestEngineTransport implements IEngineTransport {
       };
     });
   }
+
+  getInclusionList(): Promise<bellatrix.Transactions> {
+    throw Error("engine_getInclusionListV1 is not available over the REST engine API");
+  }
 }
 
 function toPayloadAttributesBellatrix(attributes: PayloadAttributes) {