@lodestar/state-transition 1.50.0-dev.040a952dd7 → 1.50.0-dev.199b9d3a1f

package/src/stateView/nativeBeaconStateView.ts

@@ -1,6 +1,5 @@
 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 {
   BeaconBlock,
@@ -24,38 +23,38 @@ import {
   electra,
   fulu,
   gloas,
-  isBlindedBeaconBlock,
   phase0,
   rewards,
-  ssz,
 } from "@lodestar/types";
 import {Checkpoint, Fork} from "@lodestar/types/phase0";
 import {VoluntaryExitValidity} from "../block/processVoluntaryExit.js";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
 import {RewardCache} from "../cache/rewardCache.js";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
-import {EMPTY_SIGNATURE} from "../constants/constants.js";
 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 {computeNewStateRootStateTransitionOpts, getComputeNewStateRootResult} from "./computeNewStateRoot.js";
 import {
-  BlockSTFInput,
+  ComputeNewStateRootInput,
   ComputeNewStateRootResult,
   IBeaconStateView,
   IBeaconStateViewGloas,
   IBeaconStateViewLatestFork,
   IBeaconStateViewNative,
+  isStatePostGloas,
 } from "./interface.js";
 
 /**
  * Wraps a native binding (the auto-generated JS interface produced by a `.node`
  * file) and exposes it as a fully-conformant `IBeaconStateViewLatestFork`.
  *
- * The binding is typed `IBeaconStateViewNative`. This type models FFI-specific
- * inputs and outputs, such as serialized blocks and typed arrays. The wrapper
- * converts those values to the forms used by `IBeaconStateViewLatestFork`.
+ * The binding is typed `IBeaconStateViewNative` — identical to
+ * `IBeaconStateViewLatestFork` except `executionPayloadAvailability` is a raw
+ * `{uint8Array, bitLen}` POJO. The `executionPayloadAvailability` getter lifts
+ * that POJO back to a `BitArray` so beacon-node consumers see no difference from
+ * the TS-side `BeaconStateView`.
  *
  * Every getter that returns a value stable for the view's lifetime is cached so
  * the binding is hit at most once per field per view. Only mutable counters
@@ -65,97 +64,109 @@ import {
  */
 export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   // phase0
-  private cachedForkName: ForkName | null = null;
-  private cachedForkSeq: ForkSeq | null = null;
-  private cachedSlot: Slot | null = null;
-  private cachedFork: Fork | null = null;
-  private cachedEpoch: Epoch | null = null;
-  private cachedGenesisTime: number | null = null;
-  private cachedGenesisValidatorsRoot: Root | null = null;
-  private cachedEth1Data: phase0.Eth1Data | null = null;
-  private cachedLatestBlockHeader: phase0.BeaconBlockHeader | null = null;
-  private cachedPreviousJustifiedCheckpoint: Checkpoint | null = null;
-  private cachedCurrentJustifiedCheckpoint: Checkpoint | null = null;
-  private cachedFinalizedCheckpoint: Checkpoint | null = null;
+  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;
+  private _genesisTime: number | null = null;
+  private _genesisValidatorsRoot: Root | null = null;
+  private _eth1Data: phase0.Eth1Data | null = null;
+  private _latestBlockHeader: phase0.BeaconBlockHeader | null = null;
+  private _previousJustifiedCheckpoint: Checkpoint | null = null;
+  private _currentJustifiedCheckpoint: Checkpoint | null = null;
+  private _finalizedCheckpoint: Checkpoint | null = null;
   // shuffling / decision roots / proposers
-  private cachedPreviousDecisionRoot: RootHex | null = null;
-  private cachedCurrentDecisionRoot: RootHex | null = null;
-  private cachedNextDecisionRoot: RootHex | null = null;
+  private _previousDecisionRoot: RootHex | null = null;
+  private _currentDecisionRoot: RootHex | null = null;
+  private _nextDecisionRoot: RootHex | null = null;
   // previousProposers can be null, so use undefined as the "not loaded" sentinel
-  private cachedPreviousProposers: ValidatorIndex[] | null | undefined = undefined;
-  private cachedCurrentProposers: ValidatorIndex[] | null = null;
-  private cachedNextProposers: ValidatorIndex[] | null = null;
+  private _previousProposers: ValidatorIndex[] | null | undefined = undefined;
+  private _currentProposers: ValidatorIndex[] | null = null;
+  private _nextProposers: ValidatorIndex[] | null = null;
   // validators / balances
-  private cachedEffectiveBalanceIncrements: EffectiveBalanceIncrements | null = null;
-  private cachedValidatorCount: number | null = null;
-  private cachedActiveValidatorCount: number | null = null;
+  private _effectiveBalanceIncrements: EffectiveBalanceIncrements | null = null;
+  private _validatorCount: number | null = null;
+  private _activeValidatorCount: number | null = null;
   // backward compat
-  private cachedCreatedWithTransferCache: boolean | null = null;
+  private _createdWithTransferCache: boolean | null = null;
   // altair
-  private cachedCurrentSyncCommittee: SyncCommittee | null = null;
-  private cachedNextSyncCommittee: SyncCommittee | null = null;
-  private cachedPreviousEpochParticipation: Uint8Array | null = null;
-  private cachedCurrentEpochParticipation: Uint8Array | null = null;
-  private cachedCurrentSyncCommitteeIndexed: SyncCommitteeCache | null = null;
-  private cachedSyncProposerReward: number | null = null;
+  private _currentSyncCommittee: SyncCommittee | null = null;
+  private _nextSyncCommittee: SyncCommittee | null = null;
+  private _previousEpochParticipation: Uint8Array | null = null;
+  private _currentEpochParticipation: Uint8Array | null = null;
+  private _currentSyncCommitteeIndexed: SyncCommitteeCache | null = null;
+  private _syncProposerReward: number | null = null;
   // bellatrix
-  private cachedLatestExecutionPayloadHeader: ExecutionPayloadHeader | null = null;
-  private cachedPayloadBlockNumber: number | null = null;
-  private cachedIsExecutionStateType: boolean | null = null;
-  private cachedIsMergeTransitionComplete: boolean | null = null;
+  private _latestExecutionPayloadHeader: ExecutionPayloadHeader | null = null;
+  private _payloadBlockNumber: number | null = null;
+  private _isExecutionStateType: boolean | null = null;
+  private _isMergeTransitionComplete: boolean | null = null;
   // capella
-  private cachedHistoricalSummaries: capella.HistoricalSummaries | null = null;
+  private _historicalSummaries: capella.HistoricalSummaries | null = null;
   // electra
-  private cachedPendingPartialWithdrawals: electra.PendingPartialWithdrawals | null = null;
-  private cachedPendingConsolidations: electra.PendingConsolidations | null = null;
-  private cachedPendingDeposits: electra.PendingDeposits | null = null;
-  private cachedPendingDepositsCount: number | null = null;
-  private cachedPendingPartialWithdrawalsCount: number | null = null;
-  private cachedPendingConsolidationsCount: number | null = null;
+  private _pendingPartialWithdrawals: electra.PendingPartialWithdrawals | null = null;
+  private _pendingConsolidations: electra.PendingConsolidations | null = null;
+  private _pendingDeposits: electra.PendingDeposits | null = null;
+  private _pendingDepositsCount: number | null = null;
+  private _pendingPartialWithdrawalsCount: number | null = null;
+  private _pendingConsolidationsCount: number | null = null;
   // fulu
-  private cachedProposerLookahead: fulu.ProposerLookahead | null = null;
+  private _proposerLookahead: fulu.ProposerLookahead | null = null;
+  // gloas
+  private _executionPayloadAvailability: BitArray | null = null;
+  private _latestBlockHash: Bytes32 | 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;
+
   // 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
   // (e.g. a handful of slots per attestation pool scan) keep them tiny.
-  private readonly cachedBlockRootAtSlot = new Map<Slot, Root>();
-  private readonly cachedBlockRootAtEpoch = new Map<Epoch, Root>();
-  private readonly cachedStateRootAtSlot = new Map<Slot, Root>();
-  private readonly cachedRandaoMix = new Map<Epoch, Bytes32>();
-  private readonly cachedShufflingAtEpoch = new Map<Epoch, EpochShuffling>();
-  private readonly cachedBeaconCommittee = new Map<string, Uint32Array>();
-  private readonly cachedBeaconCommitteeCountPerSlot = new Map<Epoch, number>();
-  private readonly cachedShufflingDecisionRoot = new Map<Epoch, RootHex>();
-  private readonly cachedBeaconProposer = new Map<Slot, ValidatorIndex>();
-  private readonly cachedValidator = new Map<ValidatorIndex, phase0.Validator>();
-  private readonly cachedBalance = new Map<number, number>();
-  private readonly cachedIndexedSyncCommitteeAtEpoch = new Map<Epoch, SyncCommitteeCache>();
-  private readonly cachedIndexedSyncCommittee = new Map<Slot, SyncCommitteeCache>();
-  private readonly cachedSingleProof = new Map<bigint, Uint8Array[]>();
+  private readonly _getBlockRootAtSlot = new Map<Slot, Root>();
+  private readonly _getBlockRootAtEpoch = new Map<Epoch, Root>();
+  private readonly _getStateRootAtSlot = new Map<Slot, Root>();
+  private readonly _getRandaoMix = new Map<Epoch, Bytes32>();
+  private readonly _getShufflingAtEpoch = new Map<Epoch, EpochShuffling>();
+  private readonly _getBeaconCommittee = new Map<string, Uint32Array>();
+  private readonly _getBeaconCommitteeCountPerSlot = new Map<Epoch, number>();
+  private readonly _getShufflingDecisionRoot = new Map<Epoch, RootHex>();
+  private readonly _getBeaconProposer = new Map<Slot, ValidatorIndex>();
+  private readonly _getValidator = new Map<ValidatorIndex, phase0.Validator>();
+  private readonly _getBalance = new Map<number, number>();
+  private readonly _getIndexedSyncCommitteeAtEpoch = new Map<Epoch, SyncCommitteeCache>();
+  private readonly _getIndexedSyncCommittee = new Map<Slot, SyncCommitteeCache>();
+  private readonly _getSingleProof = new Map<bigint, Uint8Array[]>();
+  private readonly _getEpochPTCs = new Map<Epoch, Uint32Array[]>();
+  private readonly _getBuilder = new Map<BuilderIndex, gloas.Builder>();
 
   // No-arg method caches
-  private cachedPreviousShuffling: EpochShuffling | null = null;
-  private cachedCurrentShuffling: EpochShuffling | null = null;
-  private cachedNextShuffling: EpochShuffling | null = null;
-  private cachedEffectiveBalanceIncrementsZeroInactive: EffectiveBalanceIncrements | null = null;
-  private cachedAllValidators: phase0.Validator[] | null = null;
-  private cachedAllBalances: number[] | null = null;
-  private cachedLatestWeakSubjectivityCheckpointEpoch: Epoch | null = null;
-  private cachedFinalizedRootProof: Uint8Array[] | null = null;
-  private cachedUnrealizedCheckpoints: {
+  private _getPreviousShuffling: EpochShuffling | null = null;
+  private _getCurrentShuffling: EpochShuffling | null = null;
+  private _getNextShuffling: EpochShuffling | null = null;
+  private _getEffectiveBalanceIncrementsZeroInactive: EffectiveBalanceIncrements | null = null;
+  private _getAllValidators: phase0.Validator[] | null = null;
+  private _getBuildersLength: number | null = null;
+  private _getAllBalances: number[] | null = null;
+  private _getLatestWeakSubjectivityCheckpointEpoch: Epoch | null = null;
+  private _getFinalizedRootProof: Uint8Array[] | null = null;
+  private _computeUnrealizedCheckpoints: {
     justifiedCheckpoint: phase0.Checkpoint;
     finalizedCheckpoint: phase0.Checkpoint;
   } | null = null;
-  private cachedAnchorCheckpoint: {checkpoint: phase0.Checkpoint; blockHeader: phase0.BeaconBlockHeader} | null = null;
-  private cachedIsStateValidatorsNodesPopulated: boolean | null = null;
-  private cachedValue: BeaconState | null = null;
-  private cachedSerialized: Uint8Array | null = null;
-  private cachedSerializedSize: number | null = null;
-  private cachedSerializedValidators: Uint8Array | null = null;
-  private cachedSerializedValidatorsSize: number | null = null;
-  private cachedHashTreeRoot: Uint8Array | null = null;
-  private cachedSyncCommitteesWitness: SyncCommitteeWitness | null = null;
-  private cachedExpectedWithdrawals: {
+  private _computeAnchorCheckpoint: {checkpoint: phase0.Checkpoint; blockHeader: phase0.BeaconBlockHeader} | null =
+    null;
+  private _isStateValidatorsNodesPopulated: boolean | null = null;
+  private _toValue: BeaconState | null = null;
+  private _serialize: Uint8Array | null = null;
+  private _serializedSize: number | null = null;
+  private _serializeValidators: Uint8Array | null = null;
+  private _serializedValidatorsSize: number | null = null;
+  private _hashTreeRoot: Uint8Array | null = null;
+  private _getSyncCommitteesWitness: SyncCommitteeWitness | null = null;
+  private _getExpectedWithdrawals: {
     expectedWithdrawals: capella.Withdrawal[];
     processedBuilderWithdrawalsCount: number;
     processedPartialWithdrawalsCount: number;
@@ -163,137 +174,137 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     processedValidatorSweepCount: number;
   } | null = null;
 
-  constructor(
-    private readonly config: BeaconConfig,
-    readonly binding: IBeaconStateViewNative
-  ) {}
-
-  release(): void {
-    this.binding.release();
-  }
+  constructor(readonly binding: IBeaconStateViewNative) {}
 
+  // Binding returns pojo object {uint8Array: Uint8Array; bitLen: number}
+  // this class wrap it with BitArray to conform to the api
   get executionPayloadAvailability(): BitArray {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this._executionPayloadAvailability === null) {
+      const pojo = this.binding.executionPayloadAvailability;
+      this._executionPayloadAvailability = new BitArray(pojo.uint8Array, pojo.bitLen);
+    }
+
+    return this._executionPayloadAvailability;
   }
 
   // ─── phase0 ──────────────────────────────────────────────────────────────
 
   get forkName(): ForkName {
-    if (this.cachedForkName === null) {
-      this.cachedForkName = this.binding.forkName;
+    if (this._forkName === null) {
+      this._forkName = this.binding.forkName;
     }
-    return this.cachedForkName;
+    return this._forkName;
   }
 
   get forkSeq(): ForkSeq {
-    if (this.cachedForkSeq === null) {
-      this.cachedForkSeq = this.binding.forkSeq;
+    if (this._forkSeq === null) {
+      this._forkSeq = this.binding.forkSeq;
     }
-    return this.cachedForkSeq;
+    return this._forkSeq;
   }
 
   get slot(): Slot {
-    if (this.cachedSlot === null) {
-      this.cachedSlot = this.binding.slot;
+    if (this._slot === null) {
+      this._slot = this.binding.slot;
     }
-    return this.cachedSlot;
+    return this._slot;
   }
 
   get fork(): Fork {
-    if (this.cachedFork === null) {
-      this.cachedFork = this.binding.fork;
+    if (this._fork === null) {
+      this._fork = this.binding.fork;
     }
-    return this.cachedFork;
+    return this._fork;
   }
 
   get epoch(): Epoch {
-    if (this.cachedEpoch === null) {
-      this.cachedEpoch = this.binding.epoch;
+    if (this._epoch === null) {
+      this._epoch = this.binding.epoch;
     }
-    return this.cachedEpoch;
+    return this._epoch;
   }
 
   get genesisTime(): number {
-    if (this.cachedGenesisTime === null) {
-      this.cachedGenesisTime = this.binding.genesisTime;
+    if (this._genesisTime === null) {
+      this._genesisTime = this.binding.genesisTime;
     }
-    return this.cachedGenesisTime;
+    return this._genesisTime;
   }
 
   get genesisValidatorsRoot(): Root {
-    if (this.cachedGenesisValidatorsRoot === null) {
-      this.cachedGenesisValidatorsRoot = this.binding.genesisValidatorsRoot;
+    if (this._genesisValidatorsRoot === null) {
+      this._genesisValidatorsRoot = this.binding.genesisValidatorsRoot;
     }
-    return this.cachedGenesisValidatorsRoot;
+    return this._genesisValidatorsRoot;
   }
 
   get eth1Data(): phase0.Eth1Data {
-    if (this.cachedEth1Data === null) {
-      this.cachedEth1Data = this.binding.eth1Data;
+    if (this._eth1Data === null) {
+      this._eth1Data = this.binding.eth1Data;
     }
-    return this.cachedEth1Data;
+    return this._eth1Data;
   }
 
   get latestBlockHeader(): phase0.BeaconBlockHeader {
-    if (this.cachedLatestBlockHeader === null) {
-      this.cachedLatestBlockHeader = this.binding.latestBlockHeader;
+    if (this._latestBlockHeader === null) {
+      this._latestBlockHeader = this.binding.latestBlockHeader;
     }
-    return this.cachedLatestBlockHeader;
+    return this._latestBlockHeader;
   }
 
   get previousJustifiedCheckpoint(): Checkpoint {
-    if (this.cachedPreviousJustifiedCheckpoint === null) {
-      this.cachedPreviousJustifiedCheckpoint = this.binding.previousJustifiedCheckpoint;
+    if (this._previousJustifiedCheckpoint === null) {
+      this._previousJustifiedCheckpoint = this.binding.previousJustifiedCheckpoint;
     }
-    return this.cachedPreviousJustifiedCheckpoint;
+    return this._previousJustifiedCheckpoint;
   }
 
   get currentJustifiedCheckpoint(): Checkpoint {
-    if (this.cachedCurrentJustifiedCheckpoint === null) {
-      this.cachedCurrentJustifiedCheckpoint = this.binding.currentJustifiedCheckpoint;
+    if (this._currentJustifiedCheckpoint === null) {
+      this._currentJustifiedCheckpoint = this.binding.currentJustifiedCheckpoint;
     }
-    return this.cachedCurrentJustifiedCheckpoint;
+    return this._currentJustifiedCheckpoint;
   }
 
   get finalizedCheckpoint(): Checkpoint {
-    if (this.cachedFinalizedCheckpoint === null) {
-      this.cachedFinalizedCheckpoint = this.binding.finalizedCheckpoint;
+    if (this._finalizedCheckpoint === null) {
+      this._finalizedCheckpoint = this.binding.finalizedCheckpoint;
     }
-    return this.cachedFinalizedCheckpoint;
+    return this._finalizedCheckpoint;
   }
 
   getBlockRootAtSlot(slot: Slot): Root {
-    let cached = this.cachedBlockRootAtSlot.get(slot);
+    let cached = this._getBlockRootAtSlot.get(slot);
     if (cached === undefined) {
       cached = this.binding.getBlockRootAtSlot(slot);
-      this.cachedBlockRootAtSlot.set(slot, cached);
+      this._getBlockRootAtSlot.set(slot, cached);
     }
     return cached;
   }
 
   getBlockRootAtEpoch(epoch: Epoch): Root {
-    let cached = this.cachedBlockRootAtEpoch.get(epoch);
+    let cached = this._getBlockRootAtEpoch.get(epoch);
     if (cached === undefined) {
       cached = this.binding.getBlockRootAtEpoch(epoch);
-      this.cachedBlockRootAtEpoch.set(epoch, cached);
+      this._getBlockRootAtEpoch.set(epoch, cached);
     }
     return cached;
   }
 
   getStateRootAtSlot(slot: Slot): Root {
-    let cached = this.cachedStateRootAtSlot.get(slot);
+    let cached = this._getStateRootAtSlot.get(slot);
     if (cached === undefined) {
       cached = this.binding.getStateRootAtSlot(slot);
-      this.cachedStateRootAtSlot.set(slot, cached);
+      this._getStateRootAtSlot.set(slot, cached);
     }
     return cached;
   }
 
   getRandaoMix(epoch: Epoch): Bytes32 {
-    let cached = this.cachedRandaoMix.get(epoch);
+    let cached = this._getRandaoMix.get(epoch);
     if (cached === undefined) {
       cached = this.binding.getRandaoMix(epoch);
-      this.cachedRandaoMix.set(epoch, cached);
+      this._getRandaoMix.set(epoch, cached);
     }
     return cached;
   }
@@ -301,112 +312,112 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   // Shuffling and committees
 
   getShufflingAtEpoch(epoch: Epoch): EpochShuffling {
-    let cached = this.cachedShufflingAtEpoch.get(epoch);
+    let cached = this._getShufflingAtEpoch.get(epoch);
     if (cached === undefined) {
       cached = this.binding.getShufflingAtEpoch(epoch);
-      this.cachedShufflingAtEpoch.set(epoch, cached);
+      this._getShufflingAtEpoch.set(epoch, cached);
     }
     return cached;
   }
 
   getBeaconCommittee(slot: Slot, index: CommitteeIndex): Uint32Array {
     const key = `${slot}:${index}`;
-    let cached = this.cachedBeaconCommittee.get(key);
+    let cached = this._getBeaconCommittee.get(key);
     if (cached === undefined) {
       cached = this.binding.getBeaconCommittee(slot, index);
-      this.cachedBeaconCommittee.set(key, cached);
+      this._getBeaconCommittee.set(key, cached);
     }
     return cached;
   }
 
   getBeaconCommitteeCountPerSlot(epoch: Epoch): number {
-    let cached = this.cachedBeaconCommitteeCountPerSlot.get(epoch);
+    let cached = this._getBeaconCommitteeCountPerSlot.get(epoch);
     if (cached === undefined) {
       cached = this.binding.getBeaconCommitteeCountPerSlot(epoch);
-      this.cachedBeaconCommitteeCountPerSlot.set(epoch, cached);
+      this._getBeaconCommitteeCountPerSlot.set(epoch, cached);
     }
     return cached;
   }
 
   get previousDecisionRoot(): RootHex {
-    if (this.cachedPreviousDecisionRoot === null) {
-      this.cachedPreviousDecisionRoot = this.binding.previousDecisionRoot;
+    if (this._previousDecisionRoot === null) {
+      this._previousDecisionRoot = this.binding.previousDecisionRoot;
     }
-    return this.cachedPreviousDecisionRoot;
+    return this._previousDecisionRoot;
   }
 
   get currentDecisionRoot(): RootHex {
-    if (this.cachedCurrentDecisionRoot === null) {
-      this.cachedCurrentDecisionRoot = this.binding.currentDecisionRoot;
+    if (this._currentDecisionRoot === null) {
+      this._currentDecisionRoot = this.binding.currentDecisionRoot;
     }
-    return this.cachedCurrentDecisionRoot;
+    return this._currentDecisionRoot;
   }
 
   get nextDecisionRoot(): RootHex {
-    if (this.cachedNextDecisionRoot === null) {
-      this.cachedNextDecisionRoot = this.binding.nextDecisionRoot;
+    if (this._nextDecisionRoot === null) {
+      this._nextDecisionRoot = this.binding.nextDecisionRoot;
     }
-    return this.cachedNextDecisionRoot;
+    return this._nextDecisionRoot;
   }
 
   getShufflingDecisionRoot(epoch: Epoch): RootHex {
-    let cached = this.cachedShufflingDecisionRoot.get(epoch);
+    let cached = this._getShufflingDecisionRoot.get(epoch);
     if (cached === undefined) {
       cached = this.binding.getShufflingDecisionRoot(epoch);
-      this.cachedShufflingDecisionRoot.set(epoch, cached);
+      this._getShufflingDecisionRoot.set(epoch, cached);
     }
     return cached;
   }
 
   getPreviousShuffling(): EpochShuffling {
-    if (this.cachedPreviousShuffling === null) {
-      this.cachedPreviousShuffling = this.binding.getPreviousShuffling();
+    if (this._getPreviousShuffling === null) {
+      this._getPreviousShuffling = this.binding.getPreviousShuffling();
     }
-    return this.cachedPreviousShuffling;
+    return this._getPreviousShuffling;
   }
 
   getCurrentShuffling(): EpochShuffling {
-    if (this.cachedCurrentShuffling === null) {
-      this.cachedCurrentShuffling = this.binding.getCurrentShuffling();
+    if (this._getCurrentShuffling === null) {
+      this._getCurrentShuffling = this.binding.getCurrentShuffling();
     }
-    return this.cachedCurrentShuffling;
+    return this._getCurrentShuffling;
   }
 
   getNextShuffling(): EpochShuffling {
-    if (this.cachedNextShuffling === null) {
-      this.cachedNextShuffling = this.binding.getNextShuffling();
+    if (this._getNextShuffling === null) {
+      this._getNextShuffling = this.binding.getNextShuffling();
     }
-    return this.cachedNextShuffling;
+    return this._getNextShuffling;
   }
 
   // Proposer shuffling
 
   get previousProposers(): ValidatorIndex[] | null {
-    if (this.cachedPreviousProposers === undefined) {
-      this.cachedPreviousProposers = this.binding.previousProposers;
+    if (this._previousProposers === undefined) {
+      this._previousProposers = this.binding.previousProposers;
     }
-    return this.cachedPreviousProposers;
+    return this._previousProposers;
   }
 
   get currentProposers(): ValidatorIndex[] {
-    if (this.cachedCurrentProposers === null) {
-      this.cachedCurrentProposers = this.binding.currentProposers;
+    if (this._currentProposers === null) {
+      this._currentProposers = this.binding.currentProposers;
     }
-    return this.cachedCurrentProposers;
+    return this._currentProposers;
   }
 
   get nextProposers(): ValidatorIndex[] {
-    if (this.cachedNextProposers === null) {
-      this.cachedNextProposers = this.binding.nextProposers;
+    if (this._nextProposers === null) {
+      this._nextProposers = this.binding.nextProposers;
     }
-    return this.cachedNextProposers;
+    return this._nextProposers;
   }
 
   getBeaconProposer(slot: Slot): ValidatorIndex {
-    let cached = this.cachedBeaconProposer.get(slot);
+    let cached = this._getBeaconProposer.get(slot);
     if (cached === undefined) {
       cached = this.binding.getBeaconProposer(slot);
-      this.cachedBeaconProposer.set(slot, cached);
+      this._getBeaconProposer.set(slot, cached);
     }
     return cached;
   }
@@ -414,33 +425,33 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   // Validators and balances
 
   get effectiveBalanceIncrements(): EffectiveBalanceIncrements {
-    if (this.cachedEffectiveBalanceIncrements === null) {
-      this.cachedEffectiveBalanceIncrements = this.binding.effectiveBalanceIncrements;
+    if (this._effectiveBalanceIncrements === null) {
+      this._effectiveBalanceIncrements = this.binding.effectiveBalanceIncrements;
     }
-    return this.cachedEffectiveBalanceIncrements;
+    return this._effectiveBalanceIncrements;
   }
 
   getEffectiveBalanceIncrementsZeroInactive(): EffectiveBalanceIncrements {
-    if (this.cachedEffectiveBalanceIncrementsZeroInactive === null) {
-      this.cachedEffectiveBalanceIncrementsZeroInactive = this.binding.getEffectiveBalanceIncrementsZeroInactive();
+    if (this._getEffectiveBalanceIncrementsZeroInactive === null) {
+      this._getEffectiveBalanceIncrementsZeroInactive = this.binding.getEffectiveBalanceIncrementsZeroInactive();
     }
-    return this.cachedEffectiveBalanceIncrementsZeroInactive;
+    return this._getEffectiveBalanceIncrementsZeroInactive;
   }
 
   getBalance(index: number): number {
-    let cached = this.cachedBalance.get(index);
+    let cached = this._getBalance.get(index);
     if (cached === undefined) {
       cached = this.binding.getBalance(index);
-      this.cachedBalance.set(index, cached);
+      this._getBalance.set(index, cached);
     }
     return cached;
   }
 
   getValidator(index: ValidatorIndex): phase0.Validator {
-    let cached = this.cachedValidator.get(index);
+    let cached = this._getValidator.get(index);
     if (cached === undefined) {
       cached = this.binding.getValidator(index);
-      this.cachedValidator.set(index, cached);
+      this._getValidator.set(index, cached);
     }
     return cached;
   }
@@ -450,31 +461,31 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   get validatorCount(): number {
-    if (this.cachedValidatorCount === null) {
-      this.cachedValidatorCount = this.binding.validatorCount;
+    if (this._validatorCount === null) {
+      this._validatorCount = this.binding.validatorCount;
     }
-    return this.cachedValidatorCount;
+    return this._validatorCount;
   }
 
   get activeValidatorCount(): number {
-    if (this.cachedActiveValidatorCount === null) {
-      this.cachedActiveValidatorCount = this.binding.activeValidatorCount;
+    if (this._activeValidatorCount === null) {
+      this._activeValidatorCount = this.binding.activeValidatorCount;
     }
-    return this.cachedActiveValidatorCount;
+    return this._activeValidatorCount;
   }
 
   getAllValidators(): phase0.Validator[] {
-    if (this.cachedAllValidators === null) {
-      this.cachedAllValidators = this.binding.getAllValidators();
+    if (this._getAllValidators === null) {
+      this._getAllValidators = this.binding.getAllValidators();
     }
-    return this.cachedAllValidators;
+    return this._getAllValidators;
   }
 
   getAllBalances(): number[] {
-    if (this.cachedAllBalances === null) {
-      this.cachedAllBalances = this.binding.getAllBalances();
+    if (this._getAllBalances === null) {
+      this._getAllBalances = this.binding.getAllBalances();
     }
-    return this.cachedAllBalances;
+    return this._getAllBalances;
   }
 
   // API
@@ -483,30 +494,19 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     return this.binding.proposerRewards;
   }
 
-  async computeBlockRewards(block: BeaconBlock, proposerRewards?: RewardCache): Promise<rewards.BlockRewards> {
-    const isBlinded = isBlindedBeaconBlock(block);
-    const signedBlockBytes = isBlinded
-      ? this.config.getPostBellatrixForkTypes(block.slot).SignedBlindedBeaconBlock.serialize({
-          message: block as BlindedBeaconBlock,
-          signature: EMPTY_SIGNATURE,
-        } as SignedBlindedBeaconBlock)
-      : this.config.getForkTypes(block.slot).SignedBeaconBlock.serialize({
-          message: block,
-          signature: EMPTY_SIGNATURE,
-        } as SignedBeaconBlock);
-
-    return this.binding.computeBlockRewards(signedBlockBytes, isBlinded, proposerRewards);
+  computeBlockRewards(block: BeaconBlock, proposerRewards?: RewardCache): Promise<rewards.BlockRewards> {
+    return this.binding.computeBlockRewards(block, proposerRewards);
   }
 
-  async computeAttestationsRewards(validatorIds?: (ValidatorIndex | string)[]): Promise<rewards.AttestationsRewards> {
+  computeAttestationsRewards(validatorIds?: (ValidatorIndex | string)[]): Promise<rewards.AttestationsRewards> {
     return this.binding.computeAttestationsRewards(validatorIds);
   }
 
   getLatestWeakSubjectivityCheckpointEpoch(): Epoch {
-    if (this.cachedLatestWeakSubjectivityCheckpointEpoch === null) {
-      this.cachedLatestWeakSubjectivityCheckpointEpoch = this.binding.getLatestWeakSubjectivityCheckpointEpoch();
+    if (this._getLatestWeakSubjectivityCheckpointEpoch === null) {
+      this._getLatestWeakSubjectivityCheckpointEpoch = this.binding.getLatestWeakSubjectivityCheckpointEpoch();
     }
-    return this.cachedLatestWeakSubjectivityCheckpointEpoch;
+    return this._getLatestWeakSubjectivityCheckpointEpoch;
   }
 
   // Validation
@@ -525,17 +525,17 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   // Proofs
 
   getFinalizedRootProof(): Uint8Array[] {
-    if (this.cachedFinalizedRootProof === null) {
-      this.cachedFinalizedRootProof = this.binding.getFinalizedRootProof();
+    if (this._getFinalizedRootProof === null) {
+      this._getFinalizedRootProof = this.binding.getFinalizedRootProof();
     }
-    return this.cachedFinalizedRootProof;
+    return this._getFinalizedRootProof;
   }
 
   getSingleProof(gindex: bigint): Uint8Array[] {
-    let cached = this.cachedSingleProof.get(gindex);
+    let cached = this._getSingleProof.get(gindex);
     if (cached === undefined) {
       cached = this.binding.getSingleProof(gindex);
-      this.cachedSingleProof.set(gindex, cached);
+      this._getSingleProof.set(gindex, cached);
     }
     return cached;
   }
@@ -550,17 +550,17 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     justifiedCheckpoint: phase0.Checkpoint;
     finalizedCheckpoint: phase0.Checkpoint;
   } {
-    if (this.cachedUnrealizedCheckpoints === null) {
-      this.cachedUnrealizedCheckpoints = this.binding.computeUnrealizedCheckpoints();
+    if (this._computeUnrealizedCheckpoints === null) {
+      this._computeUnrealizedCheckpoints = this.binding.computeUnrealizedCheckpoints();
     }
-    return this.cachedUnrealizedCheckpoints;
+    return this._computeUnrealizedCheckpoints;
   }
 
   computeAnchorCheckpoint(): {checkpoint: phase0.Checkpoint; blockHeader: phase0.BeaconBlockHeader} {
-    if (this.cachedAnchorCheckpoint === null) {
-      this.cachedAnchorCheckpoint = this.binding.computeAnchorCheckpoint();
+    if (this._computeAnchorCheckpoint === null) {
+      this._computeAnchorCheckpoint = this.binding.computeAnchorCheckpoint();
     }
-    return this.cachedAnchorCheckpoint;
+    return this._computeAnchorCheckpoint;
   }
 
   // Backward compatibility
@@ -574,17 +574,17 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   get createdWithTransferCache(): boolean {
-    if (this.cachedCreatedWithTransferCache === null) {
-      this.cachedCreatedWithTransferCache = this.binding.createdWithTransferCache;
+    if (this._createdWithTransferCache === null) {
+      this._createdWithTransferCache = this.binding.createdWithTransferCache;
     }
-    return this.cachedCreatedWithTransferCache;
+    return this._createdWithTransferCache;
   }
 
   isStateValidatorsNodesPopulated(): boolean {
-    if (this.cachedIsStateValidatorsNodesPopulated === null) {
-      this.cachedIsStateValidatorsNodesPopulated = this.binding.isStateValidatorsNodesPopulated();
+    if (this._isStateValidatorsNodesPopulated === null) {
+      this._isStateValidatorsNodesPopulated = this.binding.isStateValidatorsNodesPopulated();
     }
-    return this.cachedIsStateValidatorsNodesPopulated;
+    return this._isStateValidatorsNodesPopulated;
   }
 
   // Serialization
@@ -594,28 +594,28 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     seedValidatorsBytes?: Uint8Array,
     opts?: {preloadValidatorsAndBalances?: boolean}
   ): IBeaconStateView {
-    return new NativeBeaconStateView(this.config, this.binding.loadOtherState(stateBytes, seedValidatorsBytes, opts));
+    return new NativeBeaconStateView(this.binding.loadOtherState(stateBytes, seedValidatorsBytes, opts));
   }
 
   toValue(): BeaconState {
-    if (this.cachedValue === null) {
-      this.cachedValue = this.binding.toValue();
+    if (this._toValue === null) {
+      this._toValue = this.binding.toValue();
     }
-    return this.cachedValue;
+    return this._toValue;
   }
 
   serialize(): Uint8Array {
-    if (this.cachedSerialized === null) {
-      this.cachedSerialized = this.binding.serialize();
+    if (this._serialize === null) {
+      this._serialize = this.binding.serialize();
     }
-    return this.cachedSerialized;
+    return this._serialize;
   }
 
   serializedSize(): number {
-    if (this.cachedSerializedSize === null) {
-      this.cachedSerializedSize = this.binding.serializedSize();
+    if (this._serializedSize === null) {
+      this._serializedSize = this.binding.serializedSize();
     }
-    return this.cachedSerializedSize;
+    return this._serializedSize;
   }
 
   serializeToBytes(output: ByteViews, offset: number): number {
@@ -623,17 +623,17 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   serializeValidators(): Uint8Array {
-    if (this.cachedSerializedValidators === null) {
-      this.cachedSerializedValidators = this.binding.serializeValidators();
+    if (this._serializeValidators === null) {
+      this._serializeValidators = this.binding.serializeValidators();
     }
-    return this.cachedSerializedValidators;
+    return this._serializeValidators;
   }
 
   serializedValidatorsSize(): number {
-    if (this.cachedSerializedValidatorsSize === null) {
-      this.cachedSerializedValidatorsSize = this.binding.serializedValidatorsSize();
+    if (this._serializedValidatorsSize === null) {
+      this._serializedValidatorsSize = this.binding.serializedValidatorsSize();
     }
-    return this.cachedSerializedValidatorsSize;
+    return this._serializedValidatorsSize;
   }
 
   serializeValidatorsToBytes(output: ByteViews, offset: number): number {
@@ -641,53 +641,47 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   hashTreeRoot(): Uint8Array {
-    if (this.cachedHashTreeRoot === null) {
-      this.cachedHashTreeRoot = this.binding.hashTreeRoot();
+    if (this._hashTreeRoot === null) {
+      this._hashTreeRoot = this.binding.hashTreeRoot();
     }
-    return this.cachedHashTreeRoot;
+    return this._hashTreeRoot;
   }
 
   // State transition
 
-  computeNewStateRoot(input: BlockSTFInput, modules: StateTransitionModules): ComputeNewStateRootResult {
-    const postState = this.stateTransition(input, computeNewStateRootStateTransitionOpts, modules);
+  computeNewStateRoot(input: ComputeNewStateRootInput, modules: StateTransitionModules): ComputeNewStateRootResult {
+    const postState = new NativeBeaconStateView(
+      this.binding.stateTransition(input.block, computeNewStateRootStateTransitionOpts, modules)
+    );
     return getComputeNewStateRootResult(postState);
   }
 
   stateTransition(
-    {block, ssz}: BlockSTFInput,
+    signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock,
     options: StateTransitionOpts,
-    _modules: StateTransitionModules
+    modules: StateTransitionModules
   ): IBeaconStateView {
-    const isBlinded = isBlindedBeaconBlock(block.message);
-    const signedBlockBytes =
-      ssz ??
-      (isBlinded
-        ? this.config
-            .getPostBellatrixForkTypes(block.message.slot)
-            .SignedBlindedBeaconBlock.serialize(block as SignedBlindedBeaconBlock)
-        : this.config.getForkTypes(block.message.slot).SignedBeaconBlock.serialize(block as SignedBeaconBlock));
-    return new NativeBeaconStateView(this.config, this.binding.stateTransition(signedBlockBytes, isBlinded, options));
+    return new NativeBeaconStateView(this.binding.stateTransition(signedBlock, options, modules));
   }
 
-  processSlots(slot: Slot, opts?: {dontTransferCache?: boolean}, _modules?: StateTransitionModules): IBeaconStateView {
-    return new NativeBeaconStateView(this.config, this.binding.processSlots(slot, opts));
+  processSlots(slot: Slot, opts?: {dontTransferCache?: boolean}, modules?: StateTransitionModules): IBeaconStateView {
+    return new NativeBeaconStateView(this.binding.processSlots(slot, opts, modules));
   }
 
   // ─── altair ──────────────────────────────────────────────────────────────
 
   get previousEpochParticipation(): Uint8Array {
-    if (this.cachedPreviousEpochParticipation === null) {
-      this.cachedPreviousEpochParticipation = this.binding.previousEpochParticipation;
+    if (this._previousEpochParticipation === null) {
+      this._previousEpochParticipation = this.binding.previousEpochParticipation;
     }
-    return this.cachedPreviousEpochParticipation;
+    return this._previousEpochParticipation;
   }
 
   get currentEpochParticipation(): Uint8Array {
-    if (this.cachedCurrentEpochParticipation === null) {
-      this.cachedCurrentEpochParticipation = this.binding.currentEpochParticipation;
+    if (this._currentEpochParticipation === null) {
+      this._currentEpochParticipation = this.binding.currentEpochParticipation;
     }
-    return this.cachedCurrentEpochParticipation;
+    return this._currentEpochParticipation;
   }
 
   getPreviousEpochParticipation(validatorIndex: ValidatorIndex): number {
@@ -699,52 +693,52 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   get currentSyncCommittee(): altair.SyncCommittee {
-    if (this.cachedCurrentSyncCommittee === null) {
-      this.cachedCurrentSyncCommittee = this.binding.currentSyncCommittee;
+    if (this._currentSyncCommittee === null) {
+      this._currentSyncCommittee = this.binding.currentSyncCommittee;
     }
-    return this.cachedCurrentSyncCommittee;
+    return this._currentSyncCommittee;
   }
 
   get nextSyncCommittee(): altair.SyncCommittee {
-    if (this.cachedNextSyncCommittee === null) {
-      this.cachedNextSyncCommittee = this.binding.nextSyncCommittee;
+    if (this._nextSyncCommittee === null) {
+      this._nextSyncCommittee = this.binding.nextSyncCommittee;
     }
-    return this.cachedNextSyncCommittee;
+    return this._nextSyncCommittee;
   }
 
   get currentSyncCommitteeIndexed(): SyncCommitteeCache {
-    if (this.cachedCurrentSyncCommitteeIndexed === null) {
-      this.cachedCurrentSyncCommitteeIndexed = this.binding.currentSyncCommitteeIndexed;
+    if (this._currentSyncCommitteeIndexed === null) {
+      this._currentSyncCommitteeIndexed = this.binding.currentSyncCommitteeIndexed;
     }
-    return this.cachedCurrentSyncCommitteeIndexed;
+    return this._currentSyncCommitteeIndexed;
   }
 
   get syncProposerReward(): number {
-    if (this.cachedSyncProposerReward === null) {
-      this.cachedSyncProposerReward = this.binding.syncProposerReward;
+    if (this._syncProposerReward === null) {
+      this._syncProposerReward = this.binding.syncProposerReward;
     }
-    return this.cachedSyncProposerReward;
+    return this._syncProposerReward;
   }
 
   getIndexedSyncCommitteeAtEpoch(epoch: Epoch): SyncCommitteeCache {
-    let cached = this.cachedIndexedSyncCommitteeAtEpoch.get(epoch);
+    let cached = this._getIndexedSyncCommitteeAtEpoch.get(epoch);
     if (cached === undefined) {
       cached = this.binding.getIndexedSyncCommitteeAtEpoch(epoch);
-      this.cachedIndexedSyncCommitteeAtEpoch.set(epoch, cached);
+      this._getIndexedSyncCommitteeAtEpoch.set(epoch, cached);
     }
     return cached;
   }
 
   getIndexedSyncCommittee(slot: Slot): SyncCommitteeCache {
-    let cached = this.cachedIndexedSyncCommittee.get(slot);
+    let cached = this._getIndexedSyncCommittee.get(slot);
     if (cached === undefined) {
       cached = this.binding.getIndexedSyncCommittee(slot);
-      this.cachedIndexedSyncCommittee.set(slot, cached);
+      this._getIndexedSyncCommittee.set(slot, cached);
     }
     return cached;
   }
 
-  async computeSyncCommitteeRewards(
+  computeSyncCommitteeRewards(
     block: BeaconBlock,
     validatorIds: (ValidatorIndex | string)[]
   ): Promise<rewards.SyncCommitteeRewards> {
@@ -752,40 +746,40 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   getSyncCommitteesWitness(): SyncCommitteeWitness {
-    if (this.cachedSyncCommitteesWitness === null) {
-      this.cachedSyncCommitteesWitness = this.binding.getSyncCommitteesWitness();
+    if (this._getSyncCommitteesWitness === null) {
+      this._getSyncCommitteesWitness = this.binding.getSyncCommitteesWitness();
     }
-    return this.cachedSyncCommitteesWitness;
+    return this._getSyncCommitteesWitness;
   }
 
   // ─── bellatrix ───────────────────────────────────────────────────────────
 
   get latestExecutionPayloadHeader(): ExecutionPayloadHeader {
-    if (this.cachedLatestExecutionPayloadHeader === null) {
-      this.cachedLatestExecutionPayloadHeader = this.binding.latestExecutionPayloadHeader;
+    if (this._latestExecutionPayloadHeader === null) {
+      this._latestExecutionPayloadHeader = this.binding.latestExecutionPayloadHeader;
     }
-    return this.cachedLatestExecutionPayloadHeader;
+    return this._latestExecutionPayloadHeader;
   }
 
   get payloadBlockNumber(): number {
-    if (this.cachedPayloadBlockNumber === null) {
-      this.cachedPayloadBlockNumber = this.binding.payloadBlockNumber;
+    if (this._payloadBlockNumber === null) {
+      this._payloadBlockNumber = this.binding.payloadBlockNumber;
     }
-    return this.cachedPayloadBlockNumber;
+    return this._payloadBlockNumber;
   }
 
   get isExecutionStateType(): boolean {
-    if (this.cachedIsExecutionStateType === null) {
-      this.cachedIsExecutionStateType = this.binding.isExecutionStateType;
+    if (this._isExecutionStateType === null) {
+      this._isExecutionStateType = this.binding.isExecutionStateType;
     }
-    return this.cachedIsExecutionStateType;
+    return this._isExecutionStateType;
   }
 
   get isMergeTransitionComplete(): boolean {
-    if (this.cachedIsMergeTransitionComplete === null) {
-      this.cachedIsMergeTransitionComplete = this.binding.isMergeTransitionComplete;
+    if (this._isMergeTransitionComplete === null) {
+      this._isMergeTransitionComplete = this.binding.isMergeTransitionComplete;
     }
-    return this.cachedIsMergeTransitionComplete;
+    return this._isMergeTransitionComplete;
   }
 
   isExecutionEnabled(block: BeaconBlock | BlindedBeaconBlock): boolean {
@@ -795,10 +789,10 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
   // ─── capella ─────────────────────────────────────────────────────────────
 
   get historicalSummaries(): capella.HistoricalSummaries {
-    if (this.cachedHistoricalSummaries === null) {
-      this.cachedHistoricalSummaries = this.binding.historicalSummaries;
+    if (this._historicalSummaries === null) {
+      this._historicalSummaries = this.binding.historicalSummaries;
     }
-    return this.cachedHistoricalSummaries;
+    return this._historicalSummaries;
   }
 
   getExpectedWithdrawals(): {
@@ -808,127 +802,154 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     processedBuildersSweepCount: number;
     processedValidatorSweepCount: number;
   } {
-    if (this.cachedExpectedWithdrawals === null) {
-      this.cachedExpectedWithdrawals = this.binding.getExpectedWithdrawals();
+    if (this._getExpectedWithdrawals === null) {
+      this._getExpectedWithdrawals = this.binding.getExpectedWithdrawals();
     }
-    return this.cachedExpectedWithdrawals;
+    return this._getExpectedWithdrawals;
   }
 
   // ─── electra ─────────────────────────────────────────────────────────────
 
   get pendingDeposits(): electra.PendingDeposits {
-    if (this.cachedPendingDeposits === null) {
-      this.cachedPendingDeposits = ssz.electra.PendingDeposits.deserialize(this.binding.pendingDeposits);
+    if (this._pendingDeposits === null) {
+      this._pendingDeposits = this.binding.pendingDeposits;
     }
-    return this.cachedPendingDeposits;
+    return this._pendingDeposits;
   }
 
   get pendingDepositsCount(): number {
-    if (this.cachedPendingDepositsCount === null) {
-      this.cachedPendingDepositsCount = this.binding.pendingDepositsCount;
+    if (this._pendingDepositsCount === null) {
+      this._pendingDepositsCount = this.binding.pendingDepositsCount;
     }
-    return this.cachedPendingDepositsCount;
+    return this._pendingDepositsCount;
   }
 
   get pendingPartialWithdrawals(): electra.PendingPartialWithdrawals {
-    if (this.cachedPendingPartialWithdrawals === null) {
-      this.cachedPendingPartialWithdrawals = ssz.electra.PendingPartialWithdrawals.deserialize(
-        this.binding.pendingPartialWithdrawals
-      );
+    if (this._pendingPartialWithdrawals === null) {
+      this._pendingPartialWithdrawals = this.binding.pendingPartialWithdrawals;
     }
-    return this.cachedPendingPartialWithdrawals;
+    return this._pendingPartialWithdrawals;
   }
 
   get pendingPartialWithdrawalsCount(): number {
-    if (this.cachedPendingPartialWithdrawalsCount === null) {
-      this.cachedPendingPartialWithdrawalsCount = this.binding.pendingPartialWithdrawalsCount;
+    if (this._pendingPartialWithdrawalsCount === null) {
+      this._pendingPartialWithdrawalsCount = this.binding.pendingPartialWithdrawalsCount;
     }
-    return this.cachedPendingPartialWithdrawalsCount;
+    return this._pendingPartialWithdrawalsCount;
   }
 
   get pendingConsolidations(): electra.PendingConsolidations {
-    if (this.cachedPendingConsolidations === null) {
-      this.cachedPendingConsolidations = ssz.electra.PendingConsolidations.deserialize(
-        this.binding.pendingConsolidations
-      );
+    if (this._pendingConsolidations === null) {
+      this._pendingConsolidations = this.binding.pendingConsolidations;
     }
-    return this.cachedPendingConsolidations;
+    return this._pendingConsolidations;
   }
 
   get pendingConsolidationsCount(): number {
-    if (this.cachedPendingConsolidationsCount === null) {
-      this.cachedPendingConsolidationsCount = this.binding.pendingConsolidationsCount;
+    if (this._pendingConsolidationsCount === null) {
+      this._pendingConsolidationsCount = this.binding.pendingConsolidationsCount;
     }
-    return this.cachedPendingConsolidationsCount;
+    return this._pendingConsolidationsCount;
   }
 
   // ─── fulu ────────────────────────────────────────────────────────────────
 
   get proposerLookahead(): fulu.ProposerLookahead {
-    if (this.cachedProposerLookahead === null) {
-      this.cachedProposerLookahead = Array.from(this.binding.proposerLookahead);
+    if (this._proposerLookahead === null) {
+      this._proposerLookahead = this.binding.proposerLookahead;
     }
-    return this.cachedProposerLookahead;
+    return this._proposerLookahead;
   }
 
-  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._latestBlockHash === null) {
+      this._latestBlockHash = this.binding.latestBlockHash;
+    }
+    return this._latestBlockHash;
   }
 
+  // executionPayloadAvailability getter is defined near the top of the class.
+
   get latestExecutionPayloadBid(): ExecutionPayloadBid {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this._latestExecutionPayloadBid === null) {
+      this._latestExecutionPayloadBid = this.binding.latestExecutionPayloadBid;
+    }
+    return this._latestExecutionPayloadBid;
   }
 
   get payloadExpectedWithdrawals(): capella.Withdrawal[] {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this._payloadExpectedWithdrawals === null) {
+      this._payloadExpectedWithdrawals = this.binding.payloadExpectedWithdrawals;
+    }
+    return this._payloadExpectedWithdrawals;
   }
 
   get builderPendingPayments(): gloas.BuilderPendingPayments {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this._builderPendingPayments === null) {
+      this._builderPendingPayments = this.binding.builderPendingPayments;
+    }
+    return this._builderPendingPayments;
   }
 
   get builderPendingWithdrawals(): gloas.BuilderPendingWithdrawals {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this._builderPendingWithdrawals === null) {
+      this._builderPendingWithdrawals = this.binding.builderPendingWithdrawals;
+    }
+    return this._builderPendingWithdrawals;
   }
 
-  getBuilder(_index: BuilderIndex): gloas.Builder {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+  getBuilder(index: BuilderIndex): gloas.Builder {
+    let cached = this._getBuilder.get(index);
+    if (cached === undefined) {
+      cached = this.binding.getBuilder(index);
+      this._getBuilder.set(index, cached);
+    }
+    return cached;
   }
 
   getBuildersLength(): number {
-    throw new Error("NativeBeaconStateView does not support Gloas");
+    if (this._getBuildersLength === null) {
+      this._getBuildersLength = this.binding.getBuildersLength();
+    }
+    return this._getBuildersLength;
   }
 
-  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[] {
+    let cached = this._getEpochPTCs.get(epoch);
+    if (cached === undefined) {
+      cached = this.binding.getEpochPTCs(epoch);
+      this._getEpochPTCs.set(epoch, cached);
+    }
+    return cached;
   }
 
-  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 view = new NativeBeaconStateView(this.binding.withParentPayloadApplied(executionRequests));
+    if (!isStatePostGloas(view)) {
+      throw new Error("Expected gloas state from withParentPayloadApplied");
+    }
+    return view;
   }
 }