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

package/lib/stateView/nativeBeaconStateView.js

@@ -1,13 +1,15 @@
-import { isBlindedBeaconBlock, ssz, } from "@lodestar/types";
-import { EMPTY_SIGNATURE } from "../constants/constants.js";
+import { BitArray } from "@chainsafe/ssz";
 import { computeNewStateRootStateTransitionOpts, getComputeNewStateRootResult } from "./computeNewStateRoot.js";
+import { 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
@@ -16,334 +18,345 @@ import { computeNewStateRootStateTransitionOpts, getComputeNewStateRootResult }
  * would need a per-arg map and isn't worth it without a hot-path signal.
  */
 export class NativeBeaconStateView {
-    config;
     binding;
     // phase0
-    cachedForkName = null;
-    cachedForkSeq = null;
-    cachedSlot = null;
-    cachedFork = null;
-    cachedEpoch = null;
-    cachedGenesisTime = null;
-    cachedGenesisValidatorsRoot = null;
-    cachedEth1Data = null;
-    cachedLatestBlockHeader = null;
-    cachedPreviousJustifiedCheckpoint = null;
-    cachedCurrentJustifiedCheckpoint = null;
-    cachedFinalizedCheckpoint = null;
+    _forkName = null;
+    _forkSeq = null;
+    _slot = null;
+    _fork = null;
+    _epoch = null;
+    _genesisTime = null;
+    _genesisValidatorsRoot = null;
+    _eth1Data = null;
+    _latestBlockHeader = null;
+    _previousJustifiedCheckpoint = null;
+    _currentJustifiedCheckpoint = null;
+    _finalizedCheckpoint = null;
     // shuffling / decision roots / proposers
-    cachedPreviousDecisionRoot = null;
-    cachedCurrentDecisionRoot = null;
-    cachedNextDecisionRoot = null;
+    _previousDecisionRoot = null;
+    _currentDecisionRoot = null;
+    _nextDecisionRoot = null;
     // previousProposers can be null, so use undefined as the "not loaded" sentinel
-    cachedPreviousProposers = undefined;
-    cachedCurrentProposers = null;
-    cachedNextProposers = null;
+    _previousProposers = undefined;
+    _currentProposers = null;
+    _nextProposers = null;
     // validators / balances
-    cachedEffectiveBalanceIncrements = null;
-    cachedValidatorCount = null;
-    cachedActiveValidatorCount = null;
+    _effectiveBalanceIncrements = null;
+    _validatorCount = null;
+    _activeValidatorCount = null;
     // backward compat
-    cachedCreatedWithTransferCache = null;
+    _createdWithTransferCache = null;
     // altair
-    cachedCurrentSyncCommittee = null;
-    cachedNextSyncCommittee = null;
-    cachedPreviousEpochParticipation = null;
-    cachedCurrentEpochParticipation = null;
-    cachedCurrentSyncCommitteeIndexed = null;
-    cachedSyncProposerReward = null;
+    _currentSyncCommittee = null;
+    _nextSyncCommittee = null;
+    _previousEpochParticipation = null;
+    _currentEpochParticipation = null;
+    _currentSyncCommitteeIndexed = null;
+    _syncProposerReward = null;
     // bellatrix
-    cachedLatestExecutionPayloadHeader = null;
-    cachedPayloadBlockNumber = null;
-    cachedIsExecutionStateType = null;
-    cachedIsMergeTransitionComplete = null;
+    _latestExecutionPayloadHeader = null;
+    _payloadBlockNumber = null;
+    _isExecutionStateType = null;
+    _isMergeTransitionComplete = null;
     // capella
-    cachedHistoricalSummaries = null;
+    _historicalSummaries = null;
     // electra
-    cachedPendingPartialWithdrawals = null;
-    cachedPendingConsolidations = null;
-    cachedPendingDeposits = null;
-    cachedPendingDepositsCount = null;
-    cachedPendingPartialWithdrawalsCount = null;
-    cachedPendingConsolidationsCount = null;
+    _pendingPartialWithdrawals = null;
+    _pendingConsolidations = null;
+    _pendingDeposits = null;
+    _pendingDepositsCount = null;
+    _pendingPartialWithdrawalsCount = null;
+    _pendingConsolidationsCount = null;
     // fulu
-    cachedProposerLookahead = null;
+    _proposerLookahead = null;
+    // gloas
+    _executionPayloadAvailability = null;
+    _latestBlockHash = null;
+    _latestExecutionPayloadBid = null;
+    _payloadExpectedWithdrawals = null;
+    _builderPendingPayments = null;
+    _builderPendingWithdrawals = 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.
-    cachedBlockRootAtSlot = new Map();
-    cachedBlockRootAtEpoch = new Map();
-    cachedStateRootAtSlot = new Map();
-    cachedRandaoMix = new Map();
-    cachedShufflingAtEpoch = new Map();
-    cachedBeaconCommittee = new Map();
-    cachedBeaconCommitteeCountPerSlot = new Map();
-    cachedShufflingDecisionRoot = new Map();
-    cachedBeaconProposer = new Map();
-    cachedValidator = new Map();
-    cachedBalance = new Map();
-    cachedIndexedSyncCommitteeAtEpoch = new Map();
-    cachedIndexedSyncCommittee = new Map();
-    cachedSingleProof = new Map();
+    _getBlockRootAtSlot = new Map();
+    _getBlockRootAtEpoch = new Map();
+    _getStateRootAtSlot = new Map();
+    _getRandaoMix = new Map();
+    _getShufflingAtEpoch = new Map();
+    _getBeaconCommittee = new Map();
+    _getBeaconCommitteeCountPerSlot = new Map();
+    _getShufflingDecisionRoot = new Map();
+    _getBeaconProposer = new Map();
+    _getValidator = new Map();
+    _getBalance = new Map();
+    _getIndexedSyncCommitteeAtEpoch = new Map();
+    _getIndexedSyncCommittee = new Map();
+    _getSingleProof = new Map();
+    _getEpochPTCs = new Map();
+    _getBuilder = new Map();
     // No-arg method caches
-    cachedPreviousShuffling = null;
-    cachedCurrentShuffling = null;
-    cachedNextShuffling = null;
-    cachedEffectiveBalanceIncrementsZeroInactive = null;
-    cachedAllValidators = null;
-    cachedAllBalances = null;
-    cachedLatestWeakSubjectivityCheckpointEpoch = null;
-    cachedFinalizedRootProof = null;
-    cachedUnrealizedCheckpoints = null;
-    cachedAnchorCheckpoint = null;
-    cachedIsStateValidatorsNodesPopulated = null;
-    cachedValue = null;
-    cachedSerialized = null;
-    cachedSerializedSize = null;
-    cachedSerializedValidators = null;
-    cachedSerializedValidatorsSize = null;
-    cachedHashTreeRoot = null;
-    cachedSyncCommitteesWitness = null;
-    cachedExpectedWithdrawals = null;
-    constructor(config, binding) {
-        this.config = config;
+    _getPreviousShuffling = null;
+    _getCurrentShuffling = null;
+    _getNextShuffling = null;
+    _getEffectiveBalanceIncrementsZeroInactive = null;
+    _getAllValidators = null;
+    _getBuildersLength = null;
+    _getAllBalances = null;
+    _getLatestWeakSubjectivityCheckpointEpoch = null;
+    _getFinalizedRootProof = null;
+    _computeUnrealizedCheckpoints = null;
+    _computeAnchorCheckpoint = null;
+    _isStateValidatorsNodesPopulated = null;
+    _toValue = null;
+    _serialize = null;
+    _serializedSize = null;
+    _serializeValidators = null;
+    _serializedValidatorsSize = null;
+    _hashTreeRoot = null;
+    _getSyncCommitteesWitness = null;
+    _getExpectedWithdrawals = null;
+    constructor(binding) {
         this.binding = binding;
     }
-    release() {
-        this.binding.release();
-    }
+    // Binding returns pojo object {uint8Array: Uint8Array; bitLen: number}
+    // this class wrap it with BitArray to conform to the api
     get executionPayloadAvailability() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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) {
-        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) {
-        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) {
-        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) {
-        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;
     }
     // Shuffling and committees
     getShufflingAtEpoch(epoch) {
-        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, index) {
         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) {
-        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() {
-        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() {
-        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() {
-        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) {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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) {
-        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;
     }
     // Validators and balances
     get 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() {
-        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) {
-        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) {
-        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;
     }
@@ -351,54 +364,44 @@ export class NativeBeaconStateView {
         return this.binding.getValidatorsByStatus(statuses, currentEpoch);
     }
     get validatorCount() {
-        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() {
-        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() {
-        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() {
-        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
     get proposerRewards() {
         return this.binding.proposerRewards;
     }
-    async computeBlockRewards(block, proposerRewards) {
-        const isBlinded = isBlindedBeaconBlock(block);
-        const signedBlockBytes = isBlinded
-            ? this.config.getPostBellatrixForkTypes(block.slot).SignedBlindedBeaconBlock.serialize({
-                message: block,
-                signature: EMPTY_SIGNATURE,
-            })
-            : this.config.getForkTypes(block.slot).SignedBeaconBlock.serialize({
-                message: block,
-                signature: EMPTY_SIGNATURE,
-            });
-        return this.binding.computeBlockRewards(signedBlockBytes, isBlinded, proposerRewards);
-    }
-    async computeAttestationsRewards(validatorIds) {
+    computeBlockRewards(block, proposerRewards) {
+        return this.binding.computeBlockRewards(block, proposerRewards);
+    }
+    computeAttestationsRewards(validatorIds) {
         return this.binding.computeAttestationsRewards(validatorIds);
     }
     getLatestWeakSubjectivityCheckpointEpoch() {
-        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
     getVoluntaryExitValidity(signedVoluntaryExit, verifySignature) {
@@ -409,16 +412,16 @@ export class NativeBeaconStateView {
     }
     // Proofs
     getFinalizedRootProof() {
-        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) {
-        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;
     }
@@ -427,16 +430,16 @@ export class NativeBeaconStateView {
     }
     // Fork choice
     computeUnrealizedCheckpoints() {
-        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() {
-        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
     get clonedCount() {
@@ -446,93 +449,86 @@ export class NativeBeaconStateView {
         return this.binding.clonedCountWithTransferCache;
     }
     get createdWithTransferCache() {
-        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() {
-        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
     loadOtherState(stateBytes, seedValidatorsBytes, opts) {
-        return new NativeBeaconStateView(this.config, this.binding.loadOtherState(stateBytes, seedValidatorsBytes, opts));
+        return new NativeBeaconStateView(this.binding.loadOtherState(stateBytes, seedValidatorsBytes, opts));
     }
     toValue() {
-        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() {
-        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() {
-        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, offset) {
         return this.binding.serializeToBytes(output, offset);
     }
     serializeValidators() {
-        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() {
-        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, offset) {
         return this.binding.serializeValidatorsToBytes(output, offset);
     }
     hashTreeRoot() {
-        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, modules) {
-        const postState = this.stateTransition(input, computeNewStateRootStateTransitionOpts, modules);
+        const postState = new NativeBeaconStateView(this.binding.stateTransition(input.block, computeNewStateRootStateTransitionOpts, modules));
         return getComputeNewStateRootResult(postState);
     }
-    stateTransition({ block, ssz }, options, _modules) {
-        const isBlinded = isBlindedBeaconBlock(block.message);
-        const signedBlockBytes = ssz ??
-            (isBlinded
-                ? this.config
-                    .getPostBellatrixForkTypes(block.message.slot)
-                    .SignedBlindedBeaconBlock.serialize(block)
-                : this.config.getForkTypes(block.message.slot).SignedBeaconBlock.serialize(block));
-        return new NativeBeaconStateView(this.config, this.binding.stateTransition(signedBlockBytes, isBlinded, options));
+    stateTransition(signedBlock, options, modules) {
+        return new NativeBeaconStateView(this.binding.stateTransition(signedBlock, options, modules));
     }
-    processSlots(slot, opts, _modules) {
-        return new NativeBeaconStateView(this.config, this.binding.processSlots(slot, opts));
+    processSlots(slot, opts, modules) {
+        return new NativeBeaconStateView(this.binding.processSlots(slot, opts, modules));
     }
     // ─── altair ──────────────────────────────────────────────────────────────
     get previousEpochParticipation() {
-        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() {
-        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) {
         return this.previousEpochParticipation[validatorIndex];
@@ -541,181 +537,214 @@ export class NativeBeaconStateView {
         return this.currentEpochParticipation[validatorIndex];
     }
     get currentSyncCommittee() {
-        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() {
-        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() {
-        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() {
-        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) {
-        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) {
-        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(block, validatorIds) {
+    computeSyncCommitteeRewards(block, validatorIds) {
         return this.binding.computeSyncCommitteeRewards(block, validatorIds);
     }
     getSyncCommitteesWitness() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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) {
         return this.binding.isExecutionEnabled(block);
     }
     // ─── capella ─────────────────────────────────────────────────────────────
     get 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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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, _maxDurationMs) {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+    preVerifyBuilderDepositsPreGloas(maxBuilderDeposits, maxDurationMs) {
+        return this.binding.preVerifyBuilderDepositsPreGloas(maxBuilderDeposits, maxDurationMs);
     }
     clearPreGloasBuilderDepositCache() {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+        this.binding.clearPreGloasBuilderDepositCache();
     }
     // ─── gloas ───────────────────────────────────────────────────────────────
     get latestBlockHash() {
-        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() {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+        if (this._latestExecutionPayloadBid === null) {
+            this._latestExecutionPayloadBid = this.binding.latestExecutionPayloadBid;
+        }
+        return this._latestExecutionPayloadBid;
     }
     get payloadExpectedWithdrawals() {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+        if (this._payloadExpectedWithdrawals === null) {
+            this._payloadExpectedWithdrawals = this.binding.payloadExpectedWithdrawals;
+        }
+        return this._payloadExpectedWithdrawals;
     }
     get builderPendingPayments() {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+        if (this._builderPendingPayments === null) {
+            this._builderPendingPayments = this.binding.builderPendingPayments;
+        }
+        return this._builderPendingPayments;
     }
     get builderPendingWithdrawals() {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+        if (this._builderPendingWithdrawals === null) {
+            this._builderPendingWithdrawals = this.binding.builderPendingWithdrawals;
+        }
+        return this._builderPendingWithdrawals;
     }
-    getBuilder(_index) {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+    getBuilder(index) {
+        let cached = this._getBuilder.get(index);
+        if (cached === undefined) {
+            cached = this.binding.getBuilder(index);
+            this._getBuilder.set(index, cached);
+        }
+        return cached;
     }
     getBuildersLength() {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+        if (this._getBuildersLength === null) {
+            this._getBuildersLength = this.binding.getBuildersLength();
+        }
+        return this._getBuildersLength;
     }
-    canBuilderCoverBid(_builderIndex, _bidAmount) {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+    canBuilderCoverBid(builderIndex, bidAmount) {
+        return this.binding.canBuilderCoverBid(builderIndex, bidAmount);
     }
-    getEpochPTCs(_epoch) {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+    getEpochPTCs(epoch) {
+        let cached = this._getEpochPTCs.get(epoch);
+        if (cached === undefined) {
+            cached = this.binding.getEpochPTCs(epoch);
+            this._getEpochPTCs.set(epoch, cached);
+        }
+        return cached;
     }
-    getPayloadTimelinessCommittee(_slot) {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+    getPayloadTimelinessCommittee(slot) {
+        return this.binding.getPayloadTimelinessCommittee(slot);
     }
-    getIndicesInPayloadTimelinessCommittee(_validatorIndex, _slot) {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+    getIndicesInPayloadTimelinessCommittee(validatorIndex, slot) {
+        return this.binding.getIndicesInPayloadTimelinessCommittee(validatorIndex, slot);
     }
-    withParentPayloadApplied(_executionRequests) {
-        throw new Error("NativeBeaconStateView does not support Gloas");
+    withParentPayloadApplied(executionRequests) {
+        const view = new NativeBeaconStateView(this.binding.withParentPayloadApplied(executionRequests));
+        if (!isStatePostGloas(view)) {
+            throw new Error("Expected gloas state from withParentPayloadApplied");
+        }
+        return view;
     }
 }
 //# sourceMappingURL=nativeBeaconStateView.js.map