@lodestar/state-transition 1.50.1 → 1.51.0-dev.0586e6e617

package/src/stateView/nativeBeaconStateView.ts

@@ -1,7 +1,7 @@
 import {CompactMultiProof} from "@chainsafe/persistent-merkle-tree";
 import {BitArray, ByteViews} from "@chainsafe/ssz";
 import type {BeaconConfig} from "@lodestar/config";
-import {ForkName, ForkSeq} from "@lodestar/params";
+import {ForkName, ForkPostElectra, ForkSeq} from "@lodestar/params";
 import {
   BeaconBlock,
   BeaconState,
@@ -28,6 +28,7 @@ import {
   phase0,
   rewards,
   ssz,
+  sszTypesFor,
 } from "@lodestar/types";
 import {Checkpoint, Fork} from "@lodestar/types/phase0";
 import {VoluntaryExitValidity} from "../block/processVoluntaryExit.js";
@@ -39,6 +40,7 @@ import {SyncCommitteeWitness} from "../lightClient/types.js";
 import {StateTransitionModules, StateTransitionOpts} from "../stateTransition.js";
 import {EpochShuffling} from "../util/epochShuffling.js";
 import {PreVerifyBuilderDepositsResult} from "../util/preVerifyBuilderDeposits.js";
+import {getStateSlotFromBytes} from "../util/sszBytes.js";
 import {computeNewStateRootStateTransitionOpts, getComputeNewStateRootResult} from "./computeNewStateRoot.js";
 import {
   BlockSTFInput,
@@ -47,8 +49,15 @@ import {
   IBeaconStateViewGloas,
   IBeaconStateViewLatestFork,
   IBeaconStateViewNative,
+  isStatePostGloas,
 } from "./interface.js";
 
+export function assertNativeForkSupported(config: BeaconConfig, slot: Slot): void {
+  if (config.getForkSeq(slot) > ForkSeq.gloas) {
+    throw Error(`Native state transition does not support ${config.getForkName(slot)}`);
+  }
+}
+
 /**
  * Wraps a native binding (the auto-generated JS interface produced by a `.node`
  * file) and exposes it as a fully-conformant `IBeaconStateViewLatestFork`.
@@ -97,6 +106,7 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   private cachedPreviousEpochParticipation: Uint8Array | null = null;
   private cachedCurrentEpochParticipation: Uint8Array | null = null;
   private cachedCurrentSyncCommitteeIndexed: SyncCommitteeCache | null = null;
+  private cachedCurrentSyncCommitteeValidatorIndices: Uint32Array | null = null;
   private cachedSyncProposerReward: number | null = null;
   // bellatrix
   private cachedLatestExecutionPayloadHeader: ExecutionPayloadHeader | null = null;
@@ -114,6 +124,14 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   private cachedPendingConsolidationsCount: number | null = null;
   // fulu
   private cachedProposerLookahead: fulu.ProposerLookahead | null = null;
+  // gloas
+  private cachedLatestBlockHash: Bytes32 | null = null;
+  private cachedExecutionPayloadAvailability: BitArray | null = null;
+  private cachedLatestExecutionPayloadBid: ExecutionPayloadBid | null = null;
+  private cachedPayloadExpectedWithdrawals: capella.Withdrawal[] | null = null;
+  private cachedBuilderPendingPayments: gloas.BuilderPendingPayments | null = null;
+  private cachedBuilderPendingWithdrawals: gloas.BuilderPendingWithdrawals | null = null;
+  private cachedBuildersLength: number | null = null;
   // Per-argument caches for argument-taking methods. The binding is treated as
   // immutable for the view's lifetime, so a given argument always yields the
   // same result. Maps grow only with touched arguments — typical call patterns
@@ -173,7 +191,11 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   get executionPayloadAvailability(): BitArray {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this.cachedExecutionPayloadAvailability === null) {
+      const {uint8Array, bitLen} = this.binding.executionPayloadAvailability;
+      this.cachedExecutionPayloadAvailability = new BitArray(uint8Array, bitLen);
+    }
+    return this.cachedExecutionPayloadAvailability;
   }
 
   // ─── phase0 ──────────────────────────────────────────────────────────────
@@ -228,6 +250,9 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   get eth1Data(): phase0.Eth1Data {
+    if (this.forkSeq >= ForkSeq.heze) {
+      throw new Error("eth1Data was removed from the beacon state in Heze");
+    }
     if (this.cachedEth1Data === null) {
       this.cachedEth1Data = this.binding.eth1Data;
     }
@@ -594,6 +619,7 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     seedValidatorsBytes?: Uint8Array,
     opts?: {preloadValidatorsAndBalances?: boolean}
   ): IBeaconStateView {
+    assertNativeForkSupported(this.config, getStateSlotFromBytes(stateBytes));
     return new NativeBeaconStateView(this.config, this.binding.loadOtherState(stateBytes, seedValidatorsBytes, opts));
   }
 
@@ -659,6 +685,7 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     options: StateTransitionOpts,
     _modules: StateTransitionModules
   ): IBeaconStateView {
+    assertNativeForkSupported(this.config, block.message.slot);
     const isBlinded = isBlindedBeaconBlock(block.message);
     const signedBlockBytes =
       ssz ??
@@ -671,6 +698,7 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   processSlots(slot: Slot, opts?: {dontTransferCache?: boolean}, _modules?: StateTransitionModules): IBeaconStateView {
+    assertNativeForkSupported(this.config, slot);
     return new NativeBeaconStateView(this.config, this.binding.processSlots(slot, opts));
   }
 
@@ -719,6 +747,16 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     return this.cachedCurrentSyncCommitteeIndexed;
   }
 
+  get currentSyncCommitteeValidatorIndices(): Uint32Array {
+    if (this.cachedCurrentSyncCommitteeValidatorIndices === null) {
+      this.cachedCurrentSyncCommitteeValidatorIndices =
+        this.cachedCurrentSyncCommitteeIndexed?.validatorIndices ??
+        this.binding.currentSyncCommitteeValidatorIndices ??
+        this.currentSyncCommitteeIndexed.validatorIndices;
+    }
+    return this.cachedCurrentSyncCommitteeValidatorIndices;
+  }
+
   get syncProposerReward(): number {
     if (this.cachedSyncProposerReward === null) {
       this.cachedSyncProposerReward = this.binding.syncProposerReward;
@@ -818,7 +856,8 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
 
   get pendingDeposits(): electra.PendingDeposits {
     if (this.cachedPendingDeposits === null) {
-      this.cachedPendingDeposits = ssz.electra.PendingDeposits.deserialize(this.binding.pendingDeposits);
+      const type = sszTypesFor(this.forkName as ForkPostElectra).PendingDeposits;
+      this.cachedPendingDeposits = type.deserialize(this.binding.pendingDeposits);
     }
     return this.cachedPendingDeposits;
   }
@@ -832,9 +871,8 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
 
   get pendingPartialWithdrawals(): electra.PendingPartialWithdrawals {
     if (this.cachedPendingPartialWithdrawals === null) {
-      this.cachedPendingPartialWithdrawals = ssz.electra.PendingPartialWithdrawals.deserialize(
-        this.binding.pendingPartialWithdrawals
-      );
+      const type = sszTypesFor(this.forkName as ForkPostElectra).PendingPartialWithdrawals;
+      this.cachedPendingPartialWithdrawals = type.deserialize(this.binding.pendingPartialWithdrawals);
     }
     return this.cachedPendingPartialWithdrawals;
   }
@@ -848,9 +886,8 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
 
   get pendingConsolidations(): electra.PendingConsolidations {
     if (this.cachedPendingConsolidations === null) {
-      this.cachedPendingConsolidations = ssz.electra.PendingConsolidations.deserialize(
-        this.binding.pendingConsolidations
-      );
+      const type = sszTypesFor(this.forkName as ForkPostElectra).PendingConsolidations;
+      this.cachedPendingConsolidations = type.deserialize(this.binding.pendingConsolidations);
     }
     return this.cachedPendingConsolidations;
   }
@@ -875,60 +912,94 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     _maxBuilderDeposits: number,
     _maxDurationMs: number
   ): PreVerifyBuilderDepositsResult {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    // The native fork upgrade verifies directly; it does not maintain a warm-up cache.
+    return {
+      validBuilderSignaturesCount: 0,
+      invalidBuilderSignaturesCount: 0,
+      validValidatorSignaturesCount: 0,
+      invalidValidatorSignaturesCount: 0,
+      scannedPendingDeposits: 0,
+      totalCachedDeposits: 0,
+      totalBuilderPubkeys: 0,
+      pendingDepositsCount: this.pendingDepositsCount,
+    };
   }
 
   clearPreGloasBuilderDepositCache(): void {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    // The native implementation has no pre-Gloas deposit cache to clear.
   }
 
   // ─── gloas ───────────────────────────────────────────────────────────────
 
   get latestBlockHash(): Bytes32 {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this.cachedLatestBlockHash === null) {
+      this.cachedLatestBlockHash = this.binding.latestBlockHash;
+    }
+    return this.cachedLatestBlockHash;
   }
 
   get latestExecutionPayloadBid(): ExecutionPayloadBid {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this.cachedLatestExecutionPayloadBid === null) {
+      this.cachedLatestExecutionPayloadBid = this.binding.latestExecutionPayloadBid;
+    }
+    return this.cachedLatestExecutionPayloadBid;
   }
 
   get payloadExpectedWithdrawals(): capella.Withdrawal[] {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this.cachedPayloadExpectedWithdrawals === null) {
+      this.cachedPayloadExpectedWithdrawals = this.binding.payloadExpectedWithdrawals;
+    }
+    return this.cachedPayloadExpectedWithdrawals;
   }
 
   get builderPendingPayments(): gloas.BuilderPendingPayments {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this.cachedBuilderPendingPayments === null) {
+      this.cachedBuilderPendingPayments = this.binding.builderPendingPayments;
+    }
+    return this.cachedBuilderPendingPayments;
   }
 
   get builderPendingWithdrawals(): gloas.BuilderPendingWithdrawals {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this.cachedBuilderPendingWithdrawals === null) {
+      this.cachedBuilderPendingWithdrawals = this.binding.builderPendingWithdrawals;
+    }
+    return this.cachedBuilderPendingWithdrawals;
   }
 
-  getBuilder(_index: BuilderIndex): gloas.Builder {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+  getBuilder(index: BuilderIndex): gloas.Builder {
+    return this.binding.getBuilder(index);
   }
 
   getBuildersLength(): number {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this.cachedBuildersLength === null) {
+      this.cachedBuildersLength = this.binding.getBuildersLength();
+    }
+    return this.cachedBuildersLength;
   }
 
-  canBuilderCoverBid(_builderIndex: BuilderIndex, _bidAmount: number): boolean {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+  canBuilderCoverBid(builderIndex: BuilderIndex, bidAmount: number): boolean {
+    return this.binding.canBuilderCoverBid(builderIndex, bidAmount);
   }
 
-  getEpochPTCs(_epoch: Epoch): Uint32Array[] {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+  getEpochPTCs(epoch: Epoch): Uint32Array[] {
+    return this.binding.getEpochPTCs(epoch);
   }
 
-  getPayloadTimelinessCommittee(_slot: Slot): Uint32Array {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+  getPayloadTimelinessCommittee(slot: Slot): Uint32Array {
+    return this.binding.getPayloadTimelinessCommittee(slot);
   }
 
-  getIndicesInPayloadTimelinessCommittee(_validatorIndex: ValidatorIndex, _slot: Slot): number[] {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+  getIndicesInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number[] {
+    return this.binding.getIndicesInPayloadTimelinessCommittee(validatorIndex, slot);
   }
 
-  withParentPayloadApplied(_executionRequests: gloas.ExecutionRequests): IBeaconStateViewGloas {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+  withParentPayloadApplied(executionRequests: gloas.ExecutionRequests): IBeaconStateViewGloas {
+    const bytes = ssz.gloas.ExecutionRequests.serialize(executionRequests);
+    const state = new NativeBeaconStateView(this.config, this.binding.withParentPayloadApplied(bytes));
+    if (!isStatePostGloas(state)) {
+      state.release();
+      throw Error("Expected Gloas state after applying the parent payload");
+    }
+    return state;
   }
 }

package/src/stateView/stateViewFactory.ts

@@ -1,11 +1,11 @@
-import bindings from "@chainsafe/lodestar-z";
-import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BeaconConfig} from "@lodestar/config";
+import bindings from "@lodestar/native";
+import {pubkeyCache} from "@lodestar/native/pubkeys";
 import {createCachedBeaconState} from "../cache/stateCache.js";
-import {getStateTypeFromBytes} from "../util/sszBytes.js";
+import {getStateSlotFromBytes, getStateTypeFromBytes} from "../util/sszBytes.js";
 import {BeaconStateView} from "./beaconStateView.js";
 import {IBeaconStateView, IBeaconStateViewNative} from "./interface.js";
-import {NativeBeaconStateView} from "./nativeBeaconStateView.js";
+import {NativeBeaconStateView, assertNativeForkSupported} from "./nativeBeaconStateView.js";
 
 // ---- createBeaconStateView (startup path) ----
 
@@ -62,6 +62,7 @@ export function createBeaconStateViewForHistoricalRegen(opts: RegenNodeJSOpts |
 }
 
 function createNativeBeaconStateView(config: BeaconConfig, stateBytes: Uint8Array): IBeaconStateView {
+  assertNativeForkSupported(config, getStateSlotFromBytes(stateBytes));
   const nativeConfig = new bindings.BeaconConfig(config, config.genesisValidatorsRoot);
   return new NativeBeaconStateView(
     config,

package/src/testUtils/interopPubkeyCache.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
+import {pubkeyCache} from "@lodestar/native/pubkeys";
 import {interopSecretKey} from "../util/interop.js";
 import {testCachePath} from "./cache.js";
 

package/src/testUtils/state.ts

@@ -1,6 +1,6 @@
-import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {ChainForkConfig, createBeaconConfig} from "@lodestar/config";
 import {config, config as minimalConfig} from "@lodestar/config/default";
+import {pubkeyCache} from "@lodestar/native/pubkeys";
 import {
   EPOCHS_PER_HISTORICAL_VECTOR,
   EPOCHS_PER_SLASHINGS_VECTOR,

package/src/testUtils/util.ts

@@ -1,8 +1,8 @@
-import {PublicKey, SecretKey} from "@chainsafe/lodestar-z/blst";
-import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BitArray, fromHexString} from "@chainsafe/ssz";
 import {BeaconConfig, createBeaconConfig, createChainForkConfig} from "@lodestar/config";
 import {config} from "@lodestar/config/default";
+import {PublicKey, SecretKey} from "@lodestar/native/blst";
+import {pubkeyCache} from "@lodestar/native/pubkeys";
 import {
   BUILDER_WITHDRAWAL_PREFIX,
   DOMAIN_DEPOSIT,

package/src/types.ts

@@ -12,6 +12,7 @@ export type {
   CachedBeaconStateGloas,
   CachedBeaconStateHeze,
   CachedBeaconStatePhase0,
+  CachedBeaconStatePreHeze,
 } from "./cache/stateCache.js";
 export type {
   BeaconStateAllForks,
@@ -25,5 +26,6 @@ export type {
   BeaconStateGloas,
   BeaconStateHeze,
   BeaconStatePhase0,
+  BeaconStatePreHeze,
   ShufflingGetter,
 } from "./cache/types.js";

package/src/util/altair.ts

@@ -1,13 +1,24 @@
-import {BASE_REWARD_FACTOR, EFFECTIVE_BALANCE_INCREMENT} from "@lodestar/params";
+import {ChainConfig} from "@lodestar/config";
+import {BASE_REWARD_FACTOR, EFFECTIVE_BALANCE_INCREMENT, GENESIS_EPOCH} from "@lodestar/params";
+import {Epoch} from "@lodestar/types";
 import {bigIntSqrt, bnToNum} from "@lodestar/utils";
+import {getSlotDurationMsAtEpoch} from "./slot.js";
 
 /**
  * Before we manage bigIntSqrt(totalActiveStake) as BigInt and return BigInt.
  * bigIntSqrt(totalActiveStake) should fit a number (2 ** 53 -1 max)
  **/
-export function computeBaseRewardPerIncrement(totalActiveStakeByIncrement: number): number {
+export function computeBaseRewardPerIncrement(
+  config: ChainConfig,
+  epoch: Epoch,
+  totalActiveStakeByIncrement: number
+): number {
+  // Divide last so the exact slot duration ratio applies
+  const numerator = Math.floor(
+    (EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR * getSlotDurationMsAtEpoch(config, epoch)) /
+      getSlotDurationMsAtEpoch(config, GENESIS_EPOCH)
+  );
   return Math.floor(
-    (EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR) /
-      bnToNum(bigIntSqrt(BigInt(totalActiveStakeByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT)))
+    numerator / bnToNum(bigIntSqrt(BigInt(totalActiveStakeByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT)))
   );
 }

package/src/util/blindedBlock.ts

@@ -3,10 +3,12 @@ import {
   ForkName,
   ForkPostBellatrix,
   ForkPostDeneb,
+  ForkPreDeneb,
   ForkPreGloas,
   ForkSeq,
   isForkPostBellatrix,
   isForkPostDeneb,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   BeaconBlock,
@@ -31,13 +33,9 @@ export function blindedOrFullBlockHashTreeRoot(
 ): Root {
   return isBlindedBeaconBlock(blindedOrFull)
     ? // Blinded
-      config
-        .getPostBellatrixForkTypes(blindedOrFull.slot)
-        .BlindedBeaconBlock.hashTreeRoot(blindedOrFull)
+      config.getPostBellatrixForkTypes(blindedOrFull.slot).BlindedBeaconBlock.hashTreeRoot(blindedOrFull)
     : // Full
-      config
-        .getForkTypes(blindedOrFull.slot)
-        .BeaconBlock.hashTreeRoot(blindedOrFull);
+      config.getForkTypes(blindedOrFull.slot).BeaconBlock.hashTreeRoot(blindedOrFull);
 }
 
 export function blindedOrFullBlockToHeader(
@@ -46,13 +44,9 @@ export function blindedOrFullBlockToHeader(
 ): BeaconBlockHeader {
   const bodyRoot = isBlindedBeaconBlock(blindedOrFull)
     ? // Blinded
-      config
-        .getPostBellatrixForkTypes(blindedOrFull.slot)
-        .BlindedBeaconBlockBody.hashTreeRoot(blindedOrFull.body)
+      config.getPostBellatrixForkTypes(blindedOrFull.slot).BlindedBeaconBlockBody.hashTreeRoot(blindedOrFull.body)
     : // Full
-      config
-        .getForkTypes(blindedOrFull.slot)
-        .BeaconBlockBody.hashTreeRoot(blindedOrFull.body);
+      config.getForkTypes(blindedOrFull.slot).BeaconBlockBody.hashTreeRoot(blindedOrFull.body);
 
   return {
     slot: blindedOrFull.slot,
@@ -128,7 +122,10 @@ export function reconstructSignedBlockContents(
   signedBlindedBlock: SignedBlindedBeaconBlock,
   executionPayload: ExecutionPayload | null,
   blobsBundle: BlobsBundle | null
-): SignedBlockContents {
+): SignedBlockContents<ForkPreGloas> {
+  if (isForkPostGloas(fork)) {
+    throw Error("Blinded block reconstruction is not supported after Gloas");
+  }
   const signedBlock = signedBlindedBlockToFull(fork, signedBlindedBlock, executionPayload);
 
   if (isForkPostDeneb(fork)) {
@@ -136,10 +133,10 @@ export function reconstructSignedBlockContents(
       throw Error("Missing blobs bundle to reconstruct post-deneb block contents");
     }
     return {
-      signedBlock: signedBlock as SignedBeaconBlock<ForkPostDeneb>,
+      signedBlock: signedBlock as SignedBeaconBlock<ForkPostDeneb & ForkPreGloas>,
       kzgProofs: blobsBundle.proofs,
       blobs: blobsBundle.blobs,
     };
   }
-  return {signedBlock};
+  return {signedBlock: signedBlock as SignedBeaconBlock<ForkPreDeneb>};
 }

package/src/util/clock.ts

@@ -1,9 +1,9 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {GENESIS_SLOT, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {Epoch, Slot, TimeSeconds} from "@lodestar/types";
 import {ErrorAborted, Logger, isErrorAborted, sleep} from "@lodestar/utils";
 import {computeEpochAtSlot} from "./epoch.js";
-import {computeTimeAtSlot, getCurrentSlot} from "./slot.js";
+import {computeTimeAtSlot, getCurrentSlot, getSlotDurationMs} from "./slot.js";
 
 type RunEveryFn = (slot: Slot, signal: AbortSignal) => Promise<void>;
 
@@ -13,6 +13,7 @@ export type ClockOptions = {
 
 export interface IClock {
   readonly genesisTime: number;
+  /** @deprecated Use getSlotDurationMs(slot) instead */
   readonly secondsPerSlot: number;
 
   readonly currentEpoch: number;
@@ -25,6 +26,8 @@ export interface IClock {
   secFromSlot(slot: Slot): number;
   getCurrentSlot(): Slot;
   getCurrentEpoch(): Epoch;
+  /** Slot duration in ms for a given slot */
+  getSlotDurationMs(slot: Slot): number;
 }
 
 export enum TimeItem {
@@ -95,6 +98,11 @@ export class Clock implements IClock {
     return Date.now() / 1000 - computeTimeAtSlot(this.config, slot, this.genesisTime);
   }
 
+  /** Slot duration in ms for a given slot */
+  getSlotDurationMs(slot: Slot): number {
+    return getSlotDurationMs(this.config, slot);
+  }
+
   /**
    * If a task happens to take more than one slot to run, we might skip a slot. This is unfortunate,
    * however the alternative is to *always* process every slot, which has the chance of creating a
@@ -125,7 +133,7 @@ export class Clock implements IClock {
         if (timeItem === TimeItem.Slot) {
           if (nextSlot > slot + 1) {
             // It's not very likely that we skip more than one slot as HTTP timeout is set
-            // to SLOT_DURATION_MS so we will fail task before skipping another slot.
+            // to at most one slot duration so we will fail task before skipping another slot.
             this.logger.warn("Skipped slot due to task taking more than one slot to run", {
               skippedSlot: slot + 1,
             });
@@ -145,20 +153,17 @@ export class Clock implements IClock {
   }
 
   private timeUntilNext(timeItem: TimeItem): number {
-    const milliSecondsPerSlot = this.config.SLOT_DURATION_MS;
-    const msFromGenesis = Date.now() - this.genesisTime * 1000;
+    const currentSlot = getCurrentSlot(this.config, this.genesisTime);
 
     if (timeItem === TimeItem.Slot) {
-      if (msFromGenesis >= 0) {
-        return milliSecondsPerSlot - (msFromGenesis % milliSecondsPerSlot);
-      }
-      return Math.abs(msFromGenesis) % milliSecondsPerSlot;
+      const nextSlotTimeSec = computeTimeAtSlot(this.config, currentSlot + 1, this.genesisTime);
+      return Math.max(0, nextSlotTimeSec * 1000 - Date.now());
     }
-    const milliSecondsPerEpoch = SLOTS_PER_EPOCH * milliSecondsPerSlot;
-    if (msFromGenesis >= 0) {
-      return milliSecondsPerEpoch - (msFromGenesis % milliSecondsPerEpoch);
-    }
-    return Math.abs(msFromGenesis) % milliSecondsPerEpoch;
+
+    const currentEpoch = computeEpochAtSlot(currentSlot);
+    const nextEpochSlot = (currentEpoch + 1) * SLOTS_PER_EPOCH;
+    const nextEpochTimeSec = computeTimeAtSlot(this.config, nextEpochSlot, this.genesisTime);
+    return Math.max(0, nextEpochTimeSec * 1000 - Date.now());
   }
 }
 
@@ -166,9 +171,13 @@ export class Clock implements IClock {
  * Same to the spec but we use Math.round instead of Math.floor.
  */
 export function getCurrentSlotAround(config: ChainForkConfig, genesisTime: TimeSeconds): Slot {
-  const diffInSeconds = Date.now() / 1000 - genesisTime;
-  const slotsSinceGenesis = Math.round((diffInSeconds * 1000) / config.SLOT_DURATION_MS);
-  return GENESIS_SLOT + slotsSinceGenesis;
+  const floorSlot = getCurrentSlot(config, genesisTime);
+  const slotStartSec = computeTimeAtSlot(config, floorSlot, genesisTime);
+  const slotDurationMs = getSlotDurationMs(config, floorSlot);
+  const slotDurationSec = slotDurationMs / 1000;
+  const elapsed = Date.now() / 1000 - slotStartSec;
+
+  return elapsed >= slotDurationSec / 2 ? floorSlot + 1 : floorSlot;
 }
 
 // function useEventStream() {

package/src/util/deposit.ts

@@ -1,8 +1,8 @@
 import {ForkSeq, MAX_DEPOSITS} from "@lodestar/params";
 import {UintNum64, phase0} from "@lodestar/types";
-import {CachedBeaconStateAllForks, CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStatePreHeze} from "../types.js";
 
-export function getEth1DepositCount(state: CachedBeaconStateAllForks, eth1Data?: phase0.Eth1Data): UintNum64 {
+export function getEth1DepositCount(state: CachedBeaconStatePreHeze, eth1Data?: phase0.Eth1Data): UintNum64 {
   const eth1DataToUse = eth1Data ?? state.eth1Data;
   // Proposer can set any value, use in bigint until the result is bounded by MAX_DEPOSITS
   const depositCount = eth1DataToUse.depositCount;

package/src/util/epochShuffling.ts

@@ -1,5 +1,5 @@
-import {unshuffleList} from "@chainsafe/lodestar-z/shuffle";
 import {BeaconConfig} from "@lodestar/config";
+import {unshuffleList} from "@lodestar/native/shuffle";
 import {
   DOMAIN_BEACON_ATTESTER,
   GENESIS_SLOT,