@lodestar/state-transition 1.48.0-dev.84285dbabf → 1.48.0-dev.b0ce010779

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.48.0-dev.84285dbabf",
+  "version": "1.48.0-dev.b0ce010779",
   "type": "module",
   "exports": {
     ".": {
@@ -70,14 +70,14 @@
     "@chainsafe/persistent-merkle-tree": "^1.3.1",
     "@chainsafe/ssz": "^1.6.3",
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@lodestar/config": "^1.48.0-dev.84285dbabf",
-    "@lodestar/params": "^1.48.0-dev.84285dbabf",
-    "@lodestar/types": "^1.48.0-dev.84285dbabf",
-    "@lodestar/utils": "^1.48.0-dev.84285dbabf",
+    "@lodestar/config": "^1.48.0-dev.b0ce010779",
+    "@lodestar/params": "^1.48.0-dev.b0ce010779",
+    "@lodestar/types": "^1.48.0-dev.b0ce010779",
+    "@lodestar/utils": "^1.48.0-dev.b0ce010779",
     "@vekexasia/bigint-buffer2": "^1.1.1"
   },
   "devDependencies": {
-    "@lodestar/api": "^1.48.0-dev.84285dbabf"
+    "@lodestar/api": "^1.48.0-dev.b0ce010779"
   },
   "keywords": [
     "ethereum",
@@ -85,5 +85,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "eb1131db3ec6a9e6c82681d4db28abf94d1937ee"
+  "gitHead": "f92bab2a1cac36007e7c63d1504219c92b95407c"
 }

package/src/block/index.ts

@@ -53,6 +53,10 @@ export function processBlock(
 ): void {
   const {verifySignatures = true} = opts ?? {};
 
+  // Capture the parent block's slot before processBlockHeader overwrites latestBlockHeader
+  const parentSlot: Slot | null =
+    fork >= ForkSeq.gloas ? (state as CachedBeaconStateGloas).latestBlockHeader.slot : null;
+
   // Apply the parent's deferred payload effects before everything else. Must run before
   // processBlockHeader and processExecutionPayloadBid so subsequent steps see the updated state.
   if (fork >= ForkSeq.gloas) {
@@ -86,9 +90,8 @@ export function processBlock(
     processExecutionPayload(fork, state as CachedBeaconStateBellatrix, block.body, externalData);
   }
 
-  let parentSlot: Slot | null = null;
   if (fork >= ForkSeq.gloas) {
-    parentSlot = processExecutionPayloadBid(
+    processExecutionPayloadBid(
       state as CachedBeaconStateGloas,
       (block as BeaconBlock<ForkPostGloas>).body.signedExecutionPayloadBid
     );

package/src/block/processExecutionPayloadBid.ts

@@ -5,7 +5,7 @@ import {
   PAYLOAD_BUILDER_VERSION,
   SLOTS_PER_EPOCH,
 } from "@lodestar/params";
-import {Slot, gloas, heze, ssz} from "@lodestar/types";
+import {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";
@@ -22,7 +22,7 @@ import {
 export function processExecutionPayloadBid(
   state: CachedBeaconStateGloas | CachedBeaconStateHeze,
   signedBid: gloas.SignedExecutionPayloadBid
-): Slot {
+): void {
   const bid = signedBid.message;
   const {builderIndex, value: amount} = bid;
 
@@ -76,6 +76,10 @@ export function processExecutionPayloadBid(
     );
   }
 
+  if (byteArrayEquals(bid.blockHash, bid.parentBlockHash)) {
+    throw Error(`Block hash ${toRootHex(bid.blockHash)} of bid must not equal its parent block hash`);
+  }
+
   const parentBlockRoot = getBlockRootAtSlot(state, state.slot - 1);
   if (!byteArrayEquals(bid.parentBlockRoot, parentBlockRoot)) {
     throw Error(
@@ -110,14 +114,11 @@ export function processExecutionPayloadBid(
     state.builderPendingPayments.set(SLOTS_PER_EPOCH + (bid.slot % SLOTS_PER_EPOCH), pendingPaymentView);
   }
 
-  const parentSlot = state.latestExecutionPayloadBid.slot;
   if (state.config.getForkSeq(state.slot) >= ForkSeq.heze) {
     state.latestExecutionPayloadBid = ssz.heze.ExecutionPayloadBid.toViewDU(bid as heze.ExecutionPayloadBid);
   } else {
     state.latestExecutionPayloadBid = ssz.gloas.ExecutionPayloadBid.toViewDU(bid);
   }
-
-  return parentSlot;
 }
 
 function verifyExecutionPayloadBidSignature(

package/src/block/processParentExecutionPayload.ts

@@ -59,7 +59,7 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
 
   const fork = state.config.getForkSeq(state.slot);
   const parentBid = state.latestExecutionPayloadBid;
-  const parentSlot = parentBid.slot;
+  const parentSlot = state.latestBlockHeader.slot;
   const parentEpoch = computeEpochAtSlot(parentSlot);
   const currentEpoch = computeEpochAtSlot(state.slot);
 

package/src/block/processWithdrawals.ts

@@ -212,7 +212,12 @@ function getBuildersSweepWithdrawals(
       break;
     }
 
-    // Get next builder in turn
+    // Get next builder in turn, the spec does not wrap around an out of bounds start index
+    if (n === 0 && state.nextWithdrawalBuilderIndex >= builders.length) {
+      throw Error(
+        `Next withdrawal builder index ${state.nextWithdrawalBuilderIndex} out of bounds, builders count ${builders.length}`
+      );
+    }
     const builderIndex = (state.nextWithdrawalBuilderIndex + n) % builders.length;
     const builder = builders.getReadonly(builderIndex);
 
@@ -340,7 +345,12 @@ function getValidatorsSweepWithdrawals(
       break;
     }
 
-    // Get next validator in turn
+    // Get next validator in turn, the spec does not wrap around an out of bounds start index
+    if (n === 0 && nextWithdrawalValidatorIndex >= validators.length) {
+      throw Error(
+        `Next withdrawal validator index ${nextWithdrawalValidatorIndex} out of bounds, validators count ${validators.length}`
+      );
+    }
     const validatorIndex = (nextWithdrawalValidatorIndex + n) % validators.length;
 
     const validator = validators.getReadonly(validatorIndex);

package/src/epoch/processInactivityUpdates.ts

@@ -37,6 +37,7 @@ export function processInactivityUpdates(state: CachedBeaconStateAltair, cache:
 
   inactivityScoresArr.length = state.validators.length;
   inactivityScores.getAll(inactivityScoresArr);
+  let shouldSetInactivityScores = false;
 
   for (let i = 0; i < flags.length; i++) {
     const flag = flags[i];
@@ -53,8 +54,14 @@ export function processInactivityUpdates(state: CachedBeaconStateAltair, cache:
         inactivityScore -= Math.min(INACTIVITY_SCORE_RECOVERY_RATE, inactivityScore);
       }
       if (inactivityScore !== prevInactivityScore) {
-        inactivityScores.set(i, inactivityScore);
+        inactivityScoresArr[i] = inactivityScore;
+        shouldSetInactivityScores = true;
       }
     }
   }
+
+  if (shouldSetInactivityScores) {
+    // Rebuilding the full view is slightly slower than individual sets only when very few scores change.
+    state.inactivityScores = state.type.fields.inactivityScores.toViewDU(inactivityScoresArr);
+  }
 }

package/src/epoch/processPtcWindow.ts

@@ -30,7 +30,7 @@ export function processPtcWindow(state: CachedBeaconStateGloas, cache: EpochTran
 
   // Write shifted window to state: current(N) + next(N+1) + newlyComputed(N+2)
   // From the perspective of upcoming epoch N+1, this is previous + current + next
-  state.ptcWindow = ssz.gloas.PtcWindow.toViewDU([
+  state.ptcWindow = ssz.gloas.PayloadTimelinessCommitteeWindow.toViewDU([
     ...state.epochCtx.payloadTimelinessCommittees,
     ...state.epochCtx.nextPayloadTimelinessCommittees,
     ...newNextPayloadTimelinessCommittees,

package/src/lightClient/spec/index.ts

@@ -32,11 +32,13 @@ export {
   type SyncCommitteeFast,
 } from "./store.js";
 export {
+  getLightClientExecutionRoot,
   getSafetyThreshold,
   isFinalityUpdate,
   isSyncCommitteeUpdate,
   isValidLightClientHeader,
   normalizeMerkleBranch,
+  upgradeLightClientBootstrap,
   upgradeLightClientFinalityUpdate,
   upgradeLightClientHeader,
   upgradeLightClientOptimisticUpdate,

package/src/lightClient/spec/utils.ts

@@ -23,18 +23,18 @@ import {
 } from "@lodestar/params";
 import {
   BeaconBlockHeader,
+  LightClientBootstrap,
   LightClientFinalityUpdate,
   LightClientHeader,
   LightClientOptimisticUpdate,
   LightClientUpdate,
-  Slot,
   SyncCommittee,
   isElectraLightClientUpdate,
   ssz,
 } from "@lodestar/types";
-import {byteArrayEquals, verifyMerkleBranch} from "@lodestar/utils";
-import {computeEpochAtSlot, computeSyncPeriodAtSlot} from "../../util/epoch.js";
-import type {LightClientStore, SyncCommitteeFast} from "./store.js";
+import {byteArrayEquals, hash, verifyMerkleBranch} from "@lodestar/utils";
+import {computeEpochAtSlot} from "../../util/epoch.js";
+import type {ILightClientStore, SyncCommitteeFast} from "./store.js";
 
 export const GENESIS_SLOT = 0;
 export const ZERO_HASH = new Uint8Array(32);
@@ -201,6 +201,76 @@ function getGindexIndex(gindex: number): number {
   return gindex - 2 ** getGindexDepth(gindex);
 }
 
+/**
+ * Returns the execution root represented by a light-client header.
+ *
+ * Gloas headers removed `execution` so Pre-Gloas headers upgraded to the Gloas format
+ * require reconstruction of the original execution payload header root.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.14/specs/gloas/light-client/sync-protocol.md#modified-get_lc_execution_root
+ */
+export function getLightClientExecutionRoot(config: ChainForkConfig, header: LightClientHeader): Uint8Array {
+  const epoch = computeEpochAtSlot(header.beacon.slot);
+
+  if (!isGloasLightClientHeader(header)) {
+    if (epoch < config.CAPELLA_FORK_EPOCH) {
+      return ZERO_HASH;
+    }
+
+    return config
+      .getPostBellatrixForkTypes(header.beacon.slot)
+      .ExecutionPayloadHeader.hashTreeRoot((header as LightClientHeader<ForkName.capella>).execution);
+  }
+
+  if (epoch >= config.GLOAS_FORK_EPOCH) {
+    return header.executionBlockHash;
+  }
+
+  // Reconstruct the pre-Gloas execution payload root for a header upgraded to the Gloas format
+  // because the structure is different, `execution` is removed
+  const executionPayloadDepth = getGindexDepth(BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX);
+  const innerBranch = header.executionBranch.slice(0, -executionPayloadDepth);
+
+  if (epoch >= config.DENEB_FORK_EPOCH) {
+    if (header.beacon.slot === GENESIS_SLOT) {
+      return ssz.deneb.ExecutionPayloadHeader.hashTreeRoot(ssz.deneb.ExecutionPayloadHeader.defaultValue());
+    }
+    return computeBranchRoot(
+      header.executionBlockHash,
+      innerBranch,
+      ssz.deneb.ExecutionPayloadHeader.getPathInfo(["blockHash"]).gindex
+    );
+  }
+
+  if (epoch >= config.CAPELLA_FORK_EPOCH) {
+    if (header.beacon.slot === GENESIS_SLOT) {
+      return ssz.capella.ExecutionPayloadHeader.hashTreeRoot(ssz.capella.ExecutionPayloadHeader.defaultValue());
+    }
+    return computeBranchRoot(
+      header.executionBlockHash,
+      innerBranch,
+      ssz.capella.ExecutionPayloadHeader.getPathInfo(["blockHash"]).gindex
+    );
+  }
+
+  return ZERO_HASH;
+}
+
+export function upgradeLightClientBootstrap(
+  config: ChainForkConfig,
+  targetFork: ForkName,
+  bootstrap: LightClientBootstrap
+): LightClientBootstrap {
+  return {
+    ...bootstrap,
+    header: upgradeLightClientHeader(config, targetFork, bootstrap.header),
+    currentSyncCommitteeBranch: normalizeMerkleBranch(
+      bootstrap.currentSyncCommitteeBranch,
+      currentSyncCommitteeGindexAtFork(targetFork)
+    ),
+  };
+}
+
 export function upgradeLightClientHeader(
   config: ChainForkConfig,
   targetFork: ForkName,
@@ -211,9 +281,7 @@ export function upgradeLightClientHeader(
     throw Error(`Invalid upgrade request from headerFork=${headerFork} to targetFork=${targetFork}`);
   }
 
-  // We are modifying the same header object, may be we could create a copy, but its
-  // not required as of now
-  let upgradedHeader = header;
+  let upgradedHeader = {...header} as LightClientHeader;
   const startUpgradeFromFork = Object.values(ForkName)[ForkSeq[headerFork] + 1];
 
   switch (startUpgradeFromFork) {
@@ -231,23 +299,30 @@ export function upgradeLightClientHeader(
 
     // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
     case ForkName.capella:
-      (upgradedHeader as LightClientHeader<ForkName.capella>).execution =
-        ssz.capella.LightClientHeader.fields.execution.defaultValue();
-      (upgradedHeader as LightClientHeader<ForkName.capella>).executionBranch =
-        ssz.capella.LightClientHeader.fields.executionBranch.defaultValue();
+      upgradedHeader = {
+        ...upgradedHeader,
+        execution: ssz.capella.LightClientHeader.fields.execution.defaultValue(),
+        executionBranch: ssz.capella.LightClientHeader.fields.executionBranch.defaultValue(),
+      } as LightClientHeader<ForkName.capella>;
 
       // Break if no further upgradation is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.capella) break;
 
     // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
-    case ForkName.deneb:
-      (upgradedHeader as LightClientHeader<ForkName.deneb>).execution.blobGasUsed =
-        ssz.deneb.LightClientHeader.fields.execution.fields.blobGasUsed.defaultValue();
-      (upgradedHeader as LightClientHeader<ForkName.deneb>).execution.excessBlobGas =
-        ssz.deneb.LightClientHeader.fields.execution.fields.excessBlobGas.defaultValue();
+    case ForkName.deneb: {
+      const capellaHeader = upgradedHeader as LightClientHeader<ForkName.capella>;
+      upgradedHeader = {
+        ...capellaHeader,
+        execution: {
+          ...capellaHeader.execution,
+          blobGasUsed: ssz.deneb.LightClientHeader.fields.execution.fields.blobGasUsed.defaultValue(),
+          excessBlobGas: ssz.deneb.LightClientHeader.fields.execution.fields.excessBlobGas.defaultValue(),
+        },
+      } as LightClientHeader<ForkName.deneb>;
 
       // Break if no further upgradation is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.deneb) break;
+    }
 
     // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
     case ForkName.electra:
@@ -361,15 +436,16 @@ export function upgradeLightClientUpdate(
   targetFork: ForkName,
   update: LightClientUpdate
 ): LightClientUpdate {
-  update.attestedHeader = upgradeLightClientHeader(config, targetFork, update.attestedHeader);
-  update.finalizedHeader = upgradeLightClientHeader(config, targetFork, update.finalizedHeader);
-  update.nextSyncCommitteeBranch = normalizeMerkleBranch(
-    update.nextSyncCommitteeBranch,
-    nextSyncCommitteeGindexAtFork(targetFork)
-  );
-  update.finalityBranch = normalizeMerkleBranch(update.finalityBranch, finalizedRootGindexAtFork(targetFork));
-
-  return update;
+  return {
+    ...update,
+    attestedHeader: upgradeLightClientHeader(config, targetFork, update.attestedHeader),
+    finalizedHeader: upgradeLightClientHeader(config, targetFork, update.finalizedHeader),
+    nextSyncCommitteeBranch: normalizeMerkleBranch(
+      update.nextSyncCommitteeBranch,
+      nextSyncCommitteeGindexAtFork(targetFork)
+    ),
+    finalityBranch: normalizeMerkleBranch(update.finalityBranch, finalizedRootGindexAtFork(targetFork)),
+  };
 }
 
 export function upgradeLightClientFinalityUpdate(
@@ -377,14 +453,12 @@ export function upgradeLightClientFinalityUpdate(
   targetFork: ForkName,
   finalityUpdate: LightClientFinalityUpdate
 ): LightClientFinalityUpdate {
-  finalityUpdate.attestedHeader = upgradeLightClientHeader(config, targetFork, finalityUpdate.attestedHeader);
-  finalityUpdate.finalizedHeader = upgradeLightClientHeader(config, targetFork, finalityUpdate.finalizedHeader);
-  finalityUpdate.finalityBranch = normalizeMerkleBranch(
-    finalityUpdate.finalityBranch,
-    finalizedRootGindexAtFork(targetFork)
-  );
-
-  return finalityUpdate;
+  return {
+    ...finalityUpdate,
+    attestedHeader: upgradeLightClientHeader(config, targetFork, finalityUpdate.attestedHeader),
+    finalizedHeader: upgradeLightClientHeader(config, targetFork, finalityUpdate.finalizedHeader),
+    finalityBranch: normalizeMerkleBranch(finalityUpdate.finalityBranch, finalizedRootGindexAtFork(targetFork)),
+  };
 }
 
 export function upgradeLightClientOptimisticUpdate(
@@ -392,9 +466,10 @@ export function upgradeLightClientOptimisticUpdate(
   targetFork: ForkName,
   optimisticUpdate: LightClientOptimisticUpdate
 ): LightClientOptimisticUpdate {
-  optimisticUpdate.attestedHeader = upgradeLightClientHeader(config, targetFork, optimisticUpdate.attestedHeader);
-
-  return optimisticUpdate;
+  return {
+    ...optimisticUpdate,
+    attestedHeader: upgradeLightClientHeader(config, targetFork, optimisticUpdate.attestedHeader),
+  };
 }
 
 /**
@@ -405,25 +480,44 @@ export function upgradeLightClientOptimisticUpdate(
 export function upgradeLightClientStore(
   config: ChainForkConfig,
   targetFork: ForkName,
-  store: LightClientStore,
-  signatureSlot: Slot
-): LightClientStore {
-  const updateSignaturePeriod = computeSyncPeriodAtSlot(signatureSlot);
-  const bestValidUpdate = store.bestValidUpdates.get(updateSignaturePeriod);
-
-  if (bestValidUpdate) {
-    store.bestValidUpdates.set(updateSignaturePeriod, {
-      update: upgradeLightClientUpdate(config, targetFork, bestValidUpdate.update),
-      summary: bestValidUpdate.summary,
+  store: ILightClientStore
+): ILightClientStore {
+  const bestValidUpdates = new Map();
+
+  for (const [period, entry] of store.bestValidUpdates) {
+    bestValidUpdates.set(period, {
+      ...entry,
+      update: upgradeLightClientUpdate(config, targetFork, entry.update),
     });
   }
+  const finalizedHeader = upgradeLightClientHeader(config, targetFork, store.finalizedHeader);
+  const optimisticHeader = upgradeLightClientHeader(config, targetFork, store.optimisticHeader);
 
-  store.finalizedHeader = upgradeLightClientHeader(config, targetFork, store.finalizedHeader);
-  store.optimisticHeader = upgradeLightClientHeader(config, targetFork, store.optimisticHeader);
+  for (const [period, bestValidUpdate] of bestValidUpdates) {
+    store.bestValidUpdates.set(period, bestValidUpdate);
+  }
+  store.finalizedHeader = finalizedHeader;
+  store.optimisticHeader = optimisticHeader;
 
   return store;
 }
 
+function computeBranchRoot(leaf: Uint8Array, branch: Uint8Array[], gindex: bigint): Uint8Array {
+  const depth = getGindexDepth(Number(gindex));
+  if (branch.length < depth) {
+    throw Error(`Invalid Merkle branch length ${branch.length}, expected at least ${depth}`);
+  }
+  const proof = branch.slice(-depth);
+  const index = getGindexIndex(Number(gindex));
+  let root = leaf;
+
+  for (let i = 0; i < depth; i++) {
+    root = Math.floor(index / 2 ** i) % 2 === 1 ? hash(proof[i], root) : hash(root, proof[i]);
+  }
+
+  return root;
+}
+
 function isGloasLightClientHeader(header: LightClientHeader): header is LightClientHeader<ForkName.gloas> {
   return (header as LightClientHeader<ForkName.gloas>).executionBlockHash !== undefined;
 }

package/src/rewards/blockRewards.ts

@@ -42,9 +42,7 @@ export async function computeBlockRewards(
   let syncAggregateReward = cachedSyncAggregateReward;
 
   if (blockAttestationReward === 0) {
-    const parentSlot = isForkPostGloas(fork)
-      ? (preState as CachedBeaconStateGloas).latestExecutionPayloadBid.slot
-      : null;
+    const parentSlot = isForkPostGloas(fork) ? (preState as CachedBeaconStateGloas).latestBlockHeader.slot : null;
     blockAttestationReward =
       fork === ForkName.phase0
         ? computeBlockAttestationRewardPhase0(block as phase0.BeaconBlock, preState as CachedBeaconStatePhase0)

package/src/slot/upgradeStateToGloas.ts

@@ -110,7 +110,7 @@ export function upgradeStateToGloas(
     ssz.gloas.PendingConsolidations
   );
   stateGloasView.proposerLookahead = stateGloasCloned.proposerLookahead;
-  stateGloasView.ptcWindow = ssz.gloas.PtcWindow.toViewDU(initializePtcWindow(stateFulu));
+  stateGloasView.ptcWindow = ssz.gloas.PayloadTimelinessCommitteeWindow.toViewDU(initializePtcWindow(stateFulu));
 
   for (let i = 0; i < SLOTS_PER_HISTORICAL_ROOT; i++) {
     stateGloasView.executionPayloadAvailability.set(i, true);

package/src/stateView/beaconStateView.ts

@@ -116,6 +116,10 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
     return this.config.getForkName(this.cachedState.slot);
   }
 
+  get forkSeq(): ForkSeq {
+    return this.config.getForkSeq(this.cachedState.slot);
+  }
+
   get slot(): number {
     return this.cachedState.slot;
   }

package/src/stateView/interface.ts

@@ -10,6 +10,7 @@ import {
   ForkPostFulu,
   ForkPostGloas,
   ForkPostHeze,
+  ForkSeq,
   isForkPostAltair,
   isForkPostBellatrix,
   isForkPostCapella,
@@ -77,6 +78,7 @@ export interface IBeaconStateView {
 
   // phase0
   forkName: ForkName;
+  forkSeq: ForkSeq;
   slot: Slot;
   fork: Fork;
   epoch: Epoch;

package/src/stateView/nativeBeaconStateView.ts

@@ -1,6 +1,6 @@
 import {CompactMultiProof} from "@chainsafe/persistent-merkle-tree";
 import {BitArray, ByteViews} from "@chainsafe/ssz";
-import {ForkName} from "@lodestar/params";
+import {ForkName, ForkSeq} from "@lodestar/params";
 import {
   BeaconBlock,
   BeaconState,
@@ -66,6 +66,7 @@ import {
 export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   // phase0
   private _forkName: ForkName | null = null;
+  private _forkSeq: ForkSeq | null = null;
   private _slot: Slot | null = null;
   private _fork: Fork | null = null;
   private _epoch: Epoch | null = null;
@@ -194,6 +195,13 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     return this._forkName;
   }
 
+  get forkSeq(): ForkSeq {
+    if (this._forkSeq === null) {
+      this._forkSeq = this.binding.forkSeq;
+    }
+    return this._forkSeq;
+  }
+
   get slot(): Slot {
     if (this._slot === null) {
       this._slot = this.binding.slot;