@lodestar/state-transition 1.50.0-dev.2e668c516f → 1.50.0-dev.335476095e

package/src/block/processBuilderDepositRequest.ts

@@ -1,13 +1,8 @@
 import {FAR_FUTURE_EPOCH, PAYLOAD_BUILDER_VERSION} from "@lodestar/params";
 import {gloas} from "@lodestar/types";
-import {CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot} from "../util/epoch.js";
-import {
-  addBuilderToRegistry,
-  findBuilderIndexByPubkey,
-  isBuilderWithdrawalCredential,
-  isValidBuilderDepositSignature,
-} from "../util/gloas.js";
+import {isBuilderWithdrawalCredential, isValidBuilderDepositSignature} from "../util/gloas.js";
+import {IndexedBuilderState} from "./indexedBuilderState.js";
 
 /**
  * Process a builder deposit request from the execution layer: register a new builder
@@ -16,9 +11,10 @@ import {
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-process_builder_deposit_request
  */
 export function processBuilderDepositRequest(
-  state: CachedBeaconStateGloas,
+  indexedState: IndexedBuilderState,
   request: gloas.BuilderDepositRequest
 ): void {
+  const {state} = indexedState;
   const {pubkey, withdrawalCredentials, amount, signature} = request;
 
   // Ignore deposits with unexpected withdrawal credential prefixes.
@@ -26,18 +22,11 @@ export function processBuilderDepositRequest(
     return;
   }
 
-  const builderIndex = findBuilderIndexByPubkey(state, pubkey);
+  const builderIndex = indexedState.findBuilderIndexByPubkey(pubkey);
 
   if (builderIndex === null) {
     if (isValidBuilderDepositSignature(state.config, pubkey, withdrawalCredentials, amount, signature)) {
-      addBuilderToRegistry(
-        state,
-        pubkey,
-        PAYLOAD_BUILDER_VERSION,
-        withdrawalCredentials.subarray(12),
-        amount,
-        state.slot
-      );
+      indexedState.addBuilderToRegistry(pubkey, PAYLOAD_BUILDER_VERSION, withdrawalCredentials.subarray(12), amount);
     }
     return;
   }

package/src/block/processBuilderExitRequest.ts

@@ -1,12 +1,7 @@
 import {gloas} from "@lodestar/types";
 import {byteArrayEquals} from "@lodestar/utils";
-import {CachedBeaconStateGloas} from "../types.js";
-import {
-  findBuilderIndexByPubkey,
-  getPendingBalanceToWithdrawForBuilder,
-  initiateBuilderExit,
-  isActiveBuilder,
-} from "../util/gloas.js";
+import {getPendingBalanceToWithdrawForBuilder, initiateBuilderExit, isActiveBuilder} from "../util/gloas.js";
+import {IndexedBuilderState} from "./indexedBuilderState.js";
 
 /**
  * Apply a builder exit request. Authorizes the exit via `source_address` (the builder's
@@ -17,8 +12,9 @@ import {
  *
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-process_builder_exit_request
  */
-export function processBuilderExitRequest(state: CachedBeaconStateGloas, request: gloas.BuilderExitRequest): void {
-  const builderIndex = findBuilderIndexByPubkey(state, request.pubkey);
+export function processBuilderExitRequest(indexedState: IndexedBuilderState, request: gloas.BuilderExitRequest): void {
+  const {state} = indexedState;
+  const builderIndex = indexedState.findBuilderIndexByPubkey(request.pubkey);
   if (builderIndex === null) {
     return;
   }

package/src/block/processParentExecutionPayload.ts

@@ -3,6 +3,7 @@ import {BeaconBlock, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot} from "../util/epoch.js";
+import {IndexedBuilderState} from "./indexedBuilderState.js";
 import {processBuilderDepositRequest} from "./processBuilderDepositRequest.js";
 import {processBuilderExitRequest} from "./processBuilderExitRequest.js";
 import {processConsolidationRequest} from "./processConsolidationRequest.js";
@@ -53,29 +54,8 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
   const parentEpoch = computeEpochAtSlot(parentSlot);
   const currentEpoch = computeEpochAtSlot(state.slot);
 
-  // Process execution requests from parent's payload. The execution
-  // requests are processed at state.slot (child's slot), not the parent's slot.
-  for (const deposit of requests.deposits) {
-    processDepositRequest(fork, state, deposit);
-  }
-
-  for (const withdrawal of requests.withdrawals) {
-    processWithdrawalRequest(fork, state, withdrawal);
-  }
-
-  for (const consolidation of requests.consolidations) {
-    processConsolidationRequest(state, consolidation);
-  }
-
-  for (const builderDeposit of requests.builderDeposits) {
-    processBuilderDepositRequest(state, builderDeposit);
-  }
-
-  for (const builderExit of requests.builderExits) {
-    processBuilderExitRequest(state, builderExit);
-  }
-
-  // Settle the builder payment
+  // Settle the builder payment before the requests so that a builder exit request
+  // is rejected while the payment is pending
   if (parentEpoch === currentEpoch) {
     settleBuilderPayment(state, SLOTS_PER_EPOCH + (parentSlot % SLOTS_PER_EPOCH));
   } else if (parentEpoch === currentEpoch - 1) {
@@ -92,6 +72,30 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
     );
   }
 
+  // Process execution requests from parent's payload. The execution
+  // requests are processed at state.slot (child's slot), not the parent's slot.
+  for (const deposit of requests.deposits) {
+    processDepositRequest(fork, state, deposit);
+  }
+
+  for (const withdrawal of requests.withdrawals) {
+    processWithdrawalRequest(fork, state, withdrawal);
+  }
+
+  for (const consolidation of requests.consolidations) {
+    processConsolidationRequest(state, consolidation);
+  }
+
+  if (requests.builderDeposits.length > 0 || requests.builderExits.length > 0) {
+    const indexedState = new IndexedBuilderState(state);
+    for (const builderDeposit of requests.builderDeposits) {
+      processBuilderDepositRequest(indexedState, builderDeposit);
+    }
+    for (const builderExit of requests.builderExits) {
+      processBuilderExitRequest(indexedState, builderExit);
+    }
+  }
+
   // Update parent payload availability and latest block hash
   state.executionPayloadAvailability.set(parentSlot % SLOTS_PER_HISTORICAL_ROOT, true);
   state.latestBlockHash = parentBid.blockHash;

package/src/index.ts

@@ -1,4 +1,5 @@
 export {type BlockExternalData, DataAvailabilityStatus, ExecutionPayloadStatus} from "./block/externalData.js";
+export {IndexedBuilderState} from "./block/indexedBuilderState.js";
 export {getAttestationParticipationStatus, processAttestationsAltair} from "./block/processAttestationsAltair.js";
 export {assertValidAttesterSlashing} from "./block/processAttesterSlashing.js";
 export {isValidBlsToExecutionChange} from "./block/processBlsToExecutionChange.js";
@@ -43,7 +44,7 @@ export * from "./signatureSets/index.js";
 export * from "./stateTransition.js";
 export {BeaconStateView} from "./stateView/beaconStateView.js";
 export {
-  type ComputeNewStateRootInput,
+  type BlockSTFInput,
   type ComputeNewStateRootResult,
   type IBeaconStateView,
   type IBeaconStateViewAltair,
@@ -54,6 +55,7 @@ export {
   type IBeaconStateViewFulu,
   type IBeaconStateViewGloas,
   type IBeaconStateViewHeze,
+  type IBeaconStateViewNative,
   isStatePostAltair,
   isStatePostBellatrix,
   isStatePostCapella,
@@ -63,6 +65,7 @@ export {
   isStatePostGloas,
   isStatePostHeze,
 } from "./stateView/interface.js";
+export {NativeBeaconStateView} from "./stateView/nativeBeaconStateView.js";
 export {createBeaconStateView, createBeaconStateViewForHistoricalRegen} from "./stateView/stateViewFactory.js";
 export type {
   BeaconStateAllForks,

package/src/rewards/attestationsRewards.ts

@@ -18,6 +18,8 @@ import {
 import {ValidatorIndex, rewards} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {EpochTransitionCache, beforeProcessEpoch} from "../cache/epochTransitionCache.js";
+import {processInactivityUpdates} from "../epoch/processInactivityUpdates.js";
+import {processJustificationAndFinalization} from "../epoch/processJustificationAndFinalization.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
 import {
   FLAG_ELIGIBLE_ATTESTER,
@@ -45,8 +47,13 @@ export async function computeAttestationsRewards(
     throw Error("Unsupported fork. Attestations rewards calculation is not available in phase0");
   }
 
-  const stateAltair = state as CachedBeaconStateAltair;
+  // Rewards are computed after justification and inactivity updates in epoch processing, so apply both to a clone
+  // before reading finality and inactivity scores, see
+  // https://github.com/ethereum/consensus-specs/blob/v1.7.0-beta.2/specs/altair/beacon-chain.md#epoch-processing
+  const stateAltair = state.clone() as CachedBeaconStateAltair;
   const transitionCache = beforeProcessEpoch(stateAltair);
+  processJustificationAndFinalization(stateAltair, transitionCache);
+  processInactivityUpdates(stateAltair, transitionCache);
 
   const [idealRewards, penalties] = computeIdealAttestationsRewardsAndPenaltiesAltair(
     config,

package/src/stateView/beaconStateView.ts

@@ -14,8 +14,6 @@ import {
   ExecutionPayloadHeader,
   Root,
   RootHex,
-  SignedBeaconBlock,
-  SignedBlindedBeaconBlock,
   Slot,
   SyncCommittee,
   ValidatorIndex,
@@ -71,7 +69,7 @@ import {getRandaoMix} from "../util/seed.js";
 import {getLatestWeakSubjectivityCheckpointEpoch} from "../util/weakSubjectivity.js";
 import {computeNewStateRootStateTransitionOpts, getComputeNewStateRootResult} from "./computeNewStateRoot.js";
 import {
-  ComputeNewStateRootInput,
+  BlockSTFInput,
   ComputeNewStateRootResult,
   IBeaconStateView,
   IBeaconStateViewGloas,
@@ -83,34 +81,36 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
   private readonly config: BeaconConfig;
   // Cached values extracted from the tree
   // phase0
-  private _fork: Fork | null = null;
-  private _latestBlockHeader: phase0.BeaconBlockHeader | null = null;
+  private cachedFork: Fork | null = null;
+  private cachedLatestBlockHeader: phase0.BeaconBlockHeader | null = null;
   // altair
-  private _currentSyncCommittee: SyncCommittee | null = null;
-  private _nextSyncCommittee: SyncCommittee | null = null;
-  private _previousEpochParticipation: Uint8Array | null = null;
-  private _currentEpochParticipation: Uint8Array | null = null;
+  private cachedCurrentSyncCommittee: SyncCommittee | null = null;
+  private cachedNextSyncCommittee: SyncCommittee | null = null;
+  private cachedPreviousEpochParticipation: Uint8Array | null = null;
+  private cachedCurrentEpochParticipation: Uint8Array | null = null;
   // bellatrix
-  private _latestExecutionPayloadHeader: ExecutionPayloadHeader | null = null;
+  private cachedLatestExecutionPayloadHeader: ExecutionPayloadHeader | null = null;
   // capella
-  private _historicalSummaries: capella.HistoricalSummaries | null = null;
+  private cachedHistoricalSummaries: capella.HistoricalSummaries | null = null;
   // electra
-  private _pendingPartialWithdrawals: electra.PendingPartialWithdrawals | null = null;
-  private _pendingConsolidations: electra.PendingConsolidations | null = null;
-  private _pendingDeposits: electra.PendingDeposits | null = null;
+  private cachedPendingPartialWithdrawals: electra.PendingPartialWithdrawals | null = null;
+  private cachedPendingConsolidations: electra.PendingConsolidations | null = null;
+  private cachedPendingDeposits: electra.PendingDeposits | null = null;
   // fulu
-  private _proposerLookahead: fulu.ProposerLookahead | null = null;
+  private cachedProposerLookahead: fulu.ProposerLookahead | null = null;
   // gloas
-  private _executionPayloadAvailability: BitArray | null = null;
-  private _latestExecutionPayloadBid: ExecutionPayloadBid | null = null;
-  private _payloadExpectedWithdrawals: capella.Withdrawal[] | null = null;
-  private _builderPendingPayments: gloas.BuilderPendingPayments | null = null;
-  private _builderPendingWithdrawals: gloas.BuilderPendingWithdrawals | 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;
 
   constructor(readonly cachedState: CachedBeaconStateAllForks) {
     this.config = cachedState.config;
   }
 
+  release(): void {}
+
   // phase0
 
   get forkName(): ForkName {
@@ -126,10 +126,10 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   get fork(): Fork {
-    if (this._fork === null) {
-      this._fork = this.cachedState.fork.toValue();
+    if (this.cachedFork === null) {
+      this.cachedFork = this.cachedState.fork.toValue();
     }
-    return this._fork;
+    return this.cachedFork;
   }
 
   get epoch(): number {
@@ -149,10 +149,10 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   get latestBlockHeader(): phase0.BeaconBlockHeader {
-    if (this._latestBlockHeader === null) {
-      this._latestBlockHeader = this.cachedState.latestBlockHeader.toValue();
+    if (this.cachedLatestBlockHeader === null) {
+      this.cachedLatestBlockHeader = this.cachedState.latestBlockHeader.toValue();
     }
-    return this._latestBlockHeader;
+    return this.cachedLatestBlockHeader;
   }
 
   get previousJustifiedCheckpoint(): Checkpoint {
@@ -188,13 +188,13 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("previousEpochParticipation is not available before Altair");
     }
 
-    if (this._previousEpochParticipation === null) {
-      this._previousEpochParticipation = (
+    if (this.cachedPreviousEpochParticipation === null) {
+      this.cachedPreviousEpochParticipation = (
         this.cachedState as CachedBeaconStateAltair
       ).previousEpochParticipation.serialize();
     }
 
-    return this._previousEpochParticipation;
+    return this.cachedPreviousEpochParticipation;
   }
 
   // altair
@@ -204,13 +204,13 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("currentEpochParticipation is not available before Altair");
     }
 
-    if (this._currentEpochParticipation === null) {
-      this._currentEpochParticipation = (
+    if (this.cachedCurrentEpochParticipation === null) {
+      this.cachedCurrentEpochParticipation = (
         this.cachedState as CachedBeaconStateAltair
       ).currentEpochParticipation.serialize();
     }
 
-    return this._currentEpochParticipation;
+    return this.cachedCurrentEpochParticipation;
   }
 
   getPreviousEpochParticipation(validatorIndex: ValidatorIndex): number {
@@ -238,13 +238,13 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("latestExecutionPayloadHeader is not available after Gloas");
     }
 
-    if (this._latestExecutionPayloadHeader === null) {
-      this._latestExecutionPayloadHeader = (
+    if (this.cachedLatestExecutionPayloadHeader === null) {
+      this.cachedLatestExecutionPayloadHeader = (
         this.cachedState as CachedBeaconStateExecutions
       ).latestExecutionPayloadHeader.toValue();
     }
 
-    return this._latestExecutionPayloadHeader;
+    return this.cachedLatestExecutionPayloadHeader;
   }
 
   /**
@@ -270,11 +270,11 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("Historical summaries are not supported before Capella");
     }
 
-    if (this._historicalSummaries === null) {
-      this._historicalSummaries = (this.cachedState as CachedBeaconStateCapella).historicalSummaries.toValue();
+    if (this.cachedHistoricalSummaries === null) {
+      this.cachedHistoricalSummaries = (this.cachedState as CachedBeaconStateCapella).historicalSummaries.toValue();
     }
 
-    return this._historicalSummaries;
+    return this.cachedHistoricalSummaries;
   }
 
   // electra
@@ -284,11 +284,11 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("Pending deposits are not supported before Electra");
     }
 
-    if (this._pendingDeposits === null) {
-      this._pendingDeposits = (this.cachedState as CachedBeaconStateElectra).pendingDeposits.toValue();
+    if (this.cachedPendingDeposits === null) {
+      this.cachedPendingDeposits = (this.cachedState as CachedBeaconStateElectra).pendingDeposits.toValue();
     }
 
-    return this._pendingDeposits;
+    return this.cachedPendingDeposits;
   }
 
   get pendingDepositsCount(): number {
@@ -304,13 +304,13 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("Pending partial withdrawals are not supported before Electra");
     }
 
-    if (this._pendingPartialWithdrawals === null) {
-      this._pendingPartialWithdrawals = (
+    if (this.cachedPendingPartialWithdrawals === null) {
+      this.cachedPendingPartialWithdrawals = (
         this.cachedState as CachedBeaconStateElectra
       ).pendingPartialWithdrawals.toValue();
     }
 
-    return this._pendingPartialWithdrawals;
+    return this.cachedPendingPartialWithdrawals;
   }
 
   get pendingPartialWithdrawalsCount(): number {
@@ -326,11 +326,11 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("Pending consolidations are not supported before Electra");
     }
 
-    if (this._pendingConsolidations === null) {
-      this._pendingConsolidations = (this.cachedState as CachedBeaconStateElectra).pendingConsolidations.toValue();
+    if (this.cachedPendingConsolidations === null) {
+      this.cachedPendingConsolidations = (this.cachedState as CachedBeaconStateElectra).pendingConsolidations.toValue();
     }
 
-    return this._pendingConsolidations;
+    return this.cachedPendingConsolidations;
   }
 
   get pendingConsolidationsCount(): number {
@@ -348,11 +348,11 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("Proposer lookahead is not supported before Fulu");
     }
 
-    if (this._proposerLookahead === null) {
-      this._proposerLookahead = (this.cachedState as CachedBeaconStateFulu).proposerLookahead.toValue();
+    if (this.cachedProposerLookahead === null) {
+      this.cachedProposerLookahead = (this.cachedState as CachedBeaconStateFulu).proposerLookahead.toValue();
     }
 
-    return this._proposerLookahead;
+    return this.cachedProposerLookahead;
   }
 
   preVerifyBuilderDepositsPreGloas(maxBuilderDeposits: number, maxDurationMs: number): PreVerifyBuilderDepositsResult {
@@ -381,13 +381,13 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("executionPayloadAvailability is not available before Gloas");
     }
 
-    if (this._executionPayloadAvailability === null) {
-      this._executionPayloadAvailability = (
+    if (this.cachedExecutionPayloadAvailability === null) {
+      this.cachedExecutionPayloadAvailability = (
         this.cachedState as CachedBeaconStateGloas
       ).executionPayloadAvailability.toValue();
     }
 
-    return this._executionPayloadAvailability;
+    return this.cachedExecutionPayloadAvailability;
   }
 
   get latestExecutionPayloadBid(): ExecutionPayloadBid {
@@ -395,12 +395,12 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("latestExecutionPayloadBid is not available before Gloas");
     }
 
-    if (this._latestExecutionPayloadBid === null) {
-      this._latestExecutionPayloadBid = (
+    if (this.cachedLatestExecutionPayloadBid === null) {
+      this.cachedLatestExecutionPayloadBid = (
         this.cachedState as CachedBeaconStateGloas
       ).latestExecutionPayloadBid.toValue();
     }
-    return this._latestExecutionPayloadBid;
+    return this.cachedLatestExecutionPayloadBid;
   }
 
   get payloadExpectedWithdrawals(): capella.Withdrawal[] {
@@ -408,12 +408,12 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("payloadExpectedWithdrawals is not available before Gloas");
     }
 
-    if (this._payloadExpectedWithdrawals === null) {
-      this._payloadExpectedWithdrawals = (
+    if (this.cachedPayloadExpectedWithdrawals === null) {
+      this.cachedPayloadExpectedWithdrawals = (
         this.cachedState as CachedBeaconStateGloas
       ).payloadExpectedWithdrawals.toValue();
     }
-    return this._payloadExpectedWithdrawals;
+    return this.cachedPayloadExpectedWithdrawals;
   }
 
   get builderPendingPayments(): gloas.BuilderPendingPayments {
@@ -421,10 +421,10 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("Pending builder payments are not supported before Gloas");
     }
 
-    if (this._builderPendingPayments === null) {
-      this._builderPendingPayments = (this.cachedState as CachedBeaconStateGloas).builderPendingPayments.toValue();
+    if (this.cachedBuilderPendingPayments === null) {
+      this.cachedBuilderPendingPayments = (this.cachedState as CachedBeaconStateGloas).builderPendingPayments.toValue();
     }
-    return this._builderPendingPayments;
+    return this.cachedBuilderPendingPayments;
   }
 
   get builderPendingWithdrawals(): gloas.BuilderPendingWithdrawals {
@@ -432,12 +432,12 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("Pending builder withdrawals are not supported before Gloas");
     }
 
-    if (this._builderPendingWithdrawals === null) {
-      this._builderPendingWithdrawals = (
+    if (this.cachedBuilderPendingWithdrawals === null) {
+      this.cachedBuilderPendingWithdrawals = (
         this.cachedState as CachedBeaconStateGloas
       ).builderPendingWithdrawals.toValue();
     }
-    return this._builderPendingWithdrawals;
+    return this.cachedBuilderPendingWithdrawals;
   }
 
   getBuilder(index: BuilderIndex): gloas.Builder {
@@ -588,11 +588,11 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("currentSyncCommittee is not available before Altair");
     }
 
-    if (this._currentSyncCommittee === null) {
-      this._currentSyncCommittee = (this.cachedState as CachedBeaconStateAltair).currentSyncCommittee.toValue();
+    if (this.cachedCurrentSyncCommittee === null) {
+      this.cachedCurrentSyncCommittee = (this.cachedState as CachedBeaconStateAltair).currentSyncCommittee.toValue();
     }
 
-    return this._currentSyncCommittee;
+    return this.cachedCurrentSyncCommittee;
   }
 
   get nextSyncCommittee(): SyncCommittee {
@@ -600,11 +600,11 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
       throw new Error("nextSyncCommittee is not available before Altair");
     }
 
-    if (this._nextSyncCommittee === null) {
-      this._nextSyncCommittee = (this.cachedState as CachedBeaconStateAltair).nextSyncCommittee.toValue();
+    if (this.cachedNextSyncCommittee === null) {
+      this.cachedNextSyncCommittee = (this.cachedState as CachedBeaconStateAltair).nextSyncCommittee.toValue();
     }
 
-    return this._nextSyncCommittee;
+    return this.cachedNextSyncCommittee;
   }
 
   get currentSyncCommitteeIndexed(): SyncCommitteeCache {
@@ -872,7 +872,7 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
 
   // State transition
 
-  computeNewStateRoot({block}: ComputeNewStateRootInput, modules: StateTransitionModules): ComputeNewStateRootResult {
+  computeNewStateRoot({block}: BlockSTFInput, modules: StateTransitionModules): ComputeNewStateRootResult {
     const postState = new BeaconStateView(
       stateTransition(this.cachedState, block, computeNewStateRootStateTransitionOpts, modules)
     );
@@ -880,12 +880,11 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   stateTransition(
-    signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock,
+    {block}: BlockSTFInput,
     options: StateTransitionOpts,
-    {metrics, validatorMonitor}: StateTransitionModules
+    modules: StateTransitionModules
   ): IBeaconStateView {
-    const newState = stateTransition(this.cachedState, signedBlock, options, {metrics, validatorMonitor});
-    return new BeaconStateView(newState);
+    return new BeaconStateView(stateTransition(this.cachedState, block, options, modules));
   }
 
   processSlots(slot: Slot, opts?: {dontTransferCache?: boolean}, modules?: StateTransitionModules): IBeaconStateView {