@lodestar/state-transition 1.51.0-dev.2593063a82 → 1.51.0-dev.2aff7aaeb7

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`.
@@ -115,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
@@ -174,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 ──────────────────────────────────────────────────────────────
@@ -598,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));
   }
 
@@ -663,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 ??
@@ -675,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));
   }
 
@@ -832,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;
   }
@@ -846,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;
   }
@@ -862,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;
   }
@@ -885,64 +908,85 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     return this.cachedProposerLookahead;
   }
 
-  preVerifyBuilderDepositsPreGloas(
-    _maxBuilderDeposits: number,
-    _maxDurationMs: number
-  ): PreVerifyBuilderDepositsResult {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+  preVerifyBuilderDepositsPreGloas(maxBuilderDeposits: number, maxDurationMs: number): PreVerifyBuilderDepositsResult {
+    return this.binding.preVerifyBuilderDepositsPreGloas(maxBuilderDeposits, maxDurationMs);
   }
 
   clearPreGloasBuilderDepositCache(): void {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    this.binding.clearPreGloasBuilderDepositCache();
   }
 
   // ─── 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/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

@@ -33,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(
@@ -48,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,

package/src/util/clock.ts

@@ -133,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,
             });

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,

package/src/util/inclusionListCommittee.ts

@@ -0,0 +1,17 @@
+import {ValidatorIndex} from "@lodestar/types";
+
+/** Spec `InclusionListCommittee` of one slot */
+export class InclusionListCommittee {
+  constructor(readonly validatorIndices: Uint32Array) {}
+
+  /** Positions of `validatorIndex`, several when the committee cycles over a slot with fewer validators than its size */
+  getCommitteeIndices(validatorIndex: ValidatorIndex): number[] {
+    const committeeIndices: number[] = [];
+    for (let i = 0; i < this.validatorIndices.length; i++) {
+      if (this.validatorIndices[i] === validatorIndex) {
+        committeeIndices.push(i);
+      }
+    }
+    return committeeIndices;
+  }
+}

package/src/util/index.ts

@@ -17,6 +17,7 @@ export * from "./execution.js";
 export * from "./finality.js";
 export * from "./genesis.js";
 export * from "./gloas.js";
+export * from "./inclusionListCommittee.js";
 export * from "./interop.js";
 export * from "./loadState/index.js";
 export * from "./pendingDepositsLookup.js";

package/src/util/interop.ts

@@ -1,6 +1,6 @@
 import {toBufferBE} from "@vekexasia/bigint-buffer2";
 import {digest} from "@chainsafe/as-sha256";
-import {SecretKey} from "@chainsafe/lodestar-z/blst";
+import {SecretKey} from "@lodestar/native/blst";
 import {bytesToBigInt, intToBytes} from "@lodestar/utils";
 
 let curveOrder: bigint;

package/src/util/seed.ts

@@ -3,7 +3,7 @@ import {
   computePtcIndicesForEpoch,
   computeProposerIndex as nativeComputeProposerIndex,
   computeSyncCommitteeIndices as nativeComputeSyncCommitteeIndices,
-} from "@chainsafe/lodestar-z/shuffle";
+} from "@lodestar/native/shuffle";
 import {
   DOMAIN_BEACON_PROPOSER,
   DOMAIN_PTC_ATTESTER,

package/src/util/shuffling.ts

@@ -1,4 +1,4 @@
-import {ForkName, ForkSeq, SLOTS_PER_EPOCH, isForkPostFulu} from "@lodestar/params";
+import {ForkName, ForkSeq, INCLUSION_LIST_COMMITTEE_SIZE, SLOTS_PER_EPOCH, isForkPostFulu} from "@lodestar/params";
 import {
   Attestation,
   CommitteeIndex,
@@ -15,6 +15,7 @@ import {IBeaconStateView} from "../stateView/interface.js";
 import {getBlockRootAtSlot} from "./blockRoot.js";
 import {computeStartSlotAtEpoch} from "./epoch.js";
 import {EpochShuffling} from "./epochShuffling.js";
+import {InclusionListCommittee} from "./inclusionListCommittee.js";
 
 /**
  * Block root that decided the proposer shuffling for `proposalEpoch` (keys that shuffling).
@@ -196,6 +197,50 @@ export function getBeaconCommittee(epochShuffling: EpochShuffling, slot: Slot, i
   return getBeaconCommittees(epochShuffling, slot, [index])[0];
 }
 
+/** Inclusion list committees of a shuffling by slot index, computed on first use and freed with the shuffling */
+// TODO HEZE: replace this module-level map with an extended EpochShuffling tracked by the beacon-node ShufflingCache
+const inclusionListCommitteesByShuffling = new WeakMap<EpochShuffling, InclusionListCommittee[]>();
+
+/** Spec get_inclusion_list_committee: cycle over the slot's concatenated beacon committees */
+export function getInclusionListCommittee(epochShuffling: EpochShuffling, slot: Slot): InclusionListCommittee {
+  let committees = inclusionListCommitteesByShuffling.get(epochShuffling);
+  if (committees === undefined) {
+    committees = [];
+    inclusionListCommitteesByShuffling.set(epochShuffling, committees);
+  }
+  const slotIndex = slot % SLOTS_PER_EPOCH;
+  let committee = committees[slotIndex];
+  if (committee === undefined) {
+    committee = new InclusionListCommittee(computeInclusionListCommittee(epochShuffling.committees[slotIndex]));
+    committees[slotIndex] = committee;
+  }
+  return committee;
+}
+
+function computeInclusionListCommittee(slotCommittees: Uint32Array[]): Uint32Array {
+  let totalLen = 0;
+  for (const committee of slotCommittees) {
+    totalLen += committee.length;
+  }
+
+  const result = new Uint32Array(INCLUSION_LIST_COMMITTEE_SIZE);
+  if (totalLen === 0) {
+    return result;
+  }
+
+  for (let i = 0; i < INCLUSION_LIST_COMMITTEE_SIZE; i++) {
+    let offset = i % totalLen;
+    for (const committee of slotCommittees) {
+      if (offset < committee.length) {
+        result[i] = committee[offset];
+        break;
+      }
+      offset -= committee.length;
+    }
+  }
+  return result;
+}
+
 /**
  * Return a Uint32Array[] representing committees validator indices
  */

package/src/util/signatureSets.ts

@@ -1,4 +1,4 @@
-import {BLS_VERIFIER_SET_TYPE, type BlsSignatureSet, verifySignatureSets} from "@chainsafe/lodestar-z/bls-verifier";
+import {BLS_VERIFIER_SET_TYPE, type BlsSignatureSet, verifySignatureSets} from "@lodestar/native/bls-verifier";
 import {Root} from "@lodestar/types";
 
 export enum SignatureSetType {

package/src/util/slot.ts

@@ -1,27 +1,92 @@
 import {ChainConfig, ChainForkConfig} from "@lodestar/config";
-import {GENESIS_SLOT} from "@lodestar/params";
+import {GENESIS_EPOCH, GENESIS_SLOT} from "@lodestar/params";
 import {Epoch, Slot, TimeSeconds} from "@lodestar/types";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
 
+/**
+ * Slot durations with their activation epochs, derived from the configuration.
+ * A fork that changes the slot duration must add an entry here and in `ForkConfig.getSlotDurationMs`.
+ */
+export function getSlotDurations(config: ChainConfig): [Epoch, number][] {
+  const durations: [Epoch, number][] = [[GENESIS_EPOCH, config.SLOT_DURATION_MS]];
+  if (config.HEZE_FORK_EPOCH !== Infinity) {
+    durations.push([config.HEZE_FORK_EPOCH, config.SLOT_DURATION_MS_HEZE]);
+  }
+  return durations;
+}
+
+/** Slot duration in ms in effect at a given epoch */
+export function getSlotDurationMsAtEpoch(config: ChainConfig, epoch: Epoch): number {
+  let slotDurationMs = config.SLOT_DURATION_MS;
+  for (const [forkEpoch, forkSlotDurationMs] of getSlotDurations(config)) {
+    if (epoch >= forkEpoch) {
+      slotDurationMs = forkSlotDurationMs;
+    }
+  }
+  return slotDurationMs;
+}
+
 /** Slot duration in ms for a given slot */
 export function getSlotDurationMs(config: ChainForkConfig, slot: Slot): number {
   return config.getSlotDurationMs(config.getForkName(slot));
 }
 
+export function computeTimeAtSlotMs(config: ChainConfig, slot: Slot, genesisTimeMs: number): number {
+  let endSlot = slot;
+  let timeMs = genesisTimeMs;
+  for (const [forkEpoch, slotDurationMs] of getSlotDurations(config).reverse()) {
+    const forkSlot = computeStartSlotAtEpoch(forkEpoch);
+    if (forkSlot < endSlot) {
+      timeMs += (endSlot - forkSlot) * slotDurationMs;
+      endSlot = forkSlot;
+    }
+  }
+  // Pre-genesis slots extrapolate linearly so the clock keeps ticking before genesis
+  return timeMs + (endSlot - GENESIS_SLOT) * getSlotDurationMsAtEpoch(config, GENESIS_EPOCH);
+}
+
+export function computeTimeAtSlot(config: ChainConfig, slot: Slot, genesisTime: TimeSeconds): TimeSeconds {
+  return computeTimeAtSlotMs(config, slot, genesisTime * 1000) / 1000;
+}
+
+export function computeSlotAtTimeMs(config: ChainConfig, timeMs: number, genesisTimeMs: number): Slot {
+  let startSlot = GENESIS_SLOT;
+  let startTimeMs = genesisTimeMs;
+  let slotDurationMs = getSlotDurationMsAtEpoch(config, GENESIS_EPOCH);
+  for (const [forkEpoch, forkSlotDurationMs] of getSlotDurations(config)) {
+    const forkSlot = computeStartSlotAtEpoch(forkEpoch);
+    const forkTimeMs = computeTimeAtSlotMs(config, forkSlot, genesisTimeMs);
+    if (timeMs >= forkTimeMs) {
+      startSlot = forkSlot;
+      startTimeMs = forkTimeMs;
+      slotDurationMs = forkSlotDurationMs;
+    }
+  }
+  return startSlot + Math.floor((timeMs - startTimeMs) / slotDurationMs);
+}
+
 export function getSlotsSinceGenesis(config: ChainConfig, genesisTime: TimeSeconds): Slot {
-  const diffInSeconds = Date.now() / 1000 - genesisTime;
-  return Math.floor(diffInSeconds / (config.SLOT_DURATION_MS / 1000));
+  return computeSlotAtTimeMs(config, Date.now(), genesisTime * 1000) - GENESIS_SLOT;
 }
 
 export function getCurrentSlot(config: ChainConfig, genesisTime: TimeSeconds): Slot {
   return GENESIS_SLOT + getSlotsSinceGenesis(config, genesisTime);
 }
 
+/**
+ * Start epoch of the blob data retention window, preserving its wall-clock length
+ * across slot duration changes
+ */
+export function getBlobDataRetentionStartEpoch(config: ChainConfig, epoch: Epoch): Epoch {
+  const windowMs = config.MIN_BLOB_DATA_RETENTION_MS;
+  const currentStartMs = computeTimeAtSlotMs(config, computeStartSlotAtEpoch(epoch), 0);
+  if (currentStartMs < windowMs) {
+    return GENESIS_EPOCH;
+  }
+  return computeEpochAtSlot(computeSlotAtTimeMs(config, currentStartMs - windowMs, 0));
+}
+
 export function computeSlotsSinceEpochStart(slot: Slot, epoch?: Epoch): Slot {
   const computeEpoch = epoch ?? computeEpochAtSlot(slot);
   return slot - computeStartSlotAtEpoch(computeEpoch);
 }
-
-export function computeTimeAtSlot(config: ChainConfig, slot: Slot, genesisTime: TimeSeconds): TimeSeconds {
-  return genesisTime + slot * (config.SLOT_DURATION_MS / 1000);
-}

package/src/util/syncCommittee.ts

@@ -1,18 +1,21 @@
-import {aggregateSerializedPublicKeys} from "@chainsafe/lodestar-z/blst";
+import {ChainConfig} from "@lodestar/config";
+import {aggregateSerializedPublicKeys} from "@lodestar/native/blst";
 import {
   BASE_REWARD_FACTOR,
   EFFECTIVE_BALANCE_INCREMENT,
   ForkSeq,
+  GENESIS_EPOCH,
   SLOTS_PER_EPOCH,
   SYNC_COMMITTEE_SIZE,
   SYNC_REWARD_WEIGHT,
   WEIGHT_DENOMINATOR,
 } from "@lodestar/params";
-import {altair} from "@lodestar/types";
+import {Epoch, altair} from "@lodestar/types";
 import {bigIntSqrt} from "@lodestar/utils";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
 import {BeaconStateAllForks} from "../types.js";
 import {getNextSyncCommitteeIndices} from "./seed.js";
+import {getSlotDurationMsAtEpoch} from "./slot.js";
 
 /**
  * Return the sync committee for a given state and epoch.
@@ -45,11 +48,12 @@ export function getNextSyncCommittee(
 /**
  * Same logic in https://github.com/ethereum/eth2.0-specs/blob/v1.1.0-alpha.5/specs/altair/beacon-chain.md#sync-committee-processing
  */
-export function computeSyncParticipantReward(totalActiveBalanceIncrements: number): number {
-  const totalActiveBalance = BigInt(totalActiveBalanceIncrements) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
-  const baseRewardPerIncrement = Math.floor(
-    (EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR) / Number(bigIntSqrt(totalActiveBalance))
-  );
+export function computeSyncParticipantReward(
+  config: ChainConfig,
+  epoch: Epoch,
+  totalActiveBalanceIncrements: number
+): number {
+  const baseRewardPerIncrement = computeBaseRewardPerIncrement(config, epoch, totalActiveBalanceIncrements);
   const totalBaseRewards = baseRewardPerIncrement * totalActiveBalanceIncrements;
   const maxParticipantRewards = Math.floor(
     Math.floor((totalBaseRewards * SYNC_REWARD_WEIGHT) / WEIGHT_DENOMINATOR) / SLOTS_PER_EPOCH
@@ -61,9 +65,17 @@ export function computeSyncParticipantReward(totalActiveBalanceIncrements: numbe
  * 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) /
-      Number(bigIntSqrt(BigInt(totalActiveStakeByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT)))
+    numerator / Number(bigIntSqrt(BigInt(totalActiveStakeByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT)))
   );
 }