@lodestar/beacon-node 1.46.0-dev.e6f04acd82 → 1.46.0-dev.f0f5d069e2

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

@@ -31,23 +31,40 @@ export function assertLinearChainSegment(
   payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
   parentBlock: ProtoBlock | null
 ): ChainSegmentResult {
+  if (blocks.length === 0) {
+    return {warnings: null};
+  }
+
   const warnings: OrphanedPayloadEnvelope[] = [];
 
-  // 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
-  let currentExecHash: string | null = parentBlock?.executionPayloadBlockHash ?? null;
-  // Checkpoint sync first batch: parent is the anchor PENDING whose executionPayloadBlockHash
-  // is the inherited parentBlockHash semantic (= grandparent's payload), not its own payload.
-  // If parent's own payload envelope arrives in this batch, advance currentExecHash to that
-  // payload's blockHash so the segment validation sees the true EL chain head.
+  let parentExecHash: string | null = parentBlock?.executionPayloadBlockHash ?? null;
   if (parentBlock !== null) {
     const parentPayloadInput = payloadEnvelopes?.get(parentBlock.slot);
     if (parentPayloadInput?.hasPayloadEnvelope()) {
-      currentExecHash = parentPayloadInput.getBlockHashHex();
+      // Checkpoint-sync first batch: the anchor is stored PENDING with the inherited (grandparent)
+      // hash, not its own payload. Its payload envelope is in this batch, so use that blockHash as
+      // the real parent EL head.
+      parentExecHash = parentPayloadInput.getBlockHashHex();
     }
   }
+
+  // Track the expected execution payload block hash through the segment, seeded from the FIRST
+  // block's own bid
+  const firstBlockMessage = blocks[0].getBlock().message;
+  let currentExecHash: string | null = isGloasBeaconBlock(firstBlockMessage)
+    ? toRootHex(firstBlockMessage.body.signedExecutionPayloadBid.message.parentBlockHash)
+    : null;
+
+  // First block must build on the parent's EL head. PARENT_PAYLOAD_UNKNOWN (vs the in-segment
+  // NON_LINEAR_PAYLOAD_ROOTS below) tells range sync this is a parent-link problem, not an in-batch one.
+  if (parentExecHash !== null && currentExecHash !== null && currentExecHash !== parentExecHash) {
+    throw new BlockError(blocks[0].getBlock(), {
+      code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+      parentRoot: toRootHex(firstBlockMessage.parentRoot),
+      parentBlockHash: currentExecHash,
+    });
+  }
+
   // 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;
@@ -76,8 +93,7 @@ export function assertLinearChainSegment(
     }
 
     if (isGloasBeaconBlock(block.message)) {
-      // Bid check fires only when we have a seeded execution hash. With parentBlock=null the
-      // chain is seeded mid-segment by the first FULL envelope.
+      // currentExecHash and prevExecHash are only null for a pre-gloas first block (fork-transition segment); always set post-gloas.
       if (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.
@@ -86,22 +102,13 @@ export function assertLinearChainSegment(
           // 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) {
-            // i === 0 compares against the seeded fork-choice parent (segment boundary); i > 0
-            // compares against the in-segment predecessor's payload (broken link inside the segment).
-            throw new BlockError(
-              block,
-              i === 0
-                ? {
-                    code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
-                    parentRoot: toRootHex(block.message.parentRoot),
-                    parentBlockHash: bidParentHash,
-                  }
-                : {
-                    code: BlockErrorCode.NON_LINEAR_PAYLOAD_ROOTS,
-                    parentBlockHash: bidParentHash,
-                    expectedBlockHash: currentExecHash,
-                  }
-            );
+            // Broken link inside the segment: throw NON_LINEAR_PAYLOAD_ROOTS instead of PARENT_PAYLOAD_UNKNOWN
+            // this is important for range sync to handle accordingly
+            throw new BlockError(block, {
+              code: BlockErrorCode.NON_LINEAR_PAYLOAD_ROOTS,
+              parentBlockHash: bidParentHash,
+              expectedBlockHash: currentExecHash,
+            });
           }
           if (lastFullSlot !== null && payloadEnvelopes !== null) {
             const orphanedInput = payloadEnvelopes.get(lastFullSlot);

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

@@ -0,0 +1,50 @@
+export const GLOAS_POLAR_BEAR_BANNER = String.raw`
+
+                               __           .    .- '%%%░░░░░
+                              /  '-.       ,    '    '%%%░░░░
+                      _.--""""--.._;          . * .-' '%%%%░░
+      \ /          _.""    .'       '-._         '  .   '%%%%
+       L         .";      ;           ; '-.     .   / ' * '""
+      Ø         / /     .'      '    ;     '.     '     ;  |
+     D         / ;     e     ' ) ( ' ;       \     .  .'   ,:
+      E       ; :      P      ( ' )  :     '-.\          '  '
+       S      ; ;      B       ).(    '.      ';      '   '
+        T     : :      S      (/:\)     \      :
+       A      : \      ':     / : \      \   '.;
+      R       \ \      ';     \\ //       ;    ;
+     / \       \ : .'   \      \|/        |   /
+                '>'      :      '       '.;   |
+                 / ,'    /             '.  ;/ _\
+                ;,'     ;    '.        '.;    '-.
+               ;' .'   :    '. '.       / \, \ \ \
+ \             :,'     :      '. '. \  ; ::\_/_/_/::
+ ~|         .-=:.-"   -,-   "-.,=-.\ ;.; :::; ; ;::
+ ~|\        |('.'      :       .')| \: '.  :::::::
+ ~|:\        \\/       :       \//   ;   \              _____
+ ~~\:\     ■  :       .:.       :  _/     ;             \hjw:
+ ~~~\/     |  ;                 ;  ;      |              \"""
+ ~~.'      ■   :    _     _    ;  /       ;              /|~~
+ ~/        |    '. \';   ;'/ .' .'       /              /:|~~
+ |         ■      !  :   :  !_.'        /           .--::/~~~
+ |\___     |       '.:   :.'/\         ;      ____.':|:|/~~~~
+ \:::|\    ■         \'_'/  | :       :   ___/|:::|:'"""~~~~~
+ ~'""|:\   |         ;"^"   | !       :__/|::|/""""~~~~~~~~~~
+ ~~~~\::\_____     .-'      | ;       |::|/""~~~~~~~~~~~~~~~~
+ ~~~~~\:|::::|\   / / /    / /       /"""~~~~~~~~~~~~~~~~~~~~
+ ~~~~~~\|::::|:'--\_\_\__.'-|       ;~~~~~~~~~~~~~~~~~~~~~~~~
+ ~~~~~~~~""""~\::::::::::::/      .'~~~~~~~~~~~~~<><~~~~~~~~~
+ ~~~~~~~~~~~~~~""""'"""".-'      /~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~~~~~~~__,------.__.--/ , ,  , |/--._~~~~~~~~~~~~~~~~~~~~~~~
+ ~~~~~~/   |     .    :\|  |  |v'     \__~~~~~~~~~~~~~~~~~~~~
+ ~~~~~|\   ■    /:\   :::v-;v-'::        \_~~~~~~~~~~~~~~~~~~
+ ~~~~~\:\      / : \   :::::::::           \~~~~~~~~~~~~~~~~~
+ ~~~~~~\|'-.  /  :  \                      /|~~~~~~~~~~~~~~~~
+ ~~~~~~~~': \ \'. ,'/  ___            ____/:/~~~~~~~~~<><~~~~
+ ~~~~~~~~~~\|: \ ' /  /|:|\          /|:::|/~~~~~~~~~~~~~~~~~
+ ~~~~~~~~~~~|:  \:/  //"""\\        /:/"""~~~~~~~~~~~~~~~~~~~
+ ~~~><>~~~~~|\   '  //~~~~~\\______/:/~~~~~~~~~~~~~~~~~~~~~~~
+ ~~~~~~~~~~~'|\____//~~~~~~~\|GLOAS|/~~~~~~~~<><~~~~~~~~~~~~~
+ ~~~~~~~~~~~~\|:::|/~~~~~~~~~'"""""'~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~~~~~~~~~~~~~'"""'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~eth
+`;

package/src/chain/blocks/verifyBlock.ts

@@ -1,7 +1,13 @@
 import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
 import {ForkName, ForkSeq, isForkPostFulu} from "@lodestar/params";
-import {DataAvailabilityStatus, IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
-import {IndexedAttestation, Slot, deneb} from "@lodestar/types";
+import {
+  DataAvailabilityStatus,
+  IBeaconStateView,
+  computeEpochAtSlot,
+  signedBlockToSignedHeader,
+} from "@lodestar/state-transition";
+import {IndexedAttestation, Slot, deneb, ssz} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
 import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import type {BeaconChain} from "../chain.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
@@ -13,6 +19,7 @@ import {ImportBlockOpts} from "./types.js";
 import {DENEB_BLOWFISH_BANNER} from "./utils/blowfishBanner.js";
 import {ELECTRA_GIRAFFE_BANNER} from "./utils/giraffeBanner.js";
 import {CAPELLA_OWL_BANNER} from "./utils/ownBanner.js";
+import {GLOAS_POLAR_BEAR_BANNER} from "./utils/polarBearBanner.js";
 import {FULU_ZEBRA_BANNER} from "./utils/zebraBanner.js";
 import {verifyBlocksDataAvailability} from "./verifyBlocksDataAvailability.js";
 import {SegmentExecStatus, verifyBlocksExecutionPayload} from "./verifyBlocksExecutionPayloads.js";
@@ -203,6 +210,20 @@ export async function verifyBlocksInEpoch(
       // maybe chain with the above verifyBlocksSignatures()
     ]);
 
+    if (opts.skipVerifyBlockSignatures !== true) {
+      for (const block of blocks) {
+        const {slot, proposerIndex} = block.message;
+        const signedBlockHeader = signedBlockToSignedHeader(this.config, block);
+        const blockRoot = toRootHex(ssz.phase0.BeaconBlockHeader.hashTreeRoot(signedBlockHeader.message));
+        this.seenBlockProposers.observeBlockRoot(slot, proposerIndex, blockRoot, signedBlockHeader);
+        // Only produce a slashing while importing the block. A block that is verified before it is published
+        // must not be treated as equivocation evidence since it may never be seen by the network
+        if (opts.verifyOnly !== true && this.seenBlockProposers.isEquivocating(slot, proposerIndex)) {
+          this.processProposerEquivocation(slot, proposerIndex);
+        }
+      }
+    }
+
     if (opts.verifyOnly !== true) {
       const fromForkBoundary = this.config.getForkBoundaryAtEpoch(computeEpochAtSlot(parentBlock.slot));
       const toForkBoundary = this.config.getForkBoundaryAtEpoch(computeEpochAtSlot(lastBlock.message.slot));
@@ -230,6 +251,11 @@ export async function verifyBlocksInEpoch(
             this.logger.info("Activating peerDAS", {epoch: this.config.FULU_FORK_EPOCH});
             break;
 
+          case ForkName.gloas:
+            this.logger.info(GLOAS_POLAR_BEAR_BANNER);
+            this.logger.info("Activating ePBS", {epoch: this.config.GLOAS_FORK_EPOCH});
+            break;
+
           default:
         }
       }

package/src/chain/chain.ts

@@ -130,6 +130,7 @@ import {CPStateDatastore} from "./stateCache/datastore/types.js";
 import {FIFOBlockStateCache} from "./stateCache/fifoBlockStateCache.js";
 import {PersistentCheckpointStateCache} from "./stateCache/persistentCheckpointsCache.js";
 import {CheckpointStateCache} from "./stateCache/types.js";
+import {validateApiProposerSlashing} from "./validation/proposerSlashing.js";
 import {ValidatorMonitor} from "./validatorMonitor.js";
 
 /**
@@ -200,6 +201,8 @@ export class BeaconChain implements IBeaconChain {
   readonly seenAggregatedAttestations: SeenAggregatedAttestations;
   readonly seenExecutionPayloadBids = new SeenExecutionPayloadBids();
   readonly seenBlockProposers = new SeenBlockProposers();
+  /** Proposer indexes with an in-flight proposer slashing production */
+  private readonly producingProposerSlashing = new Set<ValidatorIndex>();
   readonly seenSyncCommitteeMessages = new SeenSyncCommitteeMessages();
   readonly seenContributionAndProof: SeenContributionAndProof;
   readonly seenAttestationDatas: SeenAttestationDatas;
@@ -1163,6 +1166,59 @@ export class BeaconChain implements IBeaconChain {
     return this.payloadEnvelopeProcessor.processPayloadEnvelopeJob(payloadInput, opts);
   }
 
+  processProposerEquivocation(blockSlot: Slot, proposerIndex: ValidatorIndex): void {
+    this.produceProposerSlashing(blockSlot, proposerIndex).catch((e) => {
+      this.logger.debug("Error producing proposer slashing", {slot: blockSlot, proposerIndex}, e as Error);
+    });
+  }
+
+  /** Produce a proposer slashing from two conflicting signed block headers observed for the same slot and proposer */
+  private async produceProposerSlashing(blockSlot: Slot, proposerIndex: ValidatorIndex): Promise<void> {
+    if (
+      this.opts.disableProposerSlashings === true ||
+      this.opPool.hasSeenProposerSlashing(proposerIndex) ||
+      this.producingProposerSlashing.has(proposerIndex)
+    ) {
+      return;
+    }
+
+    const headers = this.seenBlockProposers.getEquivocationHeaders(blockSlot, proposerIndex);
+    if (headers === null) {
+      return;
+    }
+
+    this.producingProposerSlashing.add(proposerIndex);
+    try {
+      const [header1, header2] = headers;
+      // ProposerSlashing uses the bigint variant of the signed block header, see types package for details
+      const proposerSlashing: phase0.ProposerSlashing = {
+        signedHeader1: {
+          message: {...header1.message, slot: BigInt(header1.message.slot)},
+          signature: header1.signature,
+        },
+        signedHeader2: {
+          message: {...header2.message, slot: BigInt(header2.message.slot)},
+          signature: header2.signature,
+        },
+      };
+
+      try {
+        await validateApiProposerSlashing(this, proposerSlashing);
+      } catch (e) {
+        this.logger.debug("Produced proposer slashing is not valid", {slot: blockSlot, proposerIndex}, e as Error);
+        return;
+      }
+
+      this.opPool.insertProposerSlashing(proposerSlashing);
+      this.emitter.emit(routes.events.EventType.proposerSlashing, proposerSlashing);
+      this.emitter.emit(ChainEvent.publishProposerSlashing, proposerSlashing);
+      this.metrics?.opPool.proposerSlashingsProduced.inc();
+      this.logger.info("Produced proposer slashing from observed equivocation", {slot: blockSlot, proposerIndex});
+    } finally {
+      this.producingProposerSlashing.delete(proposerIndex);
+    }
+  }
+
   getStatus(): Status {
     const head = this.forkChoice.getHead();
     const finalizedCheckpoint = this.forkChoice.getFinalizedCheckpoint();

package/src/chain/emitter.ts

@@ -50,6 +50,11 @@ export enum ChainEvent {
    * and are ready to be published.
    */
   publishBlobSidecars = "publishBlobSidecars",
+  /**
+   * This event signals that a proposer slashing has been produced from an observed equivocation
+   * and is ready to be published.
+   */
+  publishProposerSlashing = "publishProposerSlashing",
   /**
    * Trigger an update of status so reqresp by peers have current earliestAvailableSlot
    */
@@ -110,6 +115,8 @@ export type IChainEvents = ApiEvents & {
 
   [ChainEvent.publishBlobSidecars]: (sidecars: deneb.BlobSidecar[]) => void;
 
+  [ChainEvent.publishProposerSlashing]: (proposerSlashing: phase0.ProposerSlashing) => void;
+
   [ChainEvent.updateStatus]: () => void;
 
   // Sync events that are chain->chain. Initiated from network requests but do not cross the network

package/src/chain/interface.ts

@@ -262,6 +262,9 @@ export interface IBeaconChain {
   /** Process execution payload envelope: verify, import to fork choice, and persist to DB */
   processExecutionPayload(payloadInput: PayloadEnvelopeInput, opts?: ImportPayloadOpts): Promise<void>;
 
+  /** Produce and publish a proposer slashing from an observed equivocation. Does not throw, only logs errors */
+  processProposerEquivocation(blockSlot: Slot, proposerIndex: ValidatorIndex): void;
+
   getStatus(): Status;
 
   recomputeForkChoiceHead(caller: ForkchoiceCaller): ProtoBlock;

package/src/chain/options.ts

@@ -37,6 +37,8 @@ export type IChainOptions = BlockProcessOpts &
     suggestedFeeRecipient: string;
     graffitiAppend?: boolean;
     maxSkipSlots?: number;
+    /** Do not produce proposer slashings from observed equivocations and do not include proposer slashings in produced blocks */
+    disableProposerSlashings?: boolean;
     /** Ensure blobs returned by the execution engine are valid */
     sanityCheckExecutionEngineBlobs?: boolean;
     /** Max number of produced blobs by local validators to cache */
@@ -122,6 +124,7 @@ export const defaultChainOptions: IChainOptions = {
   // for gossip block validation, it's unlikely we see a reorg with 32 slots
   // for attestation validation, having this value ensures we don't have to regen states most of the time
   maxSkipSlots: 32,
+  disableProposerSlashings: false,
   broadcastValidationStrictness: "warn",
   // should be less than or equal to MIN_SIGNATURE_SETS_TO_BATCH_VERIFY
   // batching too much may block the I/O thread so if useWorker=false, suggest this value to be 32

package/src/chain/prepareNextSlot.ts

@@ -1,19 +1,29 @@
 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 {getFinalizedExecutionBlockHash, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {
+  ForkPostBellatrix,
+  ForkSeq,
+  SLOTS_PER_EPOCH,
+  isForkPostBellatrix,
+  isForkPostFulu,
+  isForkPostGloas,
+} from "@lodestar/params";
+import {
+  GLOAS_PREVERIFY_WINDOW_EPOCHS,
   IBeaconStateView,
   IBeaconStateViewBellatrix,
+  MAX_BUILDER_DEPOSITS_PER_SLOT,
   StateHashTreeRootSource,
   computeEpochAtSlot,
   computeTimeAtSlot,
   isStatePostBellatrix,
+  isStatePostFulu,
   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 {GENESIS_SLOT} from "../constants/constants.js";
 import {BuilderStatus} from "../execution/builder/http.js";
 import {Metrics} from "../metrics/index.js";
 import {ClockEvent} from "../util/clock.js";
@@ -30,6 +40,11 @@ export const PREPARE_NEXT_SLOT_BPS = 6667;
 /* We don't want to do more epoch transition than this */
 const PREPARE_EPOCH_LIMIT = 1;
 
+/* Fraction of a slot (out of 10_000) the pre-Gloas builder-deposit pre-verify may spend per tick.
+ * 2000 = 20% of slot (2.4s on mainnet), within the spare window left after PREPARE_NEXT_SLOT_BPS.
+ * Expressed in bps so it scales with slot duration (mainnet vs minimal/devnet). */
+const BUILDER_PREVERIFY_LIMIT_BPS = 2000;
+
 /**
  * At Bellatrix, if we are responsible for proposing in next slot, we want to prepare payload
  * 4s before the start of next slot at PREPARE_NEXT_SLOT_BPS of the current slot.
@@ -110,30 +125,38 @@ export class PrepareNextSlotScheduler {
         ? this.metrics?.precomputeNextEpochTransition.duration.startTimer()
         : null;
       const start = Date.now();
+      let feeRecipient: string | undefined;
       // 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);
-        const feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
-        let updatedPrepareState = prepareState;
+        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();
+        feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
 
         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 +165,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 +181,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)) {
+        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) {
@@ -196,9 +223,8 @@ export class PrepareNextSlotScheduler {
             computeTimeAtSlot(this.config, prepareSlot, this.chain.genesisTime) - Date.now() / 1000;
           this.metrics?.blockPayload.payloadAdvancePrepTime.observe(preparationTime);
 
-          const safeBlockHash = getSafeExecutionBlockHash(this.chain.forkChoice);
-          const finalizedBlockHash =
-            this.chain.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
+          const safeBlockHash = getSafeExecutionBlockHash(this.chain.forkChoice, this.logger);
+          const finalizedBlockHash = getFinalizedExecutionBlockHash(this.chain.forkChoice, this.logger);
 
           // awaiting here instead of throwing an async call because there is no other task
           // left for scheduler and this gives nice semantics to catch and log errors in the
@@ -221,7 +247,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 +265,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
@@ -262,6 +295,74 @@ export class PrepareNextSlotScheduler {
         });
 
         precomputeEpochTransitionTimer?.();
+
+        // Nothing more to do on an epoch-transition slot: that precompute already ran a full (>1s)
+        // epoch transition, so we don't pile the builder-deposit pre-verify (below) on top of it.
+        return;
+      }
+
+      // Pre-verify builder-deposit signatures in the GLOAS_PREVERIFY_WINDOW_EPOCHS epochs leading
+      // up to the Gloas fork, off the block-import hot path, so onboardBuildersFromPendingDeposits
+      // at the transition is mostly cache hits. Reached only on non-epoch-transition slots (the
+      // epoch-transition branch returned above). Runs on the head state — its pendingDeposits are
+      // what the fork transition derives from, and its epochCtx holds the shared, app-wide
+      // builderDepositSignatureCache.
+      const headState = this.chain.getHeadState();
+      if (isStatePostFulu(headState)) {
+        const gloasEpoch = this.config.GLOAS_FORK_EPOCH;
+        const finalizedEpoch = this.chain.forkChoice.getFinalizedCheckpoint().epoch;
+        if (finalizedEpoch >= gloasEpoch) {
+          // Gloas is finalized — the pre-verify cache has served its purpose; release its memory.
+          headState.clearPreGloasBuilderDepositCache();
+        } else {
+          const clockEpoch = computeEpochAtSlot(clockSlot);
+          if (
+            ForkSeq[fork] < ForkSeq.gloas && // only before the fork
+            clockEpoch >= gloasEpoch - GLOAS_PREVERIFY_WINDOW_EPOCHS && // Infinity when Gloas unscheduled → skip
+            clockEpoch < gloasEpoch &&
+            // skip when we're the next-slot proposer — don't compete with block-production prep.
+            feeRecipient === undefined
+          ) {
+            const maxDurationMs = this.config.getSlotComponentDurationMs(BUILDER_PREVERIFY_LIMIT_BPS);
+            const preVerifyTimer = this.metrics?.builderDepositPreVerify.duration.startTimer();
+            const result = headState.preVerifyBuilderDepositsPreGloas(MAX_BUILDER_DEPOSITS_PER_SLOT, maxDurationMs);
+            preVerifyTimer?.();
+
+            const preVerifyMetrics = this.metrics?.builderDepositPreVerify;
+            if (preVerifyMetrics) {
+              preVerifyMetrics.pendingDeposits.set(result.pendingDepositsCount);
+              preVerifyMetrics.cachedDeposits.set(result.totalCachedDeposits);
+              preVerifyMetrics.scannedDeposits.set(result.scannedPendingDeposits);
+              preVerifyMetrics.builderPubkeys.set(result.totalBuilderPubkeys);
+              if (result.validBuilderSignaturesCount > 0) {
+                preVerifyMetrics.validSignatures.inc({type: "builder"}, result.validBuilderSignaturesCount);
+              }
+              if (result.validValidatorSignaturesCount > 0) {
+                preVerifyMetrics.validSignatures.inc({type: "validator"}, result.validValidatorSignaturesCount);
+              }
+              if (result.invalidBuilderSignaturesCount > 0) {
+                preVerifyMetrics.invalidSignatures.inc({type: "builder"}, result.invalidBuilderSignaturesCount);
+              }
+              if (result.invalidValidatorSignaturesCount > 0) {
+                preVerifyMetrics.invalidSignatures.inc({type: "validator"}, result.invalidValidatorSignaturesCount);
+              }
+            }
+
+            // Always log (once per slot, only within the pre-fork window) so devnets show the
+            // pre-verify draining even on all-cache-hit ticks.
+            this.logger.verbose("PrepareNextSlotScheduler pre-verified deposit signatures", {
+              clockSlot,
+              validBuilderSignaturesCount: result.validBuilderSignaturesCount,
+              invalidBuilderSignaturesCount: result.invalidBuilderSignaturesCount,
+              validValidatorSignaturesCount: result.validValidatorSignaturesCount,
+              invalidValidatorSignaturesCount: result.invalidValidatorSignaturesCount,
+              scannedPendingDeposits: result.scannedPendingDeposits,
+              totalCachedDeposits: result.totalCachedDeposits,
+              totalBuilderPubkeys: result.totalBuilderPubkeys,
+              pendingDepositsCount: result.pendingDepositsCount,
+            });
+          }
+        }
       }
     } catch (e) {
       if (!isErrorAborted(e) && !isQueueErrorAborted(e)) {

package/src/chain/produceBlock/produceBlockBody.ts

@@ -1,6 +1,11 @@
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
-import {IForkChoice, ProtoBlock, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
+import {
+  IForkChoice,
+  ProtoBlock,
+  getFinalizedExecutionBlockHash,
+  getSafeExecutionBlockHash,
+} from "@lodestar/fork-choice";
 import {
   BUILDER_INDEX_SELF_BUILD,
   ForkName,
@@ -265,8 +270,8 @@ export async function produceBlockBody<T extends BlockType>(
     // TODO GLOAS: support non self-building here, the block type differentiation between
     // full and blinded no longer makes sense in gloas, it might be a good idea to move
     // this into a completely separate function and have pre/post gloas more separated
-    const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
-    const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
+    const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice, this.logger);
+    const finalizedBlockHash = getFinalizedExecutionBlockHash(this.forkChoice, this.logger);
     // TODO GLOAS: post-Gloas, proposer feeRecipient is also carried (signed) in
     // ProposerPreferencesPool. Consider using this unified cache instead
     // see https://github.com/ChainSafe/lodestar/issues/9379
@@ -411,8 +416,8 @@ export async function produceBlockBody<T extends BlockType>(
       throw new Error("Expected Bellatrix state for execution block production");
     }
 
-    const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
-    const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
+    const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice, this.logger);
+    const finalizedBlockHash = getFinalizedExecutionBlockHash(this.forkChoice, this.logger);
     const feeRecipient = requestedFeeRecipient ?? this.beaconProposerCache.getOrDefault(proposerIndex);
     const feeRecipientType = requestedFeeRecipient
       ? "requested"
@@ -1037,7 +1042,7 @@ export async function produceCommonBlockBody<T extends BlockType>(
     graffiti,
     // Eth1 data voting is no longer required since electra
     eth1Data: currentState.eth1Data,
-    proposerSlashings,
+    proposerSlashings: this.opts.disableProposerSlashings === true ? [] : proposerSlashings,
     attesterSlashings,
     attestations,
     // Since electra, deposits are processed by the execution layer,