@lodestar/state-transition 1.46.0-dev.1cd9a671ea → 1.46.0-dev.1dde9abaa6

package/package.json

@@ -11,36 +11,36 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.46.0-dev.1cd9a671ea",
+  "version": "1.46.0-dev.1dde9abaa6",
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
+      "typescript": "./src/index.ts",
       "types": "./lib/index.d.ts",
       "import": "./lib/index.js"
     },
     "./block": {
-      "bun": "./src/block/index.ts",
+      "typescript": "./src/block/index.ts",
       "types": "./lib/block/index.d.ts",
       "import": "./lib/block/index.js"
     },
     "./epoch": {
-      "bun": "./src/epoch/index.ts",
+      "typescript": "./src/epoch/index.ts",
       "types": "./lib/epoch/index.d.ts",
       "import": "./lib/epoch/index.js"
     },
     "./slot": {
-      "bun": "./src/slot/index.ts",
+      "typescript": "./src/slot/index.ts",
       "types": "./lib/slot/index.d.ts",
       "import": "./lib/slot/index.js"
     },
     "./light-client": {
-      "bun": "./src/lightClient/spec/index.ts",
+      "typescript": "./src/lightClient/spec/index.ts",
       "types": "./lib/lightClient/spec/index.d.ts",
       "import": "./lib/lightClient/spec/index.js"
     },
     "./test-utils": {
-      "bun": "./src/testUtils/index.ts",
+      "typescript": "./src/testUtils/index.ts",
       "types": "./lib/testUtils/index.d.ts",
       "import": "./lib/testUtils/index.js"
     }
@@ -52,11 +52,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 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",
@@ -71,14 +71,14 @@
     "@chainsafe/pubkey-index-map": "^3.0.0",
     "@chainsafe/ssz": "^1.6.2",
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@lodestar/config": "^1.46.0-dev.1cd9a671ea",
-    "@lodestar/params": "^1.46.0-dev.1cd9a671ea",
-    "@lodestar/types": "^1.46.0-dev.1cd9a671ea",
-    "@lodestar/utils": "^1.46.0-dev.1cd9a671ea",
+    "@lodestar/config": "^1.46.0-dev.1dde9abaa6",
+    "@lodestar/params": "^1.46.0-dev.1dde9abaa6",
+    "@lodestar/types": "^1.46.0-dev.1dde9abaa6",
+    "@lodestar/utils": "^1.46.0-dev.1dde9abaa6",
     "@vekexasia/bigint-buffer2": "^1.1.1"
   },
   "devDependencies": {
-    "@lodestar/api": "^1.46.0-dev.1cd9a671ea"
+    "@lodestar/api": "^1.46.0-dev.1dde9abaa6"
   },
   "keywords": [
     "ethereum",
@@ -86,5 +86,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "4b927ade924253bac78cab64f9ffc45862b91682"
+  "gitHead": "c4cd3268c1c86a757880db46afe78e3f76c8abc9"
 }

package/src/block/index.ts

@@ -1,5 +1,5 @@
 import {ForkPostGloas, ForkSeq} from "@lodestar/params";
-import {BeaconBlock, BlindedBeaconBlock, altair, capella} from "@lodestar/types";
+import {BeaconBlock, BlindedBeaconBlock, Slot, altair, capella} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {
   CachedBeaconStateAllForks,
@@ -86,8 +86,9 @@ export function processBlock(
     processExecutionPayload(fork, state as CachedBeaconStateBellatrix, block.body, externalData);
   }
 
+  let parentSlot: Slot | null = null;
   if (fork >= ForkSeq.gloas) {
-    processExecutionPayloadBid(
+    parentSlot = processExecutionPayloadBid(
       state as CachedBeaconStateGloas,
       (block as BeaconBlock<ForkPostGloas>).body.signedExecutionPayloadBid
     );
@@ -95,7 +96,7 @@ export function processBlock(
 
   processRandao(state, block, verifySignatures);
   processEth1Data(state, block.body.eth1Data);
-  processOperations(fork, state, block.body, opts, metrics);
+  processOperations(fork, state, block.body, parentSlot, opts, metrics);
   if (fork >= ForkSeq.altair) {
     processSyncAggregate(state, block as altair.BeaconBlock, verifySignatures);
   }

package/src/block/processAttestations.ts

@@ -1,5 +1,5 @@
 import {ForkSeq} from "@lodestar/params";
-import {Attestation} from "@lodestar/types";
+import {Attestation, Slot} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair, CachedBeaconStatePhase0} from "../types.js";
 import {processAttestationPhase0} from "./processAttestationPhase0.js";
@@ -12,6 +12,7 @@ export function processAttestations(
   fork: ForkSeq,
   state: CachedBeaconStateAllForks,
   attestations: Attestation[],
+  parentSlot: Slot | null,
   verifySignatures = true,
   metrics?: BeaconStateTransitionMetrics | null
 ): void {
@@ -20,6 +21,13 @@ export function processAttestations(
       processAttestationPhase0(state as CachedBeaconStatePhase0, attestation, verifySignatures);
     }
   } else {
-    processAttestationsAltair(fork, state as CachedBeaconStateAltair, attestations, verifySignatures, metrics);
+    processAttestationsAltair(
+      fork,
+      state as CachedBeaconStateAltair,
+      attestations,
+      parentSlot,
+      verifySignatures,
+      metrics
+    );
   }
 }

package/src/block/processAttestationsAltair.ts

@@ -14,7 +14,7 @@ import {
   TIMELY_TARGET_WEIGHT,
   WEIGHT_DENOMINATOR,
 } from "@lodestar/params";
-import {Attestation, Epoch, phase0} from "@lodestar/types";
+import {Attestation, Epoch, Slot, phase0} from "@lodestar/types";
 import {byteArrayEquals, intSqrt} from "@lodestar/utils";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {getAttestationWithIndicesSignatureSet} from "../signatureSets/indexedAttestation.js";
@@ -37,6 +37,7 @@ export function processAttestationsAltair(
   fork: ForkSeq,
   state: CachedBeaconStateAltair | CachedBeaconStateGloas,
   attestations: Attestation[],
+  parentSlot: Slot | null,
   verifySignature = true,
   metrics?: BeaconStateTransitionMetrics | null
 ): void {
@@ -82,7 +83,8 @@ export function processAttestationsAltair(
       stateSlot - data.slot,
       epochCtx.epoch,
       rootCache,
-      fork >= ForkSeq.gloas ? (state as CachedBeaconStateGloas).executionPayloadAvailability : null
+      fork >= ForkSeq.gloas ? (state as CachedBeaconStateGloas).executionPayloadAvailability : null,
+      parentSlot
     );
 
     // For each participant, update their participation
@@ -179,7 +181,8 @@ export function getAttestationParticipationStatus(
   inclusionDelay: number,
   currentEpoch: Epoch,
   rootCache: RootCache,
-  executionPayloadAvailability: BitArray | null
+  executionPayloadAvailability: BitArray | null,
+  parentSlot: Slot | null
 ): {flags: number; isSameSlotAttestation: boolean} {
   const justifiedCheckpoint =
     data.target.epoch === currentEpoch ? rootCache.currentJustifiedCheckpoint : rootCache.previousJustifiedCheckpoint;
@@ -221,13 +224,16 @@ export function getAttestationParticipationStatus(
       if (executionPayloadAvailability === null) {
         throw new Error("Must supply executionPayloadAvailability post-gloas");
       }
+      if (parentSlot === null) {
+        throw new Error("Must supply parentSlot post-gloas");
+      }
 
       if (data.index !== 0 && data.index !== 1) {
         throw new Error(`data index must be 0 or 1 index=${data.index}`);
       }
 
       isMatchingPayload =
-        Boolean(data.index) === executionPayloadAvailability.get(data.slot % SLOTS_PER_HISTORICAL_ROOT);
+        Boolean(data.index) === executionPayloadAvailability.get(parentSlot % SLOTS_PER_HISTORICAL_ROOT);
     }
 
     isMatchingHead = isMatchingHead && isMatchingPayload;

package/src/block/processDeposit.ts

@@ -1,4 +1,4 @@
-import {PublicKey, Signature, verify} from "@chainsafe/blst";
+import {PublicKey, Signature, verify, verifyMultipleAggregateSignatures} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {
   DEPOSIT_CONTRACT_TREE_DEPTH,
@@ -138,6 +138,10 @@ export function addValidatorToRegistry(
   state.balances.push(amount);
 }
 
+/**
+ * Verify a single deposit signature (proof of possession). See {@link verifyDepositSignatures} for
+ * the batch equivalent — the two MUST stay consistent (same domain, signing root, and checks).
+ */
 export function isValidDepositSignature(
   config: BeaconConfig,
   pubkey: Uint8Array,
@@ -164,3 +168,73 @@ export function isValidDepositSignature(
     return false; // Catch all BLS errors: failed key validation, failed signature validation, invalid signature
   }
 }
+
+/**
+ * Batch equivalent of {@link isValidDepositSignature} — verify many deposit signatures at once.
+ * MUST stay consistent with `isValidDepositSignature`: same fork-agnostic deposit domain, same
+ * `DepositMessage` signing root, same group + infinity checks. Tries a single aggregate verify and,
+ * on failure, falls back to verifying each deposit individually so the valid deposits in a batch
+ * containing an invalid one are still identified. Returns a boolean per input deposit; `slot` is not
+ * part of the signature check.
+ *
+ * Used by the pre-Gloas builder-deposit pre-verify scanner (see `preVerifyBuilderDeposits.ts`).
+ */
+export function verifyDepositSignatures(config: BeaconConfig, deposits: electra.PendingDeposit[]): boolean[] {
+  const results = new Array<boolean>(deposits.length).fill(false);
+  // fork-agnostic domain since deposits are valid across forks, matching isValidDepositSignature
+  const domain = computeDomain(DOMAIN_DEPOSIT, config.GENESIS_FORK_VERSION, ZERO_HASH);
+
+  const signatureSets: {pk: PublicKey; msg: Uint8Array; sig: Signature}[] = [];
+  const signatureSetDepositIndices: number[] = [];
+  for (let i = 0; i < deposits.length; i++) {
+    const {pubkey, withdrawalCredentials, amount, signature} = deposits[i];
+    let pk: PublicKey;
+    let sig: Signature;
+    try {
+      // Parse without group/infinity checks; deferred to the verify call below so it can be
+      // batched across all sets.
+      pk = PublicKey.fromBytes(pubkey);
+      sig = Signature.fromBytes(signature);
+    } catch (_) {
+      // Malformed pubkey or signature bytes - invalid deposit, results[i] stays false
+      continue;
+    }
+    const msg = computeSigningRoot(ssz.phase0.DepositMessage, {pubkey, withdrawalCredentials, amount}, domain);
+    signatureSets.push({pk, msg, sig});
+    signatureSetDepositIndices.push(i);
+  }
+
+  if (signatureSets.length === 0) {
+    return results;
+  }
+
+  // Deposit pubkeys and signatures are untrusted, so group + infinity checks are required.
+  // The trailing (true, true) args delegate those checks to blst, amortized across the batch.
+  let batchValid: boolean;
+  try {
+    batchValid =
+      signatureSets.length >= 2
+        ? verifyMultipleAggregateSignatures(signatureSets, true, true)
+        : verify(signatureSets[0].msg, signatureSets[0].pk, signatureSets[0].sig, true, true);
+  } catch (_) {
+    batchValid = false;
+  }
+
+  if (batchValid) {
+    for (const depositIndex of signatureSetDepositIndices) {
+      results[depositIndex] = true;
+    }
+  } else {
+    for (let s = 0; s < signatureSets.length; s++) {
+      try {
+        if (verify(signatureSets[s].msg, signatureSets[s].pk, signatureSets[s].sig, true, true)) {
+          results[signatureSetDepositIndices[s]] = true;
+        }
+      } catch (_) {
+        // invalid point / malformed → invalid signature, results[i] stays false
+      }
+    }
+  }
+
+  return results;
+}

package/src/block/processExecutionPayloadBid.ts

@@ -1,17 +1,23 @@
 import {PublicKey, Signature, verify} from "@chainsafe/blst";
-import {BUILDER_INDEX_SELF_BUILD, GENESIS_SLOT, PAYLOAD_BUILDER_VERSION, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {gloas, ssz} from "@lodestar/types";
+import {
+  BUILDER_INDEX_SELF_BUILD,
+  ForkSeq,
+  GENESIS_SLOT,
+  PAYLOAD_BUILDER_VERSION,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
+import {Slot, gloas, heze, ssz} from "@lodestar/types";
 import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
 import {G2_POINT_AT_INFINITY} from "../constants/constants.js";
 import {getExecutionPayloadBidSigningRoot} from "../signatureSets/executionPayloadBid.js";
-import {CachedBeaconStateGloas} from "../types.js";
+import {CachedBeaconStateGloas, CachedBeaconStateHeze} from "../types.js";
 import {canBuilderCoverBid, isActiveBuilder} from "../util/gloas.js";
 import {getBlockRootAtSlot, getCurrentEpoch, getRandaoMix} from "../util/index.js";
 
 export function processExecutionPayloadBid(
-  state: CachedBeaconStateGloas,
+  state: CachedBeaconStateGloas | CachedBeaconStateHeze,
   signedBid: gloas.SignedExecutionPayloadBid
-): void {
+): Slot {
   const bid = signedBid.message;
   const {builderIndex, value: amount} = bid;
 
@@ -41,7 +47,7 @@ export function processExecutionPayloadBid(
     }
 
     // Verify that the builder has funds to cover the bid
-    if (!canBuilderCoverBid(state, builderIndex, amount)) {
+    if (!canBuilderCoverBid(state as CachedBeaconStateGloas, builderIndex, amount)) {
       throw Error(`Invalid execution payload bid: builder ${builderIndex} has insufficient balance`);
     }
 
@@ -99,15 +105,22 @@ export function processExecutionPayloadBid(
     state.builderPendingPayments.set(SLOTS_PER_EPOCH + (bid.slot % SLOTS_PER_EPOCH), pendingPaymentView);
   }
 
-  state.latestExecutionPayloadBid = ssz.gloas.ExecutionPayloadBid.toViewDU(bid);
+  const parentSlot = state.latestExecutionPayloadBid.slot;
+  if (state.config.getForkSeq(state.slot) >= ForkSeq.heze) {
+    state.latestExecutionPayloadBid = ssz.heze.ExecutionPayloadBid.toViewDU(bid as heze.ExecutionPayloadBid);
+  } else {
+    state.latestExecutionPayloadBid = ssz.gloas.ExecutionPayloadBid.toViewDU(bid);
+  }
+
+  return parentSlot;
 }
 
 function verifyExecutionPayloadBidSignature(
-  state: CachedBeaconStateGloas,
+  state: CachedBeaconStateGloas | CachedBeaconStateHeze,
   pubkey: Uint8Array,
   signedBid: gloas.SignedExecutionPayloadBid
 ): boolean {
-  const signingRoot = getExecutionPayloadBidSigningRoot(state.config, state.slot, signedBid.message);
+  const signingRoot = getExecutionPayloadBidSigningRoot(state.config, signedBid.message);
 
   try {
     const publicKey = PublicKey.fromBytes(pubkey);

package/src/block/processOperations.ts

@@ -7,7 +7,7 @@ import {
   MAX_PROPOSER_SLASHINGS,
   MAX_VOLUNTARY_EXITS,
 } from "@lodestar/params";
-import {BeaconBlockBody, capella, electra, gloas} from "@lodestar/types";
+import {BeaconBlockBody, Slot, capella, electra, gloas} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {
   CachedBeaconStateAllForks,
@@ -44,6 +44,7 @@ export function processOperations(
   fork: ForkSeq,
   state: CachedBeaconStateAllForks,
   body: BeaconBlockBody,
+  parentSlot: Slot | null,
   opts: ProcessBlockOpts = {verifySignatures: true},
   metrics?: BeaconStateTransitionMetrics | null
 ): void {
@@ -67,7 +68,7 @@ export function processOperations(
     processAttesterSlashing(fork, state, attesterSlashing, opts.verifySignatures);
   }
 
-  processAttestations(fork, state, body.attestations, opts.verifySignatures, metrics);
+  processAttestations(fork, state, body.attestations, parentSlot, opts.verifySignatures, metrics);
 
   for (const deposit of body.deposits) {
     processDeposit(fork, state, deposit);

package/src/block/processWithdrawalRequest.ts

@@ -8,7 +8,11 @@ import {
 import {electra, phase0, ssz} from "@lodestar/types";
 import {toHex} from "@lodestar/utils";
 import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
-import {hasCompoundingWithdrawalCredential, hasExecutionWithdrawalCredential} from "../util/electra.js";
+import {
+  hasCompoundingWithdrawalCredential,
+  hasExecutionWithdrawalCredential,
+  isValidatorKnown,
+} from "../util/electra.js";
 import {computeExitEpochAndUpdateChurn} from "../util/epoch.js";
 import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/validator.js";
 import {initiateValidatorExit} from "./initiateValidatorExit.js";
@@ -32,7 +36,7 @@ export function processWithdrawalRequest(
   // bail out if validator is not in beacon state
   // note that we don't need to check for 6110 unfinalized vals as they won't be eligible for withdraw/exit anyway
   const validatorIndex = pubkeyCache.getIndex(withdrawalRequest.validatorPubkey);
-  if (validatorIndex === null) {
+  if (!isValidatorKnown(state, validatorIndex)) {
     return;
   }
 

package/src/cache/builderDepositSignatureCache.ts

@@ -0,0 +1,81 @@
+import {PubkeyHex, electra} from "@lodestar/types";
+
+/**
+ * Caches deposit signature-verification results — passes (`true`) and failures (`false`) — so the
+ * Fulu → Gloas fork transition can skip the bulk verification cost AND skip re-verifying deposits
+ * already proven invalid. Covers both builder-prefix deposits (onboarding) and validator deposits
+ * that share a pubkey with a builder deposit (the ones `hasPendingValidator` checks at the fork).
+ *
+ * Keyed by the deposit's struct **value object** — `electra.PendingDeposit` is a
+ * `ContainerNodeStructType`, so its `node.value` is a stable object reused across
+ * prepareNextSlot-derived states and carried by reference through the gloas pendingDeposits
+ * migration. No merkle-root computation, no slot bucketing.
+ *
+ * Also tracks builder pubkeys seen so the scanner knows which validator deposits to pre-verify (only
+ * those sharing a pubkey with a builder deposit ever reach `hasPendingValidator`). The mapped boolean
+ * records whether a *valid* validator deposit for that pubkey has been found: once true, the scanner
+ * stops pre-verifying further validator deposits for it — `hasPendingValidator` short-circuits on the
+ * first valid signature at the fork, so the rest would never be read.
+ *
+ * Lifecycle owned by `prepareNextSlot`: filled during the pre-fork window, then `clear()`ed once the
+ * Gloas fork is finalized. `onboardBuildersFromPendingDeposits()` only reads it. A plain `Map` (not a
+ * `WeakMap`) is used so the drop is deterministic and the contents are inspectable for logging.
+ *
+ * Single instance across the application (created in `EpochCache.createFromState`, shared
+ * by-reference through `clone()`).
+ */
+export class BuilderDepositSignatureCache {
+  private validityByDeposit = new Map<electra.PendingDeposit, boolean>();
+  /** builder pubkey → whether a valid validator deposit sharing it has already been pre-verified. */
+  private builderPubkeys = new Map<PubkeyHex, boolean>();
+
+  setSignatureValidity(deposit: electra.PendingDeposit, isValid: boolean): void {
+    this.validityByDeposit.set(deposit, isValid);
+  }
+
+  getSignatureValidity(deposit: electra.PendingDeposit): boolean | null {
+    return this.validityByDeposit.get(deposit) ?? null;
+  }
+
+  isVerified(deposit: electra.PendingDeposit): boolean {
+    return this.validityByDeposit.has(deposit);
+  }
+
+  /** Record a builder deposit's pubkey so the scanner pre-verifies validator deposits for it.
+   *  Idempotent; never downgrades a pubkey already marked as having a valid validator deposit. */
+  addBuilderPubkey(pubkeyHex: PubkeyHex): void {
+    if (!this.builderPubkeys.has(pubkeyHex)) {
+      this.builderPubkeys.set(pubkeyHex, false);
+    }
+  }
+
+  isBuilderPubkey(pubkeyHex: PubkeyHex): boolean {
+    return this.builderPubkeys.has(pubkeyHex);
+  }
+
+  /** True once a valid validator deposit sharing this builder pubkey has been pre-verified — the
+   *  scanner then skips this pubkey's remaining validator deposits (as `hasPendingValidator` would). */
+  hasValidValidatorDeposit(pubkeyHex: PubkeyHex): boolean {
+    return this.builderPubkeys.get(pubkeyHex) === true;
+  }
+
+  /** Mark that a valid validator deposit sharing this builder pubkey was found. */
+  setValidValidatorDeposit(pubkeyHex: PubkeyHex): void {
+    this.builderPubkeys.set(pubkeyHex, true);
+  }
+
+  /** Cumulative deposits verified & cached this window (pass + fail). */
+  get cachedDepositCount(): number {
+    return this.validityByDeposit.size;
+  }
+
+  /** Distinct builder pubkeys tracked this window. */
+  get builderPubkeyCount(): number {
+    return this.builderPubkeys.size;
+  }
+
+  clear(): void {
+    this.validityByDeposit.clear();
+    this.builderPubkeys.clear();
+  }
+}

package/src/cache/epochCache.ts

@@ -53,6 +53,7 @@ import {
 } from "../util/shuffling.js";
 import {computeBaseRewardPerIncrement, computeSyncParticipantReward} from "../util/syncCommittee.js";
 import {sumTargetUnslashedBalanceIncrements} from "../util/targetUnslashedBalance.js";
+import {BuilderDepositSignatureCache} from "./builderDepositSignatureCache.js";
 import {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsWithLen} from "./effectiveBalanceIncrements.js";
 import {EpochTransitionCache} from "./epochTransitionCache.js";
 import {PubkeyCache, createPubkeyCache, syncPubkeys} from "./pubkeyCache.js";
@@ -112,6 +113,13 @@ export class EpochCache {
    * Couples both index→pubkey and pubkey→index lookups, keeping them in sync atomically.
    */
   pubkeyCache: PubkeyCache;
+  /**
+   * Shared across all clones of the same chain head. Holds builder deposit signature validity
+   * pre-verified by the prepareForNextSlot scheduler in the `GLOAS_PREVERIFY_WINDOW_EPOCHS` epochs
+   * leading up to GLOAS_FORK_EPOCH, so `onboardBuildersFromPendingDeposits()` at the fork transition
+   * can skip the bulk verification cost. There should only exist one for the entire application.
+   */
+  builderDepositSignatureCache: BuilderDepositSignatureCache;
   /**
    * Indexes of the block proposers for the current epoch.
    * For pre-fulu, this is computed and cached from the current shuffling.
@@ -245,6 +253,7 @@ export class EpochCache {
   constructor(data: {
     config: BeaconConfig;
     pubkeyCache: PubkeyCache;
+    builderDepositSignatureCache: BuilderDepositSignatureCache;
     proposers: number[];
     proposersPrevEpoch: number[] | null;
     proposersNextEpoch: ProposersDeferred;
@@ -277,6 +286,7 @@ export class EpochCache {
   }) {
     this.config = data.config;
     this.pubkeyCache = data.pubkeyCache;
+    this.builderDepositSignatureCache = data.builderDepositSignatureCache;
     this.proposers = data.proposers;
     this.proposersPrevEpoch = data.proposersPrevEpoch;
     this.proposersNextEpoch = data.proposersNextEpoch;
@@ -408,12 +418,17 @@ export class EpochCache {
 
     const nextShuffling = cachedNextShuffling ?? computeEpochShuffling(state, nextActiveIndices, nextEpoch);
 
-    const currentProposerSeed = getSeed(state, currentEpoch, DOMAIN_BEACON_PROPOSER);
-
-    let proposers: number[];
+    let proposers: ValidatorIndex[];
+    let proposersNextEpoch: ProposersDeferred;
     if (currentEpoch >= config.FULU_FORK_EPOCH) {
-      // Overwrite proposers with state.proposerLookahead
-      proposers = (state as CachedBeaconStateFulu).proposerLookahead.getAll().slice(0, SLOTS_PER_EPOCH);
+      // After fulu, use state.proposerLookahead for current and next epoch proposers.
+      // Computing from the unfiltered active shuffling would include slashed validators in gloas.
+      const proposerLookahead = (state as CachedBeaconStateFulu).proposerLookahead.getAll();
+      proposers = proposerLookahead.slice(0, SLOTS_PER_EPOCH);
+      proposersNextEpoch = {
+        computed: true,
+        indexes: proposerLookahead.slice(SLOTS_PER_EPOCH, SLOTS_PER_EPOCH * 2),
+      };
     } else {
       // We need to calculate Pre-fulu
       // Allow to create CachedBeaconState for empty states, or no active validators
@@ -421,18 +436,17 @@ export class EpochCache {
         currentShuffling.activeIndices.length > 0
           ? computeProposers(
               config.getForkSeqAtEpoch(currentEpoch),
-              currentProposerSeed,
+              getSeed(state, currentEpoch, DOMAIN_BEACON_PROPOSER),
               currentShuffling,
               effectiveBalanceIncrements
             )
           : [];
+      proposersNextEpoch = {
+        computed: false,
+        seed: getSeed(state, nextEpoch, DOMAIN_BEACON_PROPOSER),
+      };
     }
 
-    const proposersNextEpoch: ProposersDeferred = {
-      computed: false,
-      seed: getSeed(state, nextEpoch, DOMAIN_BEACON_PROPOSER),
-    };
-
     // Only after altair, compute the indices of the current sync committee
     const afterAltairFork = currentEpoch >= config.ALTAIR_FORK_EPOCH;
 
@@ -510,6 +524,8 @@ export class EpochCache {
     return new EpochCache({
       config,
       pubkeyCache,
+      // Created once per application (shared by-reference through clone()).
+      builderDepositSignatureCache: new BuilderDepositSignatureCache(),
       proposers,
       // On first epoch, set to null to prevent unnecessary work since this is only used for metrics
       proposersPrevEpoch: null,
@@ -554,6 +570,8 @@ export class EpochCache {
       config: this.config,
       // Common append-only structures shared with all states, no need to clone
       pubkeyCache: this.pubkeyCache,
+      // Singleton per application, shared by-reference across clones
+      builderDepositSignatureCache: this.builderDepositSignatureCache,
       // Immutable data
       proposers: this.proposers,
       proposersPrevEpoch: this.proposersPrevEpoch,
@@ -713,17 +731,10 @@ export class EpochCache {
       // Populate proposer cache with lookahead from state
       const proposerLookahead = (state as CachedBeaconStateFulu).proposerLookahead.getAll();
       this.proposers = proposerLookahead.slice(0, SLOTS_PER_EPOCH);
-
-      if (proposerLookahead.length >= SLOTS_PER_EPOCH * 2) {
-        this.proposersNextEpoch = {
-          computed: true,
-          indexes: proposerLookahead.slice(SLOTS_PER_EPOCH, SLOTS_PER_EPOCH * 2),
-        };
-      } else {
-        // This should not happen unless MIN_SEED_LOOKAHEAD is set to 0
-        // this ensures things don't break if the proposer lookahead is not long enough
-        this.proposersNextEpoch = {computed: false, seed: getSeed(state, epochAfterUpcoming, DOMAIN_BEACON_PROPOSER)};
-      }
+      this.proposersNextEpoch = {
+        computed: true,
+        indexes: proposerLookahead.slice(SLOTS_PER_EPOCH, SLOTS_PER_EPOCH * 2),
+      };
     } else {
       // Need to calculate proposers pre-fulu
       const upcomingProposerSeed = getSeed(state, upcomingEpoch, DOMAIN_BEACON_PROPOSER);

package/src/cache/stateCache.ts

@@ -1,5 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {loadState} from "../util/loadState/loadState.js";
+import {isViewDUNodesPopulated} from "../util/ssz.js";
 import {EpochCache, EpochCacheImmutableData, EpochCacheOpts} from "./epochCache.js";
 import {RewardCache, createEmptyRewardCache} from "./rewardCache.js";
 import {
@@ -12,6 +13,7 @@ import {
   BeaconStateExecutions,
   BeaconStateFulu,
   BeaconStateGloas,
+  BeaconStateHeze,
   BeaconStatePhase0,
 } from "./types.js";
 
@@ -136,6 +138,7 @@ export type CachedBeaconStateDeneb = CachedBeaconState<BeaconStateDeneb>;
 export type CachedBeaconStateElectra = CachedBeaconState<BeaconStateElectra>;
 export type CachedBeaconStateFulu = CachedBeaconState<BeaconStateFulu>;
 export type CachedBeaconStateGloas = CachedBeaconState<BeaconStateGloas>;
+export type CachedBeaconStateHeze = CachedBeaconState<BeaconStateHeze>;
 
 export type CachedBeaconStateAllForks = CachedBeaconState<BeaconStateAllForks>;
 export type CachedBeaconStateExecutions = CachedBeaconState<BeaconStateExecutions>;
@@ -254,9 +257,9 @@ export function isCachedBeaconState<T extends BeaconStateAllForks>(
 // This cache is populated during epoch transition, and should be preserved for performance.
 // If the cache is missing too often, means that our clone strategy is not working well.
 export function isStateValidatorsNodesPopulated(state: CachedBeaconStateAllForks): boolean {
-  return (state.validators as unknown as {nodesPopulated?: boolean}).nodesPopulated === true;
+  return isViewDUNodesPopulated(state.validators);
 }
 
 export function isStateBalancesNodesPopulated(state: CachedBeaconStateAllForks): boolean {
-  return (state.balances as unknown as {nodesPopulated?: boolean}).nodesPopulated === true;
+  return isViewDUNodesPopulated(state.balances);
 }

package/src/cache/types.ts

@@ -11,6 +11,7 @@ export type BeaconStateDeneb = CompositeViewDU<SSZTypesFor<ForkName.deneb, "Beac
 export type BeaconStateElectra = CompositeViewDU<SSZTypesFor<ForkName.electra, "BeaconState">>;
 export type BeaconStateFulu = CompositeViewDU<SSZTypesFor<ForkName.fulu, "BeaconState">>;
 export type BeaconStateGloas = CompositeViewDU<SSZTypesFor<ForkName.gloas, "BeaconState">>;
+export type BeaconStateHeze = CompositeViewDU<SSZTypesFor<ForkName.heze, "BeaconState">>;
 
 export type BeaconStateAllForks = CompositeViewDU<SSZTypesFor<ForkAll, "BeaconState">>;
 export type BeaconStateExecutions = CompositeViewDU<SSZTypesFor<ForkPostBellatrix & ForkPreGloas, "BeaconState">>;