@lodestar/beacon-node 1.46.0-dev.4c86702f24 → 1.46.0-dev.5e77d154c5

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.46.0-dev.4c86702f24",
+  "version": "1.46.0-dev.5e77d154c5",
   "type": "module",
   "exports": {
     ".": {
@@ -77,11 +77,11 @@
   ],
   "scripts": {
     "clean": "rm -rf lib && rm -f *.tsbuildinfo",
-    "build": "tsgo -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json",
     "build:watch": "pnpm run build --watch",
     "build:release": "pnpm clean && pnpm run build",
     "check-build": "node -e \"(async function() { await import('./lib/index.js') })()\"",
-    "check-types": "tsgo",
+    "check-types": "tsc",
     "lint": "biome check src/ test/",
     "lint:fix": "pnpm run lint --write",
     "test": "pnpm test:unit && pnpm test:e2e",
@@ -126,17 +126,17 @@
     "@libp2p/peer-id": "^6.0.4",
     "@libp2p/prometheus-metrics": "^5.0.14",
     "@libp2p/tcp": "^11.0.13",
-    "@lodestar/api": "^1.46.0-dev.4c86702f24",
-    "@lodestar/config": "^1.46.0-dev.4c86702f24",
-    "@lodestar/db": "^1.46.0-dev.4c86702f24",
-    "@lodestar/fork-choice": "^1.46.0-dev.4c86702f24",
-    "@lodestar/logger": "^1.46.0-dev.4c86702f24",
-    "@lodestar/params": "^1.46.0-dev.4c86702f24",
-    "@lodestar/reqresp": "^1.46.0-dev.4c86702f24",
-    "@lodestar/state-transition": "^1.46.0-dev.4c86702f24",
-    "@lodestar/types": "^1.46.0-dev.4c86702f24",
-    "@lodestar/utils": "^1.46.0-dev.4c86702f24",
-    "@lodestar/validator": "^1.46.0-dev.4c86702f24",
+    "@lodestar/api": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/config": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/db": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/fork-choice": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/logger": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/params": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/reqresp": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/state-transition": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/types": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/utils": "^1.46.0-dev.5e77d154c5",
+    "@lodestar/validator": "^1.46.0-dev.5e77d154c5",
     "@multiformats/multiaddr": "^13.0.1",
     "datastore-core": "^11.0.2",
     "datastore-level": "^12.0.2",
@@ -158,7 +158,7 @@
     "@libp2p/interface-internal": "^3.0.13",
     "@libp2p/logger": "^6.2.2",
     "@libp2p/utils": "^7.0.13",
-    "@lodestar/spec-test-util": "^1.46.0-dev.4c86702f24",
+    "@lodestar/spec-test-util": "^1.46.0-dev.5e77d154c5",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
@@ -175,5 +175,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "f3ea5e32becacc19c1b203b6a355a196e9d70635"
+  "gitHead": "06901e757968d25e5810ed5cd4a5ed8144a2f149"
 }

package/src/api/impl/config/constants.ts

@@ -12,6 +12,7 @@ import {
   BUILDER_PAYMENT_THRESHOLD_DENOMINATOR,
   BUILDER_PAYMENT_THRESHOLD_NUMERATOR,
   BUILDER_WITHDRAWAL_PREFIX,
+  BYTES_PER_FIELD_ELEMENT,
   COMPOUNDING_WITHDRAWAL_PREFIX,
   CONSOLIDATION_REQUEST_TYPE,
   DEPOSIT_CONTRACT_TREE_DEPTH,
@@ -26,6 +27,7 @@ import {
   DOMAIN_BUILDER_DEPOSIT,
   DOMAIN_CONTRIBUTION_AND_PROOF,
   DOMAIN_DEPOSIT,
+  DOMAIN_INCLUSION_LIST_COMMITTEE,
   DOMAIN_PROPOSER_PREFERENCES,
   DOMAIN_PTC_ATTESTER,
   DOMAIN_RANDAO,
@@ -131,6 +133,7 @@ export const specConstants = {
   // Deneb types
   BLOB_TX_TYPE: toHexByte(BLOB_TX_TYPE),
   VERSIONED_HASH_VERSION_KZG: toHexByte(VERSIONED_HASH_VERSION_KZG),
+  BYTES_PER_FIELD_ELEMENT,
 
   // electra
   UNSET_DEPOSIT_REQUESTS_START_INDEX,
@@ -148,6 +151,9 @@ export const specConstants = {
   DOMAIN_BUILDER_DEPOSIT,
   BUILDER_DEPOSIT_REQUEST_TYPE: toHexByte(BUILDER_DEPOSIT_REQUEST_TYPE),
   BUILDER_EXIT_REQUEST_TYPE: toHexByte(BUILDER_EXIT_REQUEST_TYPE),
+
+  // heze
+  DOMAIN_INCLUSION_LIST_COMMITTEE,
 };
 
 /** Convert single-byte numbers to hex strings for API spec compliance */

package/src/api/impl/validator/index.ts

@@ -342,9 +342,10 @@ export function getValidatorApi(
    * 3. ProduceBlock if the parentRoot (chain's current head is optimistic). However this doesn't
    *    need to be checked/aborted here as assembleBody would call EL's api for the latest
    *    executionStatus of the parentRoot. If still not validated, produceBlock will throw error.
-   *
-   * TODO/PENDING: SyncCommitteeSignatures should also be aborted, the best way to address this
-   *   is still in flux and will be updated as and when other CL's figure this out.
+   * 4. SyncCommitteeSignature (base sync committee message) is aborted in the validator client
+   *    (see SyncCommitteeService) when the head root it would sign is optimistic, since it is
+   *    produced from the head root without a beacon-node produce endpoint to gate here. Spec:
+   *    https://github.com/ethereum/consensus-specs/blob/v1.6.1/sync/optimistic.md#participating-in-sync-committees
    */
 
   function notOnOptimisticBlockRoot(beaconBlockRoot: Root): void {
@@ -1808,7 +1809,7 @@ export function getValidatorApi(
       const filteredRegistrations = registrations.filter((registration) => {
         const {pubkey} = registration.message;
         const validatorIndex = chain.pubkeyCache.getIndex(pubkey);
-        if (validatorIndex === null) return false;
+        if (validatorIndex === null || validatorIndex >= headState.validatorCount) return false;
 
         const validator = headState.getValidator(validatorIndex);
         const status = getValidatorStatus(validator, currentEpoch);

package/src/chain/archiveStore/archiveStore.ts

@@ -4,6 +4,7 @@ import {Checkpoint} from "@lodestar/types/phase0";
 import {callFnWhenAwait} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
 import {Metrics} from "../../metrics/metrics.js";
+import {callInNextEventLoop} from "../../util/eventLoop.js";
 import {isOptimisticBlock} from "../../util/forkChoice.js";
 import {JobItemQueue, isQueueErrorAborted} from "../../util/queue/index.js";
 import {ChainEvent} from "../emitter.js";
@@ -166,9 +167,25 @@ export class ArchiveStore {
   // Event handlers
   //-------------------------------------------------------------------------
   private onFinalizedCheckpoint = (finalized: CheckpointWithHex): void => {
-    this.jobQueue.push(finalized).catch((e) => {
-      if (!isQueueErrorAborted(e)) {
-        this.logger.error("Error queuing finalized checkpoint", {epoch: finalized.epoch}, e as Error);
+    // Decouple finalized-checkpoint processing from block import. This handler runs synchronously
+    // inside the `ChainEvent.forkChoiceFinalized` emit from `forkChoice.onBlock()` during
+    // `importBlock()`; deferring the work to the next event-loop tick keeps any failure here off the
+    // import call stack, so it can't abort `importBlock()` before `regen.processState()` caches the
+    // head post-state — the deep-sync wedge this PR fixes (#9716).
+    //
+    // `jobQueue.push()` can throw synchronously (queue aborted / full) or reject asynchronously;
+    // awaiting it inside the deferred callback funnels both failure modes into the one catch.
+    callInNextEventLoop(async () => {
+      try {
+        await this.jobQueue.push(finalized);
+      } catch (e) {
+        if (!isQueueErrorAborted(e)) {
+          this.logger.error(
+            "Error queuing finalized checkpoint",
+            {epoch: finalized.epoch, rootHex: finalized.rootHex},
+            e as Error
+          );
+        }
       }
     });
   };

package/src/chain/blocks/verifyExecutionPayloadEnvelope.ts

@@ -61,7 +61,7 @@ export function verifyExecutionPayloadEnvelope(
       `Prev randao mismatch between bid and payload bid=${toHex(bid.prevRandao)} payload=${toHex(payload.prevRandao)}`
     );
   }
-  if (bid.gasLimit !== payload.gasLimit) {
+  if (bid.gasLimit !== BigInt(payload.gasLimit)) {
     throw new Error(`Gas limit mismatch between payload and bid payload=${payload.gasLimit} bid=${bid.gasLimit}`);
   }
   if (!byteArrayEquals(bid.blockHash, payload.blockHash)) {

package/src/chain/errors/executionPayloadBid.ts

@@ -5,6 +5,7 @@ export enum ExecutionPayloadBidErrorCode {
   BUILDER_NOT_ELIGIBLE = "EXECUTION_PAYLOAD_BID_ERROR_BUILDER_NOT_ELIGIBLE",
   INVALID_BUILDER_VERSION = "EXECUTION_PAYLOAD_BID_ERROR_INVALID_BUILDER_VERSION",
   NON_ZERO_EXECUTION_PAYMENT = "EXECUTION_PAYLOAD_BID_ERROR_NON_ZERO_EXECUTION_PAYMENT",
+  INCOMPATIBLE_WITH_HEAD = "EXECUTION_PAYLOAD_BID_ERROR_INCOMPATIBLE_WITH_HEAD",
   BID_ALREADY_KNOWN = "EXECUTION_PAYLOAD_BID_ERROR_BID_ALREADY_KNOWN",
   BID_TOO_LOW = "EXECUTION_PAYLOAD_BID_ERROR_BID_TOO_LOW",
   BID_TOO_HIGH = "EXECUTION_PAYLOAD_BID_ERROR_BID_TOO_HIGH",
@@ -31,7 +32,14 @@ export type ExecutionPayloadBidErrorType =
   | {
       code: ExecutionPayloadBidErrorCode.NON_ZERO_EXECUTION_PAYMENT;
       builderIndex: BuilderIndex;
-      executionPayment: number;
+      executionPayment: bigint;
+    }
+  | {
+      code: ExecutionPayloadBidErrorCode.INCOMPATIBLE_WITH_HEAD;
+      slot: Slot;
+      parentBlockRoot: RootHex;
+      parentBlockHash: RootHex;
+      headBlockRoot: RootHex;
     }
   | {
       code: ExecutionPayloadBidErrorCode.BID_ALREADY_KNOWN;
@@ -73,9 +81,9 @@ export type ExecutionPayloadBidErrorType =
   | {
       code: ExecutionPayloadBidErrorCode.PROPOSER_PREFERENCES_GAS_LIMIT_MISMATCH;
       builderIndex: BuilderIndex;
-      bidGasLimit: number;
-      parentGasLimit: number;
-      targetGasLimit: number;
+      bidGasLimit: bigint;
+      parentGasLimit: bigint;
+      targetGasLimit: bigint;
     };
 
 export class ExecutionPayloadBidError extends GossipActionError<ExecutionPayloadBidErrorType> {}

package/src/chain/opPools/aggregatedAttestationPool.ts

@@ -234,6 +234,7 @@ export class AggregatedAttestationPool {
     const stateEpoch = state.epoch;
     const statePrevEpoch = stateEpoch - 1;
     const rootCache = new RootCache(state);
+    const gloasState = isStatePostGloas(state) ? state : null;
 
     const notSeenValidatorsFn = getNotSeenValidatorsFn(this.config, shufflingCache, state);
     const validateAttestationDataFn = getValidateAttestationDataFn(forkChoice, state);
@@ -361,7 +362,8 @@ export class AggregatedAttestationPool {
             inclusionDistance,
             stateEpoch,
             rootCache,
-            isStatePostGloas(state) ? state.executionPayloadAvailability : null
+            gloasState?.executionPayloadAvailability ?? null,
+            gloasState?.latestExecutionPayloadBid.slot ?? null
           );
 
           const weight =
@@ -431,7 +433,7 @@ export class AggregatedAttestationPool {
       );
     } else {
       const attestationGroupsByIndex = this.attestationGroupByIndexByDataHexBySlot.get(bySlot);
-      if (!attestationGroupsByIndex) throw Error(`No attestations for slot ${bySlot}`);
+      if (!attestationGroupsByIndex) return [];
       attestationGroupsArr = Array.from(attestationGroupsByIndex.values());
     }
 

package/src/chain/prepareNextSlot.ts

@@ -1,7 +1,14 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
-import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostBellatrix, isForkPostGloas} from "@lodestar/params";
+import {
+  ForkPostBellatrix,
+  ForkSeq,
+  SLOTS_PER_EPOCH,
+  isForkPostBellatrix,
+  isForkPostFulu,
+  isForkPostGloas,
+} from "@lodestar/params";
 import {
   IBeaconStateView,
   IBeaconStateViewBellatrix,
@@ -11,7 +18,7 @@ import {
   isStatePostBellatrix,
   isStatePostGloas,
 } from "@lodestar/state-transition";
-import {Bytes32, Slot} from "@lodestar/types";
+import {Bytes32, Slot, ValidatorIndex} from "@lodestar/types";
 import {Logger, fromHex, isErrorAborted, sleep} from "@lodestar/utils";
 import {GENESIS_SLOT, ZERO_HASH_HEX} from "../constants/constants.js";
 import {BuilderStatus} from "../execution/builder/http.js";
@@ -111,29 +118,36 @@ export class PrepareNextSlotScheduler {
         : null;
       const start = Date.now();
       // No need to wait for this or the clock drift
-      // Pre Bellatrix: we only do precompute state transition for the last slot of epoch
-      // For Bellatrix, we always do the `processSlots()` to prepare payload for the next slot
-      const prepareState = await this.chain.regen.getBlockSlotState(
-        headBlock,
-        prepareSlot,
-        // the slot 0 of next epoch will likely use this Previous Root Checkpoint state for state transition so we transfer cache here
-        // the resulting state with cache will be cached in Checkpoint State Cache which is used for the upcoming block processing
-        // for other slots dontTransferCached=true because we don't run state transition on this state
-        {dontTransferCache: !isEpochTransition},
-        RegenCaller.precomputeEpoch
-      );
-
       if (isForkPostBellatrix(fork)) {
-        const proposerIndex = prepareState.getBeaconProposer(prepareSlot);
+        let preparedState: IBeaconStateView | undefined;
+
+        const getProposerIndex = async (): Promise<ValidatorIndex> => {
+          if (isForkPostFulu(fork)) {
+            // getBeaconProposer covers the current + next epoch; should not throw
+            // PROPOSER_EPOCH_MISMATCH here due to the PREPARE_EPOCH_LIMIT check above.
+            return this.chain.getHeadState().getBeaconProposer(prepareSlot);
+          }
+          // the slot 0 of next epoch will likely use this Previous Root Checkpoint state for state transition so we transfer cache here
+          // the resulting state with cache will be cached in Checkpoint State Cache which is used for the upcoming block processing
+          // for other slots dontTransferCached=true because we don't run state transition on this state
+          preparedState = await this.chain.regen.getBlockSlotState(
+            headBlock,
+            prepareSlot,
+            {dontTransferCache: !isEpochTransition},
+            RegenCaller.precomputeEpoch
+          );
+          return preparedState.getBeaconProposer(prepareSlot);
+        };
+
+        const proposerIndex = await getProposerIndex();
         const feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
-        let updatedPrepareState = prepareState;
 
         if (feeRecipient) {
           // If we are proposing next slot, we need to predict if we can proposer-boost-reorg or not
           const proposerHead = this.chain.predictProposerHead(clockSlot);
           const {slot: proposerHeadSlot, blockRoot: proposerHeadRoot} = proposerHead;
 
-          // If we predict we can reorg, update prepareState with proposer head block
+          // If we predict we can reorg, we build on the proposer head (parent) block instead
           if (proposerHeadRoot !== headRoot || proposerHeadSlot !== headSlot) {
             this.logger.verbose("Weak head detected. May build on parent block instead", {
               proposerHeadSlot,
@@ -142,13 +156,6 @@ export class PrepareNextSlotScheduler {
               headRoot,
             });
             this.metrics?.weakHeadDetected.inc();
-            updatedPrepareState = await this.chain.regen.getBlockSlotState(
-              proposerHead,
-              prepareSlot,
-              // only transfer cache if epoch transition because that's the state we will use to stateTransition() the 1st block of epoch
-              {dontTransferCache: !isEpochTransition},
-              RegenCaller.predictProposerHead
-            );
             updatedHead = proposerHead;
           }
 
@@ -165,30 +172,41 @@ export class PrepareNextSlotScheduler {
           }
         }
 
-        if (!isStatePostBellatrix(updatedPrepareState)) {
+        // post-fulu we'll always reach here because preparedState is undefined
+        if (preparedState === undefined || updatedHead !== headBlock) {
+          preparedState = await this.chain.regen.getBlockSlotState(
+            updatedHead,
+            prepareSlot,
+            // only transfer cache if epoch transition because that's the state we will use to stateTransition() the 1st block of epoch
+            {dontTransferCache: !isEpochTransition},
+            updatedHead === headBlock ? RegenCaller.precomputeEpoch : RegenCaller.predictProposerHead
+          );
+        }
+
+        if (!isStatePostBellatrix(preparedState)) {
           throw new Error("Expected Bellatrix state for payload attributes");
         }
 
         let parentBlockHash: Bytes32;
         // Apply parent payload once here as it's reused by EL prep and SSE emit below
-        let stateAfterParentPayload: IBeaconStateViewBellatrix = updatedPrepareState;
-        if (isStatePostGloas(updatedPrepareState)) {
-          // Spec: should_build_on_full(store, head) — see produceBlockBody.ts for context.
+        let stateAfterParentPayload: IBeaconStateViewBellatrix = preparedState;
+        if (isStatePostGloas(preparedState)) {
+          // Spec: should_build_on_full(store, head, slot) - see produceBlockBody.ts for context.
           if (this.chain.forkChoice.shouldBuildOnFull(updatedHead, prepareSlot)) {
-            parentBlockHash = updatedPrepareState.latestExecutionPayloadBid.blockHash;
+            parentBlockHash = preparedState.latestExecutionPayloadBid.blockHash;
             // Skip applying parent payload unless we're proposing the next slot or have to emit payload_attributes events
             if (feeRecipient !== undefined || this.chain.opts.emitPayloadAttributes === true) {
               const parentExecutionRequests = await this.chain.getParentExecutionRequests(
                 updatedHead.slot,
                 updatedHead.blockRoot
               );
-              stateAfterParentPayload = updatedPrepareState.withParentPayloadApplied(parentExecutionRequests);
+              stateAfterParentPayload = preparedState.withParentPayloadApplied(parentExecutionRequests);
             }
           } else {
-            parentBlockHash = updatedPrepareState.latestExecutionPayloadBid.parentBlockHash;
+            parentBlockHash = preparedState.latestExecutionPayloadBid.parentBlockHash;
           }
         } else {
-          parentBlockHash = updatedPrepareState.latestExecutionPayloadHeader.blockHash;
+          parentBlockHash = preparedState.latestExecutionPayloadHeader.blockHash;
         }
 
         if (feeRecipient) {
@@ -221,7 +239,7 @@ export class PrepareNextSlotScheduler {
           });
         }
 
-        this.computeStateHashTreeRoot(updatedPrepareState, isEpochTransition);
+        this.computeStateHashTreeRoot(preparedState, isEpochTransition);
 
         // If emitPayloadAttributes is true emit a SSE payloadAttributes event for
         // every slot. Without the flag, only emit the event if we are proposing in the next slot.
@@ -239,7 +257,14 @@ export class PrepareNextSlotScheduler {
           this.chain.emitter.emit(routes.events.EventType.payloadAttributes, {data, version: fork});
         }
       } else {
-        this.computeStateHashTreeRoot(prepareState, isEpochTransition);
+        // Pre-bellatrix only reaches here at an epoch transition to precompute the next epoch state
+        const preparedState = await this.chain.regen.getBlockSlotState(
+          headBlock,
+          prepareSlot,
+          {dontTransferCache: !isEpochTransition},
+          RegenCaller.precomputeEpoch
+        );
+        this.computeStateHashTreeRoot(preparedState, isEpochTransition);
       }
 
       // assuming there is no reorg, it caches the checkpoint state & helps avoid doing a full state transition in the next slot

package/src/chain/produceBlock/produceBlockBody.ts

@@ -1,3 +1,4 @@
+import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
 import {IForkChoice, ProtoBlock, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {
@@ -10,6 +11,7 @@ import {
   ForkPostGloas,
   ForkPreGloas,
   ForkSeq,
+  INCLUSION_LIST_COMMITTEE_SIZE,
   isForkPostAltair,
   isForkPostBellatrix,
   isForkPostGloas,
@@ -49,6 +51,7 @@ import {
   electra,
   fulu,
   gloas,
+  heze,
   ssz,
 } from "@lodestar/types";
 import {GWEI_TO_WEI, Logger, byteArrayEquals, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
@@ -276,7 +279,7 @@ export async function produceBlockBody<T extends BlockType>(
     let parentExecutionRequests: gloas.ExecutionRequests;
     // Apply parent payload once here as it's reused by EL prep and voluntary exit filtering below
     let stateAfterParentPayload: IBeaconStateViewBellatrix = currentState;
-    // Spec: should_build_on_full(store, head). `parentBlock` is the proposer's head
+    // Spec: should_build_on_full(store, head, slot). `parentBlock` is the proposer's head
     // (set by chain.getProposerHead(slot)). Returns false when the PTC majority signalled
     // the blob data is not available or the payload was not timely, forcing a build on EMPTY (reorg).
     const isBuildingOnFull = this.forkChoice.shouldBuildOnFull(parentBlock, blockSlot);
@@ -345,14 +348,18 @@ export async function produceBlockBody<T extends BlockType>(
       blockHash: executionPayload.blockHash,
       prevRandao: currentState.getRandaoMix(currentState.epoch),
       feeRecipient: executionPayload.feeRecipient,
-      gasLimit: executionPayload.gasLimit,
+      gasLimit: BigInt(executionPayload.gasLimit),
       builderIndex: BUILDER_INDEX_SELF_BUILD,
       slot: blockSlot,
       value: 0,
-      executionPayment: 0,
+      executionPayment: 0n,
       blobKzgCommitments: blobsBundle.commitments,
       executionRequestsRoot: ssz.gloas.ExecutionRequests.hashTreeRoot(executionRequests as gloas.ExecutionRequests),
     };
+    if (ForkSeq[fork] >= ForkSeq.heze) {
+      // TODO HEZE: populate from inclusion list pool once IL aggregation is wired up.
+      (bid as heze.ExecutionPayloadBid).inclusionListBits = BitArray.fromBitLen(INCLUSION_LIST_COMMITTEE_SIZE);
+    }
     const signedBid: gloas.SignedExecutionPayloadBid = {
       message: bid,
       signature: G2_POINT_AT_INFINITY,
@@ -927,6 +934,11 @@ function preparePayloadAttributes(
     );
   }
 
+  if (ForkSeq[fork] >= ForkSeq.heze) {
+    // TODO HEZE: populate from inclusion list pool once IL aggregation is wired up.
+    (payloadAttributes as heze.SSEPayloadAttributes["payloadAttributes"]).inclusionListTransactions = [];
+  }
+
   return payloadAttributes;
 }
 
@@ -949,7 +961,7 @@ function getProposerTargetGasLimit(
   prepareSlot: Slot,
   parentBlockRoot: Root,
   parentBlockHash: Bytes32
-): number {
+): bigint {
   const parentBlockRootHex = toRootHex(parentBlockRoot);
   const parentBlock = chain.forkChoice.getBlockHexDefaultStatus(parentBlockRootHex);
   const dependentRootHex = (() => {
@@ -979,7 +991,7 @@ function getProposerTargetGasLimit(
       `Cannot resolve parent payload gas_limit for proposer targetGasLimit fallback parentBlockRoot=${parentBlockRootHex} parentBlockHash=${toRootHex(parentBlockHash)}`
     );
   }
-  return parentPayloadVariant.executionPayloadGasLimit;
+  return BigInt(parentPayloadVariant.executionPayloadGasLimit);
 }
 
 export async function produceCommonBlockBody<T extends BlockType>(

package/src/chain/seenCache/seenExecutionPayloadBids.ts

@@ -1,4 +1,4 @@
-import {BuilderIndex, Slot} from "@lodestar/types";
+import {BuilderIndex, RootHex, Slot} from "@lodestar/types";
 import {MapDef} from "@lodestar/utils";
 
 /**
@@ -7,29 +7,42 @@ import {MapDef} from "@lodestar/utils";
 const SLOTS_RETAINED = 2;
 
 /**
- * Tracks execution payload bids we've already seen per (slot, builder).
+ * Tracks execution payload bids we've already seen per
+ * (slot, builder, parent block hash, parent block root).
  */
 export class SeenExecutionPayloadBids {
-  private readonly builderIndexesBySlot = new MapDef<Slot, Set<BuilderIndex>>(() => new Set<BuilderIndex>());
+  private readonly branchesByBuilderBySlot = new MapDef<Slot, MapDef<BuilderIndex, Set<string>>>(
+    () => new MapDef<BuilderIndex, Set<string>>(() => new Set<string>())
+  );
   private lowestPermissibleSlot: Slot = 0;
 
-  isKnown(slot: Slot, builderIndex: BuilderIndex): boolean {
-    return this.builderIndexesBySlot.get(slot)?.has(builderIndex) === true;
+  isKnown(slot: Slot, builderIndex: BuilderIndex, parentBlockHash: RootHex, parentBlockRoot: RootHex): boolean {
+    return (
+      this.branchesByBuilderBySlot.get(slot)?.get(builderIndex)?.has(branchKey(parentBlockHash, parentBlockRoot)) ===
+      true
+    );
   }
 
-  add(slot: Slot, builderIndex: BuilderIndex): void {
+  add(slot: Slot, builderIndex: BuilderIndex, parentBlockHash: RootHex, parentBlockRoot: RootHex): void {
     if (slot < this.lowestPermissibleSlot) {
       throw Error(`slot ${slot} < lowestPermissibleSlot ${this.lowestPermissibleSlot}`);
     }
-    this.builderIndexesBySlot.getOrDefault(slot).add(builderIndex);
+    this.branchesByBuilderBySlot
+      .getOrDefault(slot)
+      .getOrDefault(builderIndex)
+      .add(branchKey(parentBlockHash, parentBlockRoot));
   }
 
   prune(currentSlot: Slot): void {
     this.lowestPermissibleSlot = Math.max(currentSlot - SLOTS_RETAINED, 0);
-    for (const slot of this.builderIndexesBySlot.keys()) {
+    for (const slot of this.branchesByBuilderBySlot.keys()) {
       if (slot < this.lowestPermissibleSlot) {
-        this.builderIndexesBySlot.delete(slot);
+        this.branchesByBuilderBySlot.delete(slot);
       }
     }
   }
 }
+
+function branchKey(parentBlockHash: RootHex, parentBlockRoot: RootHex): string {
+  return `${parentBlockHash}:${parentBlockRoot}`;
+}

package/src/chain/validation/blobSidecar.ts

@@ -111,7 +111,7 @@ export async function validateGossipBlobSidecar(
 
   // [REJECT] The blob is from a higher slot than its parent.
   if (parentBlock.slot >= blobSlot) {
-    throw new BlobSidecarGossipError(GossipAction.IGNORE, {
+    throw new BlobSidecarGossipError(GossipAction.REJECT, {
       code: BlobSidecarErrorCode.NOT_LATER_THAN_PARENT,
       parentSlot: parentBlock.slot,
       slot: blobSlot,

package/src/chain/validation/dataColumnSidecar.ts

@@ -2,15 +2,16 @@ import {ChainConfig, ChainForkConfig} from "@lodestar/config";
 import {
   KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH,
   KZG_COMMITMENTS_SUBTREE_INDEX,
+  MIN_SEED_LOOKAHEAD,
   NUMBER_OF_COLUMNS,
+  isForkPostFulu,
 } from "@lodestar/params";
 import {
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   getBlockHeaderProposerSignatureSetByHeaderSlot,
-  getBlockHeaderProposerSignatureSetByParentStateSlot,
 } from "@lodestar/state-transition";
-import {DataColumnSidecar, Root, Slot, SubnetID, fulu, gloas, ssz} from "@lodestar/types";
+import {DataColumnSidecar, Root, Slot, SubnetID, ValidatorIndex, fulu, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex, verifyMerkleBranch} from "@lodestar/utils";
 import {BeaconMetrics} from "../../metrics/metrics/beacon.js";
 import {Metrics} from "../../metrics/metrics.js";
@@ -104,19 +105,23 @@ export async function validateGossipFuluDataColumnSidecar(
     });
   }
 
-  // getBlockSlotState also checks for whether the current finalized checkpoint is an ancestor of the block.
-  // As a result, we throw an IGNORE (whereas the spec says we should REJECT for this scenario).
-  // this is something we should change this in the future to make the code airtight to the spec.
   // 7) [REJECT] The sidecar's block's parent passes validation.
-  const blockState = await chain.regen
-    .getBlockSlotState(parentBlock, blockHeader.slot, {dontTransferCache: true}, RegenCaller.validateGossipDataColumn)
-    .catch(() => {
-      throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
-        code: DataColumnSidecarErrorCode.PARENT_UNKNOWN,
-        parentRoot,
-        slot: blockHeader.slot,
-      });
-    });
+  // Post-fulu, we can use parent state to get expected proposer index thanks to proposer lookahead
+  const parentEpoch = computeEpochAtSlot(parentBlock.slot);
+  const blockEpoch = computeEpochAtSlot(blockHeader.slot);
+  const getProposerIndex = async (): Promise<ValidatorIndex> => {
+    if (isForkPostFulu(chain.config.getForkName(parentBlock.slot)) && blockEpoch - parentEpoch <= MIN_SEED_LOOKAHEAD) {
+      const parentState = await chain.regen.getState(parentBlock.stateRoot, RegenCaller.validateGossipDataColumn);
+      return parentState.getBeaconProposer(blockHeader.slot);
+    }
+    const blockState = await chain.regen.getBlockSlotState(
+      parentBlock,
+      blockHeader.slot,
+      {dontTransferCache: true},
+      RegenCaller.validateGossipDataColumn
+    );
+    return blockState.getBeaconProposer(blockHeader.slot);
+  };
 
   // 13) [REJECT] The sidecar is proposed by the expected proposer_index for the block's slot in the context of the current
   //              shuffling (defined by block_header.parent_root/block_header.slot). If the proposer_index cannot
@@ -124,7 +129,13 @@ export async function validateGossipFuluDataColumnSidecar(
   //              while proposers for the block's branch are calculated -- in such a case do not REJECT, instead IGNORE
   //              this message.
   const proposerIndex = blockHeader.proposerIndex;
-  const expectedProposerIndex = blockState.getBeaconProposer(blockHeader.slot);
+  const expectedProposerIndex = await getProposerIndex().catch(() => {
+    throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
+      code: DataColumnSidecarErrorCode.PARENT_UNKNOWN,
+      parentRoot,
+      slot: blockHeader.slot,
+    });
+  });
 
   if (proposerIndex !== expectedProposerIndex) {
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
@@ -137,9 +148,8 @@ export async function validateGossipFuluDataColumnSidecar(
   // 5) [REJECT] The proposer signature of sidecar.signed_block_header, is valid with respect to the block_header.proposer_index pubkey.
   const signature = dataColumnSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockHeader.slot, blockRootHex, signature)) {
-    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+    const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
       chain.config,
-      blockState.slot,
       dataColumnSidecar.signedBlockHeader
     );