@lodestar/state-transition 1.50.0-dev.023ad6c012 → 1.50.0-dev.03c05fa09a

package/lib/stateView/nativeBeaconStateView.js

@@ -1,15 +1,14 @@
-import { BitArray } from "@chainsafe/ssz";
+import { ForkSeq } from "@lodestar/params";
+import { isBlindedBeaconBlock, ssz, } from "@lodestar/types";
+import { EMPTY_SIGNATURE } from "../constants/constants.js";
 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` — 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`.
+ * 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`.
  *
  * 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
@@ -18,345 +17,338 @@ import { isStatePostGloas, } from "./interface.js";
  * would need a per-arg map and isn't worth it without a hot-path signal.
  */
 export class NativeBeaconStateView {
+    config;
     binding;
     // phase0
-    _forkName = null;
-    _forkSeq = null;
-    _slot = null;
-    _fork = null;
-    _epoch = null;
-    _genesisTime = null;
-    _genesisValidatorsRoot = null;
-    _eth1Data = null;
-    _latestBlockHeader = null;
-    _previousJustifiedCheckpoint = null;
-    _currentJustifiedCheckpoint = null;
-    _finalizedCheckpoint = null;
+    cachedForkName = null;
+    cachedForkSeq = null;
+    cachedSlot = null;
+    cachedFork = null;
+    cachedEpoch = null;
+    cachedGenesisTime = null;
+    cachedGenesisValidatorsRoot = null;
+    cachedEth1Data = null;
+    cachedLatestBlockHeader = null;
+    cachedPreviousJustifiedCheckpoint = null;
+    cachedCurrentJustifiedCheckpoint = null;
+    cachedFinalizedCheckpoint = null;
     // shuffling / decision roots / proposers
-    _previousDecisionRoot = null;
-    _currentDecisionRoot = null;
-    _nextDecisionRoot = null;
+    cachedPreviousDecisionRoot = null;
+    cachedCurrentDecisionRoot = null;
+    cachedNextDecisionRoot = null;
     // previousProposers can be null, so use undefined as the "not loaded" sentinel
-    _previousProposers = undefined;
-    _currentProposers = null;
-    _nextProposers = null;
+    cachedPreviousProposers = undefined;
+    cachedCurrentProposers = null;
+    cachedNextProposers = null;
     // validators / balances
-    _effectiveBalanceIncrements = null;
-    _validatorCount = null;
-    _activeValidatorCount = null;
+    cachedEffectiveBalanceIncrements = null;
+    cachedValidatorCount = null;
+    cachedActiveValidatorCount = null;
     // backward compat
-    _createdWithTransferCache = null;
+    cachedCreatedWithTransferCache = null;
     // altair
-    _currentSyncCommittee = null;
-    _nextSyncCommittee = null;
-    _previousEpochParticipation = null;
-    _currentEpochParticipation = null;
-    _currentSyncCommitteeIndexed = null;
-    _syncProposerReward = null;
+    cachedCurrentSyncCommittee = null;
+    cachedNextSyncCommittee = null;
+    cachedPreviousEpochParticipation = null;
+    cachedCurrentEpochParticipation = null;
+    cachedCurrentSyncCommitteeIndexed = null;
+    cachedCurrentSyncCommitteeValidatorIndices = null;
+    cachedSyncProposerReward = null;
     // bellatrix
-    _latestExecutionPayloadHeader = null;
-    _payloadBlockNumber = null;
-    _isExecutionStateType = null;
-    _isMergeTransitionComplete = null;
+    cachedLatestExecutionPayloadHeader = null;
+    cachedPayloadBlockNumber = null;
+    cachedIsExecutionStateType = null;
+    cachedIsMergeTransitionComplete = null;
     // capella
-    _historicalSummaries = null;
+    cachedHistoricalSummaries = null;
     // electra
-    _pendingPartialWithdrawals = null;
-    _pendingConsolidations = null;
-    _pendingDeposits = null;
-    _pendingDepositsCount = null;
-    _pendingPartialWithdrawalsCount = null;
-    _pendingConsolidationsCount = null;
+    cachedPendingPartialWithdrawals = null;
+    cachedPendingConsolidations = null;
+    cachedPendingDeposits = null;
+    cachedPendingDepositsCount = null;
+    cachedPendingPartialWithdrawalsCount = null;
+    cachedPendingConsolidationsCount = null;
     // fulu
-    _proposerLookahead = null;
-    // gloas
-    _executionPayloadAvailability = null;
-    _latestBlockHash = null;
-    _latestExecutionPayloadBid = null;
-    _payloadExpectedWithdrawals = null;
-    _builderPendingPayments = null;
-    _builderPendingWithdrawals = null;
+    cachedProposerLookahead = 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.
-    _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();
+    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();
     // No-arg method caches
-    _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) {
+    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;
         this.binding = binding;
     }
-    // Binding returns pojo object {uint8Array: Uint8Array; bitLen: number}
-    // this class wrap it with BitArray to conform to the api
+    release() {
+        this.binding.release();
+    }
     get executionPayloadAvailability() {
-        if (this._executionPayloadAvailability === null) {
-            const pojo = this.binding.executionPayloadAvailability;
-            this._executionPayloadAvailability = new BitArray(pojo.uint8Array, pojo.bitLen);
-        }
-        return this._executionPayloadAvailability;
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
     // ─── phase0 ──────────────────────────────────────────────────────────────
     get forkName() {
-        if (this._forkName === null) {
-            this._forkName = this.binding.forkName;
+        if (this.cachedForkName === null) {
+            this.cachedForkName = this.binding.forkName;
         }
-        return this._forkName;
+        return this.cachedForkName;
     }
     get forkSeq() {
-        if (this._forkSeq === null) {
-            this._forkSeq = this.binding.forkSeq;
+        if (this.cachedForkSeq === null) {
+            this.cachedForkSeq = this.binding.forkSeq;
         }
-        return this._forkSeq;
+        return this.cachedForkSeq;
     }
     get slot() {
-        if (this._slot === null) {
-            this._slot = this.binding.slot;
+        if (this.cachedSlot === null) {
+            this.cachedSlot = this.binding.slot;
         }
-        return this._slot;
+        return this.cachedSlot;
     }
     get fork() {
-        if (this._fork === null) {
-            this._fork = this.binding.fork;
+        if (this.cachedFork === null) {
+            this.cachedFork = this.binding.fork;
         }
-        return this._fork;
+        return this.cachedFork;
     }
     get epoch() {
-        if (this._epoch === null) {
-            this._epoch = this.binding.epoch;
+        if (this.cachedEpoch === null) {
+            this.cachedEpoch = this.binding.epoch;
         }
-        return this._epoch;
+        return this.cachedEpoch;
     }
     get genesisTime() {
-        if (this._genesisTime === null) {
-            this._genesisTime = this.binding.genesisTime;
+        if (this.cachedGenesisTime === null) {
+            this.cachedGenesisTime = this.binding.genesisTime;
         }
-        return this._genesisTime;
+        return this.cachedGenesisTime;
     }
     get genesisValidatorsRoot() {
-        if (this._genesisValidatorsRoot === null) {
-            this._genesisValidatorsRoot = this.binding.genesisValidatorsRoot;
+        if (this.cachedGenesisValidatorsRoot === null) {
+            this.cachedGenesisValidatorsRoot = this.binding.genesisValidatorsRoot;
         }
-        return this._genesisValidatorsRoot;
+        return this.cachedGenesisValidatorsRoot;
     }
     get eth1Data() {
-        if (this._eth1Data === null) {
-            this._eth1Data = this.binding.eth1Data;
+        if (this.forkSeq >= ForkSeq.heze) {
+            throw new Error("eth1Data was removed from the beacon state in Heze");
+        }
+        if (this.cachedEth1Data === null) {
+            this.cachedEth1Data = this.binding.eth1Data;
         }
-        return this._eth1Data;
+        return this.cachedEth1Data;
     }
     get latestBlockHeader() {
-        if (this._latestBlockHeader === null) {
-            this._latestBlockHeader = this.binding.latestBlockHeader;
+        if (this.cachedLatestBlockHeader === null) {
+            this.cachedLatestBlockHeader = this.binding.latestBlockHeader;
         }
-        return this._latestBlockHeader;
+        return this.cachedLatestBlockHeader;
     }
     get previousJustifiedCheckpoint() {
-        if (this._previousJustifiedCheckpoint === null) {
-            this._previousJustifiedCheckpoint = this.binding.previousJustifiedCheckpoint;
+        if (this.cachedPreviousJustifiedCheckpoint === null) {
+            this.cachedPreviousJustifiedCheckpoint = this.binding.previousJustifiedCheckpoint;
         }
-        return this._previousJustifiedCheckpoint;
+        return this.cachedPreviousJustifiedCheckpoint;
     }
     get currentJustifiedCheckpoint() {
-        if (this._currentJustifiedCheckpoint === null) {
-            this._currentJustifiedCheckpoint = this.binding.currentJustifiedCheckpoint;
+        if (this.cachedCurrentJustifiedCheckpoint === null) {
+            this.cachedCurrentJustifiedCheckpoint = this.binding.currentJustifiedCheckpoint;
         }
-        return this._currentJustifiedCheckpoint;
+        return this.cachedCurrentJustifiedCheckpoint;
     }
     get finalizedCheckpoint() {
-        if (this._finalizedCheckpoint === null) {
-            this._finalizedCheckpoint = this.binding.finalizedCheckpoint;
+        if (this.cachedFinalizedCheckpoint === null) {
+            this.cachedFinalizedCheckpoint = this.binding.finalizedCheckpoint;
         }
-        return this._finalizedCheckpoint;
+        return this.cachedFinalizedCheckpoint;
     }
     getBlockRootAtSlot(slot) {
-        let cached = this._getBlockRootAtSlot.get(slot);
+        let cached = this.cachedBlockRootAtSlot.get(slot);
         if (cached === undefined) {
             cached = this.binding.getBlockRootAtSlot(slot);
-            this._getBlockRootAtSlot.set(slot, cached);
+            this.cachedBlockRootAtSlot.set(slot, cached);
         }
         return cached;
     }
     getBlockRootAtEpoch(epoch) {
-        let cached = this._getBlockRootAtEpoch.get(epoch);
+        let cached = this.cachedBlockRootAtEpoch.get(epoch);
         if (cached === undefined) {
             cached = this.binding.getBlockRootAtEpoch(epoch);
-            this._getBlockRootAtEpoch.set(epoch, cached);
+            this.cachedBlockRootAtEpoch.set(epoch, cached);
         }
         return cached;
     }
     getStateRootAtSlot(slot) {
-        let cached = this._getStateRootAtSlot.get(slot);
+        let cached = this.cachedStateRootAtSlot.get(slot);
         if (cached === undefined) {
             cached = this.binding.getStateRootAtSlot(slot);
-            this._getStateRootAtSlot.set(slot, cached);
+            this.cachedStateRootAtSlot.set(slot, cached);
         }
         return cached;
     }
     getRandaoMix(epoch) {
-        let cached = this._getRandaoMix.get(epoch);
+        let cached = this.cachedRandaoMix.get(epoch);
         if (cached === undefined) {
             cached = this.binding.getRandaoMix(epoch);
-            this._getRandaoMix.set(epoch, cached);
+            this.cachedRandaoMix.set(epoch, cached);
         }
         return cached;
     }
     // Shuffling and committees
     getShufflingAtEpoch(epoch) {
-        let cached = this._getShufflingAtEpoch.get(epoch);
+        let cached = this.cachedShufflingAtEpoch.get(epoch);
         if (cached === undefined) {
             cached = this.binding.getShufflingAtEpoch(epoch);
-            this._getShufflingAtEpoch.set(epoch, cached);
+            this.cachedShufflingAtEpoch.set(epoch, cached);
         }
         return cached;
     }
     getBeaconCommittee(slot, index) {
         const key = `${slot}:${index}`;
-        let cached = this._getBeaconCommittee.get(key);
+        let cached = this.cachedBeaconCommittee.get(key);
         if (cached === undefined) {
             cached = this.binding.getBeaconCommittee(slot, index);
-            this._getBeaconCommittee.set(key, cached);
+            this.cachedBeaconCommittee.set(key, cached);
         }
         return cached;
     }
     getBeaconCommitteeCountPerSlot(epoch) {
-        let cached = this._getBeaconCommitteeCountPerSlot.get(epoch);
+        let cached = this.cachedBeaconCommitteeCountPerSlot.get(epoch);
         if (cached === undefined) {
             cached = this.binding.getBeaconCommitteeCountPerSlot(epoch);
-            this._getBeaconCommitteeCountPerSlot.set(epoch, cached);
+            this.cachedBeaconCommitteeCountPerSlot.set(epoch, cached);
         }
         return cached;
     }
     get previousDecisionRoot() {
-        if (this._previousDecisionRoot === null) {
-            this._previousDecisionRoot = this.binding.previousDecisionRoot;
+        if (this.cachedPreviousDecisionRoot === null) {
+            this.cachedPreviousDecisionRoot = this.binding.previousDecisionRoot;
         }
-        return this._previousDecisionRoot;
+        return this.cachedPreviousDecisionRoot;
     }
     get currentDecisionRoot() {
-        if (this._currentDecisionRoot === null) {
-            this._currentDecisionRoot = this.binding.currentDecisionRoot;
+        if (this.cachedCurrentDecisionRoot === null) {
+            this.cachedCurrentDecisionRoot = this.binding.currentDecisionRoot;
         }
-        return this._currentDecisionRoot;
+        return this.cachedCurrentDecisionRoot;
     }
     get nextDecisionRoot() {
-        if (this._nextDecisionRoot === null) {
-            this._nextDecisionRoot = this.binding.nextDecisionRoot;
+        if (this.cachedNextDecisionRoot === null) {
+            this.cachedNextDecisionRoot = this.binding.nextDecisionRoot;
         }
-        return this._nextDecisionRoot;
+        return this.cachedNextDecisionRoot;
     }
     getShufflingDecisionRoot(epoch) {
-        let cached = this._getShufflingDecisionRoot.get(epoch);
+        let cached = this.cachedShufflingDecisionRoot.get(epoch);
         if (cached === undefined) {
             cached = this.binding.getShufflingDecisionRoot(epoch);
-            this._getShufflingDecisionRoot.set(epoch, cached);
+            this.cachedShufflingDecisionRoot.set(epoch, cached);
         }
         return cached;
     }
     getPreviousShuffling() {
-        if (this._getPreviousShuffling === null) {
-            this._getPreviousShuffling = this.binding.getPreviousShuffling();
+        if (this.cachedPreviousShuffling === null) {
+            this.cachedPreviousShuffling = this.binding.getPreviousShuffling();
         }
-        return this._getPreviousShuffling;
+        return this.cachedPreviousShuffling;
     }
     getCurrentShuffling() {
-        if (this._getCurrentShuffling === null) {
-            this._getCurrentShuffling = this.binding.getCurrentShuffling();
+        if (this.cachedCurrentShuffling === null) {
+            this.cachedCurrentShuffling = this.binding.getCurrentShuffling();
         }
-        return this._getCurrentShuffling;
+        return this.cachedCurrentShuffling;
     }
     getNextShuffling() {
-        if (this._getNextShuffling === null) {
-            this._getNextShuffling = this.binding.getNextShuffling();
+        if (this.cachedNextShuffling === null) {
+            this.cachedNextShuffling = this.binding.getNextShuffling();
         }
-        return this._getNextShuffling;
+        return this.cachedNextShuffling;
     }
     // Proposer shuffling
     get previousProposers() {
-        if (this._previousProposers === undefined) {
-            this._previousProposers = this.binding.previousProposers;
+        if (this.cachedPreviousProposers === undefined) {
+            this.cachedPreviousProposers = this.binding.previousProposers;
         }
-        return this._previousProposers;
+        return this.cachedPreviousProposers;
     }
     get currentProposers() {
-        if (this._currentProposers === null) {
-            this._currentProposers = this.binding.currentProposers;
+        if (this.cachedCurrentProposers === null) {
+            this.cachedCurrentProposers = this.binding.currentProposers;
         }
-        return this._currentProposers;
+        return this.cachedCurrentProposers;
     }
     get nextProposers() {
-        if (this._nextProposers === null) {
-            this._nextProposers = this.binding.nextProposers;
+        if (this.cachedNextProposers === null) {
+            this.cachedNextProposers = this.binding.nextProposers;
         }
-        return this._nextProposers;
+        return this.cachedNextProposers;
     }
     getBeaconProposer(slot) {
-        let cached = this._getBeaconProposer.get(slot);
+        let cached = this.cachedBeaconProposer.get(slot);
         if (cached === undefined) {
             cached = this.binding.getBeaconProposer(slot);
-            this._getBeaconProposer.set(slot, cached);
+            this.cachedBeaconProposer.set(slot, cached);
         }
         return cached;
     }
     // Validators and balances
     get effectiveBalanceIncrements() {
-        if (this._effectiveBalanceIncrements === null) {
-            this._effectiveBalanceIncrements = this.binding.effectiveBalanceIncrements;
+        if (this.cachedEffectiveBalanceIncrements === null) {
+            this.cachedEffectiveBalanceIncrements = this.binding.effectiveBalanceIncrements;
         }
-        return this._effectiveBalanceIncrements;
+        return this.cachedEffectiveBalanceIncrements;
     }
     getEffectiveBalanceIncrementsZeroInactive() {
-        if (this._getEffectiveBalanceIncrementsZeroInactive === null) {
-            this._getEffectiveBalanceIncrementsZeroInactive = this.binding.getEffectiveBalanceIncrementsZeroInactive();
+        if (this.cachedEffectiveBalanceIncrementsZeroInactive === null) {
+            this.cachedEffectiveBalanceIncrementsZeroInactive = this.binding.getEffectiveBalanceIncrementsZeroInactive();
         }
-        return this._getEffectiveBalanceIncrementsZeroInactive;
+        return this.cachedEffectiveBalanceIncrementsZeroInactive;
     }
     getBalance(index) {
-        let cached = this._getBalance.get(index);
+        let cached = this.cachedBalance.get(index);
         if (cached === undefined) {
             cached = this.binding.getBalance(index);
-            this._getBalance.set(index, cached);
+            this.cachedBalance.set(index, cached);
         }
         return cached;
     }
     getValidator(index) {
-        let cached = this._getValidator.get(index);
+        let cached = this.cachedValidator.get(index);
         if (cached === undefined) {
             cached = this.binding.getValidator(index);
-            this._getValidator.set(index, cached);
+            this.cachedValidator.set(index, cached);
         }
         return cached;
     }
@@ -364,44 +356,54 @@ export class NativeBeaconStateView {
         return this.binding.getValidatorsByStatus(statuses, currentEpoch);
     }
     get validatorCount() {
-        if (this._validatorCount === null) {
-            this._validatorCount = this.binding.validatorCount;
+        if (this.cachedValidatorCount === null) {
+            this.cachedValidatorCount = this.binding.validatorCount;
         }
-        return this._validatorCount;
+        return this.cachedValidatorCount;
     }
     get activeValidatorCount() {
-        if (this._activeValidatorCount === null) {
-            this._activeValidatorCount = this.binding.activeValidatorCount;
+        if (this.cachedActiveValidatorCount === null) {
+            this.cachedActiveValidatorCount = this.binding.activeValidatorCount;
         }
-        return this._activeValidatorCount;
+        return this.cachedActiveValidatorCount;
     }
     getAllValidators() {
-        if (this._getAllValidators === null) {
-            this._getAllValidators = this.binding.getAllValidators();
+        if (this.cachedAllValidators === null) {
+            this.cachedAllValidators = this.binding.getAllValidators();
         }
-        return this._getAllValidators;
+        return this.cachedAllValidators;
     }
     getAllBalances() {
-        if (this._getAllBalances === null) {
-            this._getAllBalances = this.binding.getAllBalances();
+        if (this.cachedAllBalances === null) {
+            this.cachedAllBalances = this.binding.getAllBalances();
         }
-        return this._getAllBalances;
+        return this.cachedAllBalances;
     }
     // API
     get proposerRewards() {
         return this.binding.proposerRewards;
     }
-    computeBlockRewards(block, proposerRewards) {
-        return this.binding.computeBlockRewards(block, proposerRewards);
-    }
-    computeAttestationsRewards(validatorIds) {
+    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) {
         return this.binding.computeAttestationsRewards(validatorIds);
     }
     getLatestWeakSubjectivityCheckpointEpoch() {
-        if (this._getLatestWeakSubjectivityCheckpointEpoch === null) {
-            this._getLatestWeakSubjectivityCheckpointEpoch = this.binding.getLatestWeakSubjectivityCheckpointEpoch();
+        if (this.cachedLatestWeakSubjectivityCheckpointEpoch === null) {
+            this.cachedLatestWeakSubjectivityCheckpointEpoch = this.binding.getLatestWeakSubjectivityCheckpointEpoch();
         }
-        return this._getLatestWeakSubjectivityCheckpointEpoch;
+        return this.cachedLatestWeakSubjectivityCheckpointEpoch;
     }
     // Validation
     getVoluntaryExitValidity(signedVoluntaryExit, verifySignature) {
@@ -412,16 +414,16 @@ export class NativeBeaconStateView {
     }
     // Proofs
     getFinalizedRootProof() {
-        if (this._getFinalizedRootProof === null) {
-            this._getFinalizedRootProof = this.binding.getFinalizedRootProof();
+        if (this.cachedFinalizedRootProof === null) {
+            this.cachedFinalizedRootProof = this.binding.getFinalizedRootProof();
         }
-        return this._getFinalizedRootProof;
+        return this.cachedFinalizedRootProof;
     }
     getSingleProof(gindex) {
-        let cached = this._getSingleProof.get(gindex);
+        let cached = this.cachedSingleProof.get(gindex);
         if (cached === undefined) {
             cached = this.binding.getSingleProof(gindex);
-            this._getSingleProof.set(gindex, cached);
+            this.cachedSingleProof.set(gindex, cached);
         }
         return cached;
     }
@@ -430,16 +432,16 @@ export class NativeBeaconStateView {
     }
     // Fork choice
     computeUnrealizedCheckpoints() {
-        if (this._computeUnrealizedCheckpoints === null) {
-            this._computeUnrealizedCheckpoints = this.binding.computeUnrealizedCheckpoints();
+        if (this.cachedUnrealizedCheckpoints === null) {
+            this.cachedUnrealizedCheckpoints = this.binding.computeUnrealizedCheckpoints();
         }
-        return this._computeUnrealizedCheckpoints;
+        return this.cachedUnrealizedCheckpoints;
     }
     computeAnchorCheckpoint() {
-        if (this._computeAnchorCheckpoint === null) {
-            this._computeAnchorCheckpoint = this.binding.computeAnchorCheckpoint();
+        if (this.cachedAnchorCheckpoint === null) {
+            this.cachedAnchorCheckpoint = this.binding.computeAnchorCheckpoint();
         }
-        return this._computeAnchorCheckpoint;
+        return this.cachedAnchorCheckpoint;
     }
     // Backward compatibility
     get clonedCount() {
@@ -449,86 +451,93 @@ export class NativeBeaconStateView {
         return this.binding.clonedCountWithTransferCache;
     }
     get createdWithTransferCache() {
-        if (this._createdWithTransferCache === null) {
-            this._createdWithTransferCache = this.binding.createdWithTransferCache;
+        if (this.cachedCreatedWithTransferCache === null) {
+            this.cachedCreatedWithTransferCache = this.binding.createdWithTransferCache;
         }
-        return this._createdWithTransferCache;
+        return this.cachedCreatedWithTransferCache;
     }
     isStateValidatorsNodesPopulated() {
-        if (this._isStateValidatorsNodesPopulated === null) {
-            this._isStateValidatorsNodesPopulated = this.binding.isStateValidatorsNodesPopulated();
+        if (this.cachedIsStateValidatorsNodesPopulated === null) {
+            this.cachedIsStateValidatorsNodesPopulated = this.binding.isStateValidatorsNodesPopulated();
         }
-        return this._isStateValidatorsNodesPopulated;
+        return this.cachedIsStateValidatorsNodesPopulated;
     }
     // Serialization
     loadOtherState(stateBytes, seedValidatorsBytes, opts) {
-        return new NativeBeaconStateView(this.binding.loadOtherState(stateBytes, seedValidatorsBytes, opts));
+        return new NativeBeaconStateView(this.config, this.binding.loadOtherState(stateBytes, seedValidatorsBytes, opts));
     }
     toValue() {
-        if (this._toValue === null) {
-            this._toValue = this.binding.toValue();
+        if (this.cachedValue === null) {
+            this.cachedValue = this.binding.toValue();
         }
-        return this._toValue;
+        return this.cachedValue;
     }
     serialize() {
-        if (this._serialize === null) {
-            this._serialize = this.binding.serialize();
+        if (this.cachedSerialized === null) {
+            this.cachedSerialized = this.binding.serialize();
         }
-        return this._serialize;
+        return this.cachedSerialized;
     }
     serializedSize() {
-        if (this._serializedSize === null) {
-            this._serializedSize = this.binding.serializedSize();
+        if (this.cachedSerializedSize === null) {
+            this.cachedSerializedSize = this.binding.serializedSize();
         }
-        return this._serializedSize;
+        return this.cachedSerializedSize;
     }
     serializeToBytes(output, offset) {
         return this.binding.serializeToBytes(output, offset);
     }
     serializeValidators() {
-        if (this._serializeValidators === null) {
-            this._serializeValidators = this.binding.serializeValidators();
+        if (this.cachedSerializedValidators === null) {
+            this.cachedSerializedValidators = this.binding.serializeValidators();
         }
-        return this._serializeValidators;
+        return this.cachedSerializedValidators;
     }
     serializedValidatorsSize() {
-        if (this._serializedValidatorsSize === null) {
-            this._serializedValidatorsSize = this.binding.serializedValidatorsSize();
+        if (this.cachedSerializedValidatorsSize === null) {
+            this.cachedSerializedValidatorsSize = this.binding.serializedValidatorsSize();
         }
-        return this._serializedValidatorsSize;
+        return this.cachedSerializedValidatorsSize;
     }
     serializeValidatorsToBytes(output, offset) {
         return this.binding.serializeValidatorsToBytes(output, offset);
     }
     hashTreeRoot() {
-        if (this._hashTreeRoot === null) {
-            this._hashTreeRoot = this.binding.hashTreeRoot();
+        if (this.cachedHashTreeRoot === null) {
+            this.cachedHashTreeRoot = this.binding.hashTreeRoot();
         }
-        return this._hashTreeRoot;
+        return this.cachedHashTreeRoot;
     }
     // State transition
     computeNewStateRoot(input, modules) {
-        const postState = new NativeBeaconStateView(this.binding.stateTransition(input.block, computeNewStateRootStateTransitionOpts, modules));
+        const postState = this.stateTransition(input, computeNewStateRootStateTransitionOpts, modules);
         return getComputeNewStateRootResult(postState);
     }
-    stateTransition(signedBlock, options, modules) {
-        return new NativeBeaconStateView(this.binding.stateTransition(signedBlock, options, modules));
+    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));
     }
-    processSlots(slot, opts, modules) {
-        return new NativeBeaconStateView(this.binding.processSlots(slot, opts, modules));
+    processSlots(slot, opts, _modules) {
+        return new NativeBeaconStateView(this.config, this.binding.processSlots(slot, opts));
     }
     // ─── altair ──────────────────────────────────────────────────────────────
     get previousEpochParticipation() {
-        if (this._previousEpochParticipation === null) {
-            this._previousEpochParticipation = this.binding.previousEpochParticipation;
+        if (this.cachedPreviousEpochParticipation === null) {
+            this.cachedPreviousEpochParticipation = this.binding.previousEpochParticipation;
         }
-        return this._previousEpochParticipation;
+        return this.cachedPreviousEpochParticipation;
     }
     get currentEpochParticipation() {
-        if (this._currentEpochParticipation === null) {
-            this._currentEpochParticipation = this.binding.currentEpochParticipation;
+        if (this.cachedCurrentEpochParticipation === null) {
+            this.cachedCurrentEpochParticipation = this.binding.currentEpochParticipation;
         }
-        return this._currentEpochParticipation;
+        return this.cachedCurrentEpochParticipation;
     }
     getPreviousEpochParticipation(validatorIndex) {
         return this.previousEpochParticipation[validatorIndex];
@@ -537,214 +546,190 @@ export class NativeBeaconStateView {
         return this.currentEpochParticipation[validatorIndex];
     }
     get currentSyncCommittee() {
-        if (this._currentSyncCommittee === null) {
-            this._currentSyncCommittee = this.binding.currentSyncCommittee;
+        if (this.cachedCurrentSyncCommittee === null) {
+            this.cachedCurrentSyncCommittee = this.binding.currentSyncCommittee;
         }
-        return this._currentSyncCommittee;
+        return this.cachedCurrentSyncCommittee;
     }
     get nextSyncCommittee() {
-        if (this._nextSyncCommittee === null) {
-            this._nextSyncCommittee = this.binding.nextSyncCommittee;
+        if (this.cachedNextSyncCommittee === null) {
+            this.cachedNextSyncCommittee = this.binding.nextSyncCommittee;
         }
-        return this._nextSyncCommittee;
+        return this.cachedNextSyncCommittee;
     }
     get currentSyncCommitteeIndexed() {
-        if (this._currentSyncCommitteeIndexed === null) {
-            this._currentSyncCommitteeIndexed = this.binding.currentSyncCommitteeIndexed;
+        if (this.cachedCurrentSyncCommitteeIndexed === null) {
+            this.cachedCurrentSyncCommitteeIndexed = this.binding.currentSyncCommitteeIndexed;
+        }
+        return this.cachedCurrentSyncCommitteeIndexed;
+    }
+    get currentSyncCommitteeValidatorIndices() {
+        if (this.cachedCurrentSyncCommitteeValidatorIndices === null) {
+            this.cachedCurrentSyncCommitteeValidatorIndices =
+                this.cachedCurrentSyncCommitteeIndexed?.validatorIndices ??
+                    this.binding.currentSyncCommitteeValidatorIndices ??
+                    this.currentSyncCommitteeIndexed.validatorIndices;
         }
-        return this._currentSyncCommitteeIndexed;
+        return this.cachedCurrentSyncCommitteeValidatorIndices;
     }
     get syncProposerReward() {
-        if (this._syncProposerReward === null) {
-            this._syncProposerReward = this.binding.syncProposerReward;
+        if (this.cachedSyncProposerReward === null) {
+            this.cachedSyncProposerReward = this.binding.syncProposerReward;
         }
-        return this._syncProposerReward;
+        return this.cachedSyncProposerReward;
     }
     getIndexedSyncCommitteeAtEpoch(epoch) {
-        let cached = this._getIndexedSyncCommitteeAtEpoch.get(epoch);
+        let cached = this.cachedIndexedSyncCommitteeAtEpoch.get(epoch);
         if (cached === undefined) {
             cached = this.binding.getIndexedSyncCommitteeAtEpoch(epoch);
-            this._getIndexedSyncCommitteeAtEpoch.set(epoch, cached);
+            this.cachedIndexedSyncCommitteeAtEpoch.set(epoch, cached);
         }
         return cached;
     }
     getIndexedSyncCommittee(slot) {
-        let cached = this._getIndexedSyncCommittee.get(slot);
+        let cached = this.cachedIndexedSyncCommittee.get(slot);
         if (cached === undefined) {
             cached = this.binding.getIndexedSyncCommittee(slot);
-            this._getIndexedSyncCommittee.set(slot, cached);
+            this.cachedIndexedSyncCommittee.set(slot, cached);
         }
         return cached;
     }
-    computeSyncCommitteeRewards(block, validatorIds) {
+    async computeSyncCommitteeRewards(block, validatorIds) {
         return this.binding.computeSyncCommitteeRewards(block, validatorIds);
     }
     getSyncCommitteesWitness() {
-        if (this._getSyncCommitteesWitness === null) {
-            this._getSyncCommitteesWitness = this.binding.getSyncCommitteesWitness();
+        if (this.cachedSyncCommitteesWitness === null) {
+            this.cachedSyncCommitteesWitness = this.binding.getSyncCommitteesWitness();
         }
-        return this._getSyncCommitteesWitness;
+        return this.cachedSyncCommitteesWitness;
     }
     // ─── bellatrix ───────────────────────────────────────────────────────────
     get latestExecutionPayloadHeader() {
-        if (this._latestExecutionPayloadHeader === null) {
-            this._latestExecutionPayloadHeader = this.binding.latestExecutionPayloadHeader;
+        if (this.cachedLatestExecutionPayloadHeader === null) {
+            this.cachedLatestExecutionPayloadHeader = this.binding.latestExecutionPayloadHeader;
         }
-        return this._latestExecutionPayloadHeader;
+        return this.cachedLatestExecutionPayloadHeader;
     }
     get payloadBlockNumber() {
-        if (this._payloadBlockNumber === null) {
-            this._payloadBlockNumber = this.binding.payloadBlockNumber;
+        if (this.cachedPayloadBlockNumber === null) {
+            this.cachedPayloadBlockNumber = this.binding.payloadBlockNumber;
         }
-        return this._payloadBlockNumber;
+        return this.cachedPayloadBlockNumber;
     }
     get isExecutionStateType() {
-        if (this._isExecutionStateType === null) {
-            this._isExecutionStateType = this.binding.isExecutionStateType;
+        if (this.cachedIsExecutionStateType === null) {
+            this.cachedIsExecutionStateType = this.binding.isExecutionStateType;
         }
-        return this._isExecutionStateType;
+        return this.cachedIsExecutionStateType;
     }
     get isMergeTransitionComplete() {
-        if (this._isMergeTransitionComplete === null) {
-            this._isMergeTransitionComplete = this.binding.isMergeTransitionComplete;
+        if (this.cachedIsMergeTransitionComplete === null) {
+            this.cachedIsMergeTransitionComplete = this.binding.isMergeTransitionComplete;
         }
-        return this._isMergeTransitionComplete;
+        return this.cachedIsMergeTransitionComplete;
     }
     isExecutionEnabled(block) {
         return this.binding.isExecutionEnabled(block);
     }
     // ─── capella ─────────────────────────────────────────────────────────────
     get historicalSummaries() {
-        if (this._historicalSummaries === null) {
-            this._historicalSummaries = this.binding.historicalSummaries;
+        if (this.cachedHistoricalSummaries === null) {
+            this.cachedHistoricalSummaries = this.binding.historicalSummaries;
         }
-        return this._historicalSummaries;
+        return this.cachedHistoricalSummaries;
     }
     getExpectedWithdrawals() {
-        if (this._getExpectedWithdrawals === null) {
-            this._getExpectedWithdrawals = this.binding.getExpectedWithdrawals();
+        if (this.cachedExpectedWithdrawals === null) {
+            this.cachedExpectedWithdrawals = this.binding.getExpectedWithdrawals();
         }
-        return this._getExpectedWithdrawals;
+        return this.cachedExpectedWithdrawals;
     }
     // ─── electra ─────────────────────────────────────────────────────────────
     get pendingDeposits() {
-        if (this._pendingDeposits === null) {
-            this._pendingDeposits = this.binding.pendingDeposits;
+        if (this.cachedPendingDeposits === null) {
+            this.cachedPendingDeposits = ssz.electra.PendingDeposits.deserialize(this.binding.pendingDeposits);
         }
-        return this._pendingDeposits;
+        return this.cachedPendingDeposits;
     }
     get pendingDepositsCount() {
-        if (this._pendingDepositsCount === null) {
-            this._pendingDepositsCount = this.binding.pendingDepositsCount;
+        if (this.cachedPendingDepositsCount === null) {
+            this.cachedPendingDepositsCount = this.binding.pendingDepositsCount;
         }
-        return this._pendingDepositsCount;
+        return this.cachedPendingDepositsCount;
     }
     get pendingPartialWithdrawals() {
-        if (this._pendingPartialWithdrawals === null) {
-            this._pendingPartialWithdrawals = this.binding.pendingPartialWithdrawals;
+        if (this.cachedPendingPartialWithdrawals === null) {
+            this.cachedPendingPartialWithdrawals = ssz.electra.PendingPartialWithdrawals.deserialize(this.binding.pendingPartialWithdrawals);
         }
-        return this._pendingPartialWithdrawals;
+        return this.cachedPendingPartialWithdrawals;
     }
     get pendingPartialWithdrawalsCount() {
-        if (this._pendingPartialWithdrawalsCount === null) {
-            this._pendingPartialWithdrawalsCount = this.binding.pendingPartialWithdrawalsCount;
+        if (this.cachedPendingPartialWithdrawalsCount === null) {
+            this.cachedPendingPartialWithdrawalsCount = this.binding.pendingPartialWithdrawalsCount;
         }
-        return this._pendingPartialWithdrawalsCount;
+        return this.cachedPendingPartialWithdrawalsCount;
     }
     get pendingConsolidations() {
-        if (this._pendingConsolidations === null) {
-            this._pendingConsolidations = this.binding.pendingConsolidations;
+        if (this.cachedPendingConsolidations === null) {
+            this.cachedPendingConsolidations = ssz.electra.PendingConsolidations.deserialize(this.binding.pendingConsolidations);
         }
-        return this._pendingConsolidations;
+        return this.cachedPendingConsolidations;
     }
     get pendingConsolidationsCount() {
-        if (this._pendingConsolidationsCount === null) {
-            this._pendingConsolidationsCount = this.binding.pendingConsolidationsCount;
+        if (this.cachedPendingConsolidationsCount === null) {
+            this.cachedPendingConsolidationsCount = this.binding.pendingConsolidationsCount;
         }
-        return this._pendingConsolidationsCount;
+        return this.cachedPendingConsolidationsCount;
     }
     // ─── fulu ────────────────────────────────────────────────────────────────
     get proposerLookahead() {
-        if (this._proposerLookahead === null) {
-            this._proposerLookahead = this.binding.proposerLookahead;
+        if (this.cachedProposerLookahead === null) {
+            this.cachedProposerLookahead = Array.from(this.binding.proposerLookahead);
         }
-        return this._proposerLookahead;
+        return this.cachedProposerLookahead;
     }
-    preVerifyBuilderDepositsPreGloas(maxBuilderDeposits, maxDurationMs) {
-        return this.binding.preVerifyBuilderDepositsPreGloas(maxBuilderDeposits, maxDurationMs);
+    preVerifyBuilderDepositsPreGloas(_maxBuilderDeposits, _maxDurationMs) {
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
     clearPreGloasBuilderDepositCache() {
-        this.binding.clearPreGloasBuilderDepositCache();
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
     // ─── gloas ───────────────────────────────────────────────────────────────
     get latestBlockHash() {
-        if (this._latestBlockHash === null) {
-            this._latestBlockHash = this.binding.latestBlockHash;
-        }
-        return this._latestBlockHash;
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
-    // executionPayloadAvailability getter is defined near the top of the class.
     get latestExecutionPayloadBid() {
-        if (this._latestExecutionPayloadBid === null) {
-            this._latestExecutionPayloadBid = this.binding.latestExecutionPayloadBid;
-        }
-        return this._latestExecutionPayloadBid;
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
     get payloadExpectedWithdrawals() {
-        if (this._payloadExpectedWithdrawals === null) {
-            this._payloadExpectedWithdrawals = this.binding.payloadExpectedWithdrawals;
-        }
-        return this._payloadExpectedWithdrawals;
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
     get builderPendingPayments() {
-        if (this._builderPendingPayments === null) {
-            this._builderPendingPayments = this.binding.builderPendingPayments;
-        }
-        return this._builderPendingPayments;
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
     get builderPendingWithdrawals() {
-        if (this._builderPendingWithdrawals === null) {
-            this._builderPendingWithdrawals = this.binding.builderPendingWithdrawals;
-        }
-        return this._builderPendingWithdrawals;
+        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;
+    getBuilder(_index) {
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
     getBuildersLength() {
-        if (this._getBuildersLength === null) {
-            this._getBuildersLength = this.binding.getBuildersLength();
-        }
-        return this._getBuildersLength;
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
-    canBuilderCoverBid(builderIndex, bidAmount) {
-        return this.binding.canBuilderCoverBid(builderIndex, bidAmount);
+    canBuilderCoverBid(_builderIndex, _bidAmount) {
+        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;
+    getEpochPTCs(_epoch) {
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
-    getPayloadTimelinessCommittee(slot) {
-        return this.binding.getPayloadTimelinessCommittee(slot);
+    getPayloadTimelinessCommittee(_slot) {
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
-    getIndicesInPayloadTimelinessCommittee(validatorIndex, slot) {
-        return this.binding.getIndicesInPayloadTimelinessCommittee(validatorIndex, slot);
+    getIndicesInPayloadTimelinessCommittee(_validatorIndex, _slot) {
+        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;
+    withParentPayloadApplied(_executionRequests) {
+        throw new Error("NativeBeaconStateView does not support Gloas");
     }
 }
 //# sourceMappingURL=nativeBeaconStateView.js.map