@lodestar/state-transition 1.46.0-dev.d9bad172a8 → 1.46.0-dev.de5f89eae1

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.46.0-dev.d9bad172a8",
+  "version": "1.46.0-dev.de5f89eae1",
   "type": "module",
   "exports": {
     ".": {
@@ -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.d9bad172a8",
-    "@lodestar/params": "^1.46.0-dev.d9bad172a8",
-    "@lodestar/types": "^1.46.0-dev.d9bad172a8",
-    "@lodestar/utils": "^1.46.0-dev.d9bad172a8",
+    "@lodestar/config": "^1.46.0-dev.de5f89eae1",
+    "@lodestar/params": "^1.46.0-dev.de5f89eae1",
+    "@lodestar/types": "^1.46.0-dev.de5f89eae1",
+    "@lodestar/utils": "^1.46.0-dev.de5f89eae1",
     "@vekexasia/bigint-buffer2": "^1.1.1"
   },
   "devDependencies": {
-    "@lodestar/api": "^1.46.0-dev.d9bad172a8"
+    "@lodestar/api": "^1.46.0-dev.de5f89eae1"
   },
   "keywords": [
     "ethereum",
@@ -86,5 +86,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "a73860bdbc5e66d2bb7b4e0dc40cedd69bcd0b45"
+  "gitHead": "be4f4cc1a397f425a67a91a73ee8751e57f690dc"
 }

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,15 +1,21 @@
 import {PublicKey, Signature, verify} from "@chainsafe/blst";
-import {BUILDER_INDEX_SELF_BUILD, GENESIS_SLOT, PAYLOAD_BUILDER_VERSION, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {Slot, 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
 ): Slot {
   const bid = signedBid.message;
@@ -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`);
     }
 
@@ -100,17 +106,21 @@ export function processExecutionPayloadBid(
   }
 
   const parentSlot = state.latestExecutionPayloadBid.slot;
-  state.latestExecutionPayloadBid = ssz.gloas.ExecutionPayloadBid.toViewDU(bid);
+  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/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;
@@ -514,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,
@@ -558,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,

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">>;

package/src/index.ts

@@ -52,6 +52,7 @@ export {
   type IBeaconStateViewElectra,
   type IBeaconStateViewFulu,
   type IBeaconStateViewGloas,
+  type IBeaconStateViewHeze,
   isStatePostAltair,
   isStatePostBellatrix,
   isStatePostCapella,
@@ -59,6 +60,7 @@ export {
   isStatePostElectra,
   isStatePostFulu,
   isStatePostGloas,
+  isStatePostHeze,
 } from "./stateView/interface.js";
 export {createBeaconStateView, createBeaconStateViewForHistoricalRegen} from "./stateView/stateViewFactory.js";
 export type {
@@ -71,6 +73,7 @@ export type {
   BeaconStateExecutions,
   BeaconStateFulu,
   BeaconStateGloas,
+  BeaconStateHeze,
   // Non-cached states
   BeaconStatePhase0,
   CachedBeaconStateAllForks,
@@ -82,6 +85,7 @@ export type {
   CachedBeaconStateExecutions,
   CachedBeaconStateFulu,
   CachedBeaconStateGloas,
+  CachedBeaconStateHeze,
   CachedBeaconStatePhase0,
 } from "./types.js";
 export * from "./util/index.js";

package/src/lightClient/spec/utils.ts

@@ -193,11 +193,11 @@ export function nextSyncCommitteeGindexAtFork(fork: ForkName): number {
   return NEXT_SYNC_COMMITTEE_GINDEX;
 }
 
-export function getGindexDepth(gindex: number): number {
+function getGindexDepth(gindex: number): number {
   return Math.floor(Math.log2(gindex));
 }
 
-export function getGindexIndex(gindex: number): number {
+function getGindexIndex(gindex: number): number {
   return gindex - 2 ** getGindexDepth(gindex);
 }
 
@@ -263,6 +263,7 @@ export function upgradeLightClientHeader(
       // Break if no further upgrades is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.fulu) break;
 
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
     case ForkName.gloas:
       if (isGloasLightClientHeader(upgradedHeader)) {
         break;
@@ -272,6 +273,12 @@ export function upgradeLightClientHeader(
 
       // Break if no further upgrades is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.gloas) break;
+
+    case ForkName.heze:
+      // No changes to LightClientHeader in Heze
+
+      // Break if no further upgrades is required else fall through
+      if (ForkSeq[targetFork] <= ForkSeq.heze) break;
   }
   return upgradedHeader;
 }

package/src/metrics.ts

@@ -3,6 +3,7 @@ import {ProposerRewardType} from "./block/types.js";
 import {EpochTransitionStep} from "./epoch/index.js";
 import {StateCloneSource, StateHashTreeRootSource} from "./stateTransition.js";
 import {CachedBeaconStateAllForks} from "./types.js";
+import {isViewDUNodesPopulated} from "./util/ssz.js";
 
 export type BeaconStateTransitionMetrics = ReturnType<typeof getMetrics>;
 
@@ -159,9 +160,9 @@ export function onPostStateMetrics(postState: CachedBeaconStateAllForks, metrics
 // 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.
 function isValidatorsNodesPopulated(state: CachedBeaconStateAllForks): boolean {
-  return (state.validators as unknown as {nodesPopulated?: boolean}).nodesPopulated === true;
+  return isViewDUNodesPopulated(state.validators);
 }
 
 function isBalancesNodesPopulated(state: CachedBeaconStateAllForks): boolean {
-  return (state.balances as unknown as {nodesPopulated?: boolean}).nodesPopulated === true;
+  return isViewDUNodesPopulated(state.balances);
 }

package/src/signatureSets/executionPayloadBid.ts

@@ -1,14 +1,12 @@
 import {BeaconConfig} from "@lodestar/config";
-import {DOMAIN_BEACON_BUILDER} from "@lodestar/params";
-import {Slot, gloas, ssz} from "@lodestar/types";
+import {DOMAIN_BEACON_BUILDER, isForkPostGloas} from "@lodestar/params";
+import {ExecutionPayloadBid, ssz, sszTypesFor} from "@lodestar/types";
 import {computeSigningRoot} from "../util/index.js";
 
-export function getExecutionPayloadBidSigningRoot(
-  config: BeaconConfig,
-  stateSlot: Slot,
-  bid: gloas.ExecutionPayloadBid
-): Uint8Array {
-  const domain = config.getDomain(stateSlot, DOMAIN_BEACON_BUILDER);
+export function getExecutionPayloadBidSigningRoot(config: BeaconConfig, bid: ExecutionPayloadBid): Uint8Array {
+  const fork = config.getForkName(bid.slot);
+  const domain = config.getDomain(bid.slot, DOMAIN_BEACON_BUILDER);
+  const sszType = isForkPostGloas(fork) ? sszTypesFor(fork).ExecutionPayloadBid : ssz.gloas.ExecutionPayloadBid;
 
-  return computeSigningRoot(ssz.gloas.ExecutionPayloadBid, bid, domain);
+  return computeSigningRoot(sszType, bid, domain);
 }

package/src/slot/index.ts

@@ -10,6 +10,7 @@ export {upgradeStateToDeneb} from "./upgradeStateToDeneb.js";
 export {upgradeStateToElectra} from "./upgradeStateToElectra.js";
 export {upgradeStateToFulu} from "./upgradeStateToFulu.js";
 export {upgradeStateToGloas} from "./upgradeStateToGloas.js";
+export {upgradeStateToHeze} from "./upgradeStateToHeze.js";
 
 /**
  * Dial state to next slot. Common for all forks

package/src/slot/upgradeStateToGloas.ts

@@ -172,8 +172,8 @@ function onboardBuildersFromPendingDeposits(state: CachedBeaconStateGloas): void
   const pendingDeposits = ssz.gloas.PendingDeposits.defaultViewDU();
   const pendingDepositsLookup = PendingDepositsLookup.buildEmpty();
 
-  for (let i = 0; i < state.pendingDeposits.length; i++) {
-    const deposit = state.pendingDeposits.getReadonly(i);
+  for (const deposit of state.pendingDeposits.getAllReadonly()) {
+    const depositValue = deposit.toValue();
 
     const validatorIndex = state.epochCtx.getValidatorIndex(deposit.pubkey);
     const pubkeyHex = toPubkeyHex(deposit.pubkey);
@@ -181,7 +181,7 @@ function onboardBuildersFromPendingDeposits(state: CachedBeaconStateGloas): void
     // Deposits for existing validators stay in the pending queue
     if (isValidatorKnown(state, validatorIndex)) {
       pendingDeposits.push(deposit);
-      pendingDepositsLookup.add(deposit, pubkeyHex);
+      pendingDepositsLookup.add(depositValue, pubkeyHex);
       continue;
     }
 
@@ -202,26 +202,33 @@ function onboardBuildersFromPendingDeposits(state: CachedBeaconStateGloas): void
     // can pick it up later.
     if (!isBuilderWithdrawalCredential(deposit.withdrawalCredentials)) {
       pendingDeposits.push(deposit);
-      pendingDepositsLookup.add(deposit, pubkeyHex);
+      pendingDepositsLookup.add(depositValue, pubkeyHex);
       continue;
     }
-    if (pendingDepositsLookup.hasPendingValidator(state.config, pubkeyHex)) {
+    if (
+      pendingDepositsLookup.hasPendingValidator(state.config, pubkeyHex, state.epochCtx.builderDepositSignatureCache)
+    ) {
       pendingDeposits.push(deposit);
-      pendingDepositsLookup.add(deposit, pubkeyHex);
+      pendingDepositsLookup.add(depositValue, pubkeyHex);
       continue;
     }
 
     // Verify the deposit signature (proof of possession). If invalid the deposit is silently
     // dropped — stake is forfeited, matching the validator deposit contract behavior.
-    if (
-      !isValidDepositSignature(
+    //
+    // The prepareNextSlot scheduler pre-verifies these signatures in the epochs before the fork
+    // A cache miss falls back to verifying this one deposit — no worse than pre-cache.
+    const cached = state.epochCtx.builderDepositSignatureCache.getSignatureValidity(depositValue);
+    const isValid =
+      cached ??
+      isValidDepositSignature(
         state.config,
         deposit.pubkey,
         deposit.withdrawalCredentials,
         deposit.amount,
         deposit.signature
-      )
-    ) {
+      );
+    if (!isValid) {
       continue;
     }
 

package/src/slot/upgradeStateToHeze.ts

@@ -0,0 +1,91 @@
+import {ssz} from "@lodestar/types";
+import {getCachedBeaconState} from "../cache/stateCache.js";
+import {CachedBeaconStateGloas, CachedBeaconStateHeze} from "../types.js";
+
+/**
+ * Upgrade a state from Gloas to Heze.
+ * Spec: heze/fork.md `upgrade_to_heze`.
+ */
+export function upgradeStateToHeze(stateGloas: CachedBeaconStateGloas): CachedBeaconStateHeze {
+  const {config} = stateGloas;
+
+  ssz.gloas.BeaconState.commitViewDU(stateGloas);
+  const stateHezeCloned = stateGloas;
+
+  const stateHezeView = ssz.heze.BeaconState.defaultViewDU();
+
+  stateHezeView.genesisTime = stateHezeCloned.genesisTime;
+  stateHezeView.genesisValidatorsRoot = stateHezeCloned.genesisValidatorsRoot;
+  stateHezeView.slot = stateHezeCloned.slot;
+  stateHezeView.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: stateGloas.fork.currentVersion,
+    currentVersion: config.HEZE_FORK_VERSION,
+    epoch: stateGloas.epochCtx.epoch,
+  });
+  stateHezeView.latestBlockHeader = stateHezeCloned.latestBlockHeader;
+  stateHezeView.blockRoots = stateHezeCloned.blockRoots;
+  stateHezeView.stateRoots = stateHezeCloned.stateRoots;
+  stateHezeView.historicalRoots = stateHezeCloned.historicalRoots;
+  stateHezeView.eth1Data = stateHezeCloned.eth1Data;
+  stateHezeView.eth1DataVotes = stateHezeCloned.eth1DataVotes;
+  stateHezeView.eth1DepositIndex = stateHezeCloned.eth1DepositIndex;
+  stateHezeView.validators = stateHezeCloned.validators;
+  stateHezeView.balances = stateHezeCloned.balances;
+  stateHezeView.randaoMixes = stateHezeCloned.randaoMixes;
+  stateHezeView.slashings = stateHezeCloned.slashings;
+  stateHezeView.previousEpochParticipation = stateHezeCloned.previousEpochParticipation;
+  stateHezeView.currentEpochParticipation = stateHezeCloned.currentEpochParticipation;
+  stateHezeView.justificationBits = stateHezeCloned.justificationBits;
+  stateHezeView.previousJustifiedCheckpoint = stateHezeCloned.previousJustifiedCheckpoint;
+  stateHezeView.currentJustifiedCheckpoint = stateHezeCloned.currentJustifiedCheckpoint;
+  stateHezeView.finalizedCheckpoint = stateHezeCloned.finalizedCheckpoint;
+  stateHezeView.inactivityScores = stateHezeCloned.inactivityScores;
+  stateHezeView.currentSyncCommittee = stateHezeCloned.currentSyncCommittee;
+  stateHezeView.nextSyncCommittee = stateHezeCloned.nextSyncCommittee;
+  stateHezeView.latestBlockHash = stateHezeCloned.latestBlockHash;
+  stateHezeView.nextWithdrawalIndex = stateHezeCloned.nextWithdrawalIndex;
+  stateHezeView.nextWithdrawalValidatorIndex = stateHezeCloned.nextWithdrawalValidatorIndex;
+  stateHezeView.historicalSummaries = stateHezeCloned.historicalSummaries;
+  stateHezeView.depositRequestsStartIndex = stateHezeCloned.depositRequestsStartIndex;
+  stateHezeView.depositBalanceToConsume = stateHezeCloned.depositBalanceToConsume;
+  stateHezeView.exitBalanceToConsume = stateHezeCloned.exitBalanceToConsume;
+  stateHezeView.earliestExitEpoch = stateHezeCloned.earliestExitEpoch;
+  stateHezeView.consolidationBalanceToConsume = stateHezeCloned.consolidationBalanceToConsume;
+  stateHezeView.earliestConsolidationEpoch = stateHezeCloned.earliestConsolidationEpoch;
+  stateHezeView.pendingDeposits = stateHezeCloned.pendingDeposits;
+  stateHezeView.pendingPartialWithdrawals = stateHezeCloned.pendingPartialWithdrawals;
+  stateHezeView.pendingConsolidations = stateHezeCloned.pendingConsolidations;
+  stateHezeView.proposerLookahead = stateHezeCloned.proposerLookahead;
+  stateHezeView.builders = stateHezeCloned.builders;
+  stateHezeView.nextWithdrawalBuilderIndex = stateHezeCloned.nextWithdrawalBuilderIndex;
+  stateHezeView.executionPayloadAvailability = stateHezeCloned.executionPayloadAvailability;
+  stateHezeView.builderPendingPayments = stateHezeCloned.builderPendingPayments;
+  stateHezeView.builderPendingWithdrawals = stateHezeCloned.builderPendingWithdrawals;
+
+  // [Modified in Heze:EIP7805] inclusion_list_bits = Bitvector[INCLUSION_LIST_COMMITTEE_SIZE]() (default zero)
+  const oldBid = stateHezeCloned.latestExecutionPayloadBid;
+  const newBid = ssz.heze.ExecutionPayloadBid.defaultViewDU();
+  newBid.parentBlockHash = oldBid.parentBlockHash;
+  newBid.parentBlockRoot = oldBid.parentBlockRoot;
+  newBid.blockHash = oldBid.blockHash;
+  newBid.prevRandao = oldBid.prevRandao;
+  newBid.feeRecipient = oldBid.feeRecipient;
+  newBid.gasLimit = oldBid.gasLimit;
+  newBid.builderIndex = oldBid.builderIndex;
+  newBid.slot = oldBid.slot;
+  newBid.value = oldBid.value;
+  newBid.executionPayment = oldBid.executionPayment;
+  newBid.blobKzgCommitments = oldBid.blobKzgCommitments;
+  newBid.executionRequestsRoot = oldBid.executionRequestsRoot;
+  stateHezeView.latestExecutionPayloadBid = newBid;
+
+  stateHezeView.payloadExpectedWithdrawals = stateHezeCloned.payloadExpectedWithdrawals;
+  stateHezeView.ptcWindow = stateHezeCloned.ptcWindow;
+
+  const stateHeze = getCachedBeaconState(stateHezeView, stateGloas);
+  stateHeze.commit();
+  // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
+  stateHeze["clearCache"]();
+
+  return stateHeze;
+}