@lodestar/state-transition 1.50.0-dev.023ad6c012 → 1.50.0-dev.03c05fa09a

package/src/stateView/stateViewFactory.ts

@@ -1,14 +1,16 @@
+import bindings from "@chainsafe/lodestar-z";
 import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BeaconConfig} from "@lodestar/config";
 import {createCachedBeaconState} from "../cache/stateCache.js";
 import {getStateTypeFromBytes} from "../util/sszBytes.js";
 import {BeaconStateView} from "./beaconStateView.js";
-import {IBeaconStateView} from "./interface.js";
+import {IBeaconStateView, IBeaconStateViewNative} from "./interface.js";
+import {NativeBeaconStateView} from "./nativeBeaconStateView.js";
 
 // ---- createBeaconStateView (startup path) ----
 
 type CreateBeaconStateViewOpts = {
-  useNative: boolean;
+  nativeStateTransition: boolean;
   config: BeaconConfig;
   stateBytes: Uint8Array;
 };
@@ -18,12 +20,11 @@ type CreateBeaconStateViewOpts = {
  *
  * Caller must reserve pubkey capacity before calling this function.
  *
- * Set `useNative: true` to use the native (Zig) implementation once available.
+ * Set `nativeStateTransition: true` to use the native (Zig) implementation.
  */
 export function createBeaconStateView(opts: CreateBeaconStateViewOpts): IBeaconStateView {
-  if (opts.useNative) {
-    throw new Error("Native (Zig) BeaconStateView not yet implemented");
-    // TODO: return a new instance of NativeBeaconStateView
+  if (opts.nativeStateTransition) {
+    return createNativeBeaconStateView(opts.config, opts.stateBytes);
   }
   const {config, stateBytes} = opts;
   const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
@@ -34,28 +35,36 @@ export function createBeaconStateView(opts: CreateBeaconStateViewOpts): IBeaconS
 // ---- createBeaconStateViewForHistoricalRegen (regen path) ----
 
 type RegenNodeJSOpts = {
-  useNative: false;
+  nativeStateTransition: false;
   config: BeaconConfig;
   stateBytes: Uint8Array;
 };
 
 type RegenNativeOpts = {
-  useNative: true;
+  nativeStateTransition: true;
+  config: BeaconConfig;
   stateBytes: Uint8Array;
 };
 
 /**
  * Create a BeaconStateView from raw SSZ bytes. Used in the historical state regen worker thread.
  *
- * Set `useNative: true` to use the native (Zig) implementation once available.
+ * Set `nativeStateTransition: true` to use the native (Zig) implementation.
  */
 export function createBeaconStateViewForHistoricalRegen(opts: RegenNodeJSOpts | RegenNativeOpts): IBeaconStateView {
-  if (opts.useNative) {
-    throw new Error("Native (Zig) BeaconStateView not yet implemented");
-    // TODO: return a new instance of NativeBeaconStateView
+  if (opts.nativeStateTransition) {
+    return createNativeBeaconStateView(opts.config, opts.stateBytes);
   }
   const {config, stateBytes} = opts;
   const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
   const cachedState = createCachedBeaconState(state, {config, pubkeyCache}, {skipSyncPubkeys: true});
   return new BeaconStateView(cachedState);
 }
+
+function createNativeBeaconStateView(config: BeaconConfig, stateBytes: Uint8Array): IBeaconStateView {
+  const nativeConfig = new bindings.BeaconConfig(config, config.genesisValidatorsRoot);
+  return new NativeBeaconStateView(
+    config,
+    bindings.BeaconStateView.createFromBytes(stateBytes, nativeConfig) as IBeaconStateViewNative
+  );
+}

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/blindedBlock.ts

@@ -3,10 +3,12 @@ import {
   ForkName,
   ForkPostBellatrix,
   ForkPostDeneb,
+  ForkPreDeneb,
   ForkPreGloas,
   ForkSeq,
   isForkPostBellatrix,
   isForkPostDeneb,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   BeaconBlock,
@@ -128,7 +130,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 +141,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
@@ -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/genesis.ts

@@ -11,11 +11,18 @@ import {
   UNSET_DEPOSIT_REQUESTS_START_INDEX,
 } from "@lodestar/params";
 import {Bytes32, Root, TimeSeconds, phase0, ssz} from "@lodestar/types";
-import {processDeposit} from "../block/processDeposit.js";
+import {applyDeposit, processDeposit} from "../block/processDeposit.js";
 import {EpochCacheImmutableData} from "../cache/epochCache.js";
 import {createCachedBeaconState} from "../cache/stateCache.js";
 import {increaseBalance} from "../index.js";
-import {BeaconStateAllForks, CachedBeaconStateAllForks, CachedBeaconStateElectra} from "../types.js";
+import {
+  BeaconStateAllForks,
+  BeaconStatePreHeze,
+  CachedBeaconStateAllForks,
+  CachedBeaconStateElectra,
+  CachedBeaconStateGloas,
+  CachedBeaconStatePreHeze,
+} from "../types.js";
 import {newFilledArray} from "./array.js";
 import {getTemporaryBlockHeader} from "./blockRoot.js";
 import {computeEpochAtSlot} from "./epoch.js";
@@ -87,7 +94,9 @@ export function getGenesisBeaconState(
   state.latestBlockHeader = ssz.phase0.BeaconBlockHeader.toViewDU(latestBlockHeader);
 
   // Ethereum 1.0 chain data
-  state.eth1Data = ssz.phase0.Eth1Data.toViewDU(genesisEth1Data);
+  if (config.getForkSeq(GENESIS_SLOT) < ForkSeq.heze) {
+    (state as BeaconStatePreHeze).eth1Data = ssz.phase0.Eth1Data.toViewDU(genesisEth1Data);
+  }
   state.randaoMixes = ssz.phase0.RandaoMixes.toViewDU(randaoMixes);
 
   return state;
@@ -100,7 +109,9 @@ export function getGenesisBeaconState(
  * @param eth1BlockHash eth1 block hash
  */
 export function applyEth1BlockHash(state: CachedBeaconStateAllForks, eth1BlockHash: Bytes32): void {
-  state.eth1Data.blockHash = eth1BlockHash;
+  if (state.config.getForkSeq(state.slot) < ForkSeq.heze) {
+    (state as CachedBeaconStatePreHeze).eth1Data.blockHash = eth1BlockHash;
+  }
   state.randaoMixes = ssz.phase0.RandaoMixes.toViewDU(newFilledArray(EPOCHS_PER_HISTORICAL_VECTOR, eth1BlockHash));
 }
 
@@ -134,36 +145,41 @@ export function applyDeposits(
   fullDepositDataRootList?: DepositDataRootViewDU
 ): {activatedValidatorCount: number} {
   const fork = config.getForkSeq(state.slot);
-  const depositDataRootList: Root[] = [];
-
-  const fullDepositDataRootArr = fullDepositDataRootList ? fullDepositDataRootList.getAllReadonlyValues() : null;
-
-  if (fullDepositDataRootArr) {
-    const depositCount = Number(state.eth1Data.depositCount);
-    for (let index = 0; index < depositCount; index++) {
-      depositDataRootList.push(fullDepositDataRootArr[index]);
+  if (fork >= ForkSeq.heze) {
+    // Genesis deposits do not use the removed legacy deposit tree.
+    for (const deposit of newDeposits) {
+      applyDeposit(fork, state, deposit.data);
     }
-  }
+  } else {
+    const statePreHeze = state as CachedBeaconStatePreHeze;
+    const depositDataRootList: Root[] = [];
+    const fullDepositDataRootArr = fullDepositDataRootList ? fullDepositDataRootList.getAllReadonlyValues() : null;
 
-  const initDepositCount = depositDataRootList.length;
-  const depositDatas = fullDepositDataRootList ? null : newDeposits.map((deposit) => deposit.data);
-  const {DepositData, DepositDataRootList} = ssz.phase0;
-
-  for (const [index, deposit] of newDeposits.entries()) {
     if (fullDepositDataRootArr) {
-      depositDataRootList.push(fullDepositDataRootArr[index + initDepositCount]);
-      state.eth1Data.depositRoot = DepositDataRootList.hashTreeRoot(depositDataRootList);
-    } else if (depositDatas) {
-      const depositDataList = depositDatas.slice(0, index + 1);
-      state.eth1Data.depositRoot = DepositDataRootList.hashTreeRoot(
-        depositDataList.map((d) => DepositData.hashTreeRoot(d))
-      );
+      const depositCount = Number(statePreHeze.eth1Data.depositCount);
+      for (let index = 0; index < depositCount; index++) {
+        depositDataRootList.push(fullDepositDataRootArr[index]);
+      }
     }
 
-    state.eth1Data.depositCount += 1n;
+    const initDepositCount = depositDataRootList.length;
+    const depositDatas = fullDepositDataRootList ? null : newDeposits.map((deposit) => deposit.data);
+    const {DepositData, DepositDataRootList} = ssz.phase0;
+
+    for (const [index, deposit] of newDeposits.entries()) {
+      if (fullDepositDataRootArr) {
+        depositDataRootList.push(fullDepositDataRootArr[index + initDepositCount]);
+        statePreHeze.eth1Data.depositRoot = DepositDataRootList.hashTreeRoot(depositDataRootList);
+      } else if (depositDatas) {
+        const depositDataList = depositDatas.slice(0, index + 1);
+        statePreHeze.eth1Data.depositRoot = DepositDataRootList.hashTreeRoot(
+          depositDataList.map((d) => DepositData.hashTreeRoot(d))
+        );
+      }
 
-    const fork = config.getForkSeq(GENESIS_SLOT);
-    processDeposit(fork, state, deposit);
+      statePreHeze.eth1Data.depositCount += 1n;
+      processDeposit(fork, statePreHeze, deposit);
+    }
   }
 
   // Process deposit balance updates
@@ -178,7 +194,11 @@ export function applyDeposits(
       }
       increaseBalance(state, validatorIndex, amount);
     }
-    stateElectra.pendingDeposits = ssz.electra.PendingDeposits.defaultViewDU();
+    if (fork >= ForkSeq.gloas) {
+      (state as CachedBeaconStateGloas).pendingDeposits = ssz.gloas.PendingDeposits.defaultViewDU();
+    } else {
+      stateElectra.pendingDeposits = ssz.electra.PendingDeposits.defaultViewDU();
+    }
   }
 
   // Process activations
@@ -316,7 +336,9 @@ export function initializeBeaconStateFromEth1(
     stateElectra.latestExecutionPayloadHeader =
       (executionPayloadHeader as CompositeViewDU<typeof ssz.electra.ExecutionPayloadHeader>) ??
       ssz.electra.ExecutionPayloadHeader.defaultViewDU();
-    stateElectra.depositRequestsStartIndex = UNSET_DEPOSIT_REQUESTS_START_INDEX;
+    if (fork < ForkSeq.heze) {
+      stateElectra.depositRequestsStartIndex = UNSET_DEPOSIT_REQUESTS_START_INDEX;
+    }
   }
 
   if (fork >= ForkSeq.fulu) {
@@ -326,6 +348,10 @@ export function initializeBeaconStateFromEth1(
     stateFulu.latestExecutionPayloadHeader =
       (executionPayloadHeader as CompositeViewDU<typeof ssz.fulu.ExecutionPayloadHeader>) ??
       ssz.fulu.ExecutionPayloadHeader.defaultViewDU();
+    if (fork < ForkSeq.heze) {
+      // Fulu retires the legacy bridge after the genesis deposits.
+      stateFulu.depositRequestsStartIndex = BigInt(stateFulu.eth1DepositIndex);
+    }
   }
 
   if (fork >= ForkSeq.gloas) {

package/src/util/slot.ts

@@ -1,8 +1,13 @@
-import {ChainConfig} from "@lodestar/config";
+import {ChainConfig, ChainForkConfig} from "@lodestar/config";
 import {GENESIS_SLOT} from "@lodestar/params";
 import {Epoch, Slot, TimeSeconds} from "@lodestar/types";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
 
+/** Slot duration in ms for a given slot */
+export function getSlotDurationMs(config: ChainForkConfig, slot: Slot): number {
+  return config.getSlotDurationMs(config.getForkName(slot));
+}
+
 export function getSlotsSinceGenesis(config: ChainConfig, genesisTime: TimeSeconds): Slot {
   const diffInSeconds = Date.now() / 1000 - genesisTime;
   return Math.floor(diffInSeconds / (config.SLOT_DURATION_MS / 1000));