@lodestar/state-transition 1.44.0-dev.f507c14622 → 1.44.0-dev.ff43f013ea

package/lib/stateView/nativeBeaconStateView.js

@@ -0,0 +1,698 @@
+import { BitArray } from "@chainsafe/ssz";
+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`.
+ *
+ * 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
+ * (`proposerRewards`, `clonedCount`, `clonedCountWithTransferCache`) stay
+ * pass-through. Methods with arguments are pass-through too — caching them
+ * would need a per-arg map and isn't worth it without a hot-path signal.
+ */
+export class NativeBeaconStateView {
+    binding;
+    // phase0
+    _forkName = 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
+    _previousDecisionRoot = null;
+    _currentDecisionRoot = null;
+    _nextDecisionRoot = null;
+    // previousProposers can be null, so use undefined as the "not loaded" sentinel
+    _previousProposers = undefined;
+    _currentProposers = null;
+    _nextProposers = null;
+    // validators / balances
+    _effectiveBalanceIncrements = null;
+    _validatorCount = null;
+    _activeValidatorCount = null;
+    // backward compat
+    _createdWithTransferCache = null;
+    // altair
+    _currentSyncCommittee = null;
+    _nextSyncCommittee = null;
+    _previousEpochParticipation = null;
+    _currentEpochParticipation = null;
+    _currentSyncCommitteeIndexed = null;
+    _syncProposerReward = null;
+    // bellatrix
+    _latestExecutionPayloadHeader = null;
+    _payloadBlockNumber = null;
+    _isExecutionStateType = null;
+    _isMergeTransitionComplete = null;
+    // capella
+    _historicalSummaries = null;
+    // electra
+    _pendingPartialWithdrawals = null;
+    _pendingConsolidations = null;
+    _pendingDeposits = null;
+    _pendingDepositsCount = null;
+    _pendingPartialWithdrawalsCount = null;
+    _pendingConsolidationsCount = null;
+    // fulu
+    _proposerLookahead = null;
+    // gloas
+    _executionPayloadAvailability = null;
+    _latestBlockHash = null;
+    _latestExecutionPayloadBid = null;
+    _payloadExpectedWithdrawals = 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();
+    _getShufflingDecisionRoot = new Map();
+    _getBeaconProposer = new Map();
+    // getBeaconProposerOrNull can return null, so use .has() to distinguish "not cached" from "cached null"
+    _getBeaconProposerOrNull = 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
+    _getPreviousShuffling = null;
+    _getCurrentShuffling = null;
+    _getNextShuffling = null;
+    _getEffectiveBalanceIncrementsZeroInactive = null;
+    _getAllValidators = 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;
+    }
+    // Binding returns pojo object {uint8Array: Uint8Array; bitLen: number}
+    // this class wrap it with BitArray to conform to the api
+    get executionPayloadAvailability() {
+        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._forkName === null) {
+            this._forkName = this.binding.forkName;
+        }
+        return this._forkName;
+    }
+    get slot() {
+        if (this._slot === null) {
+            this._slot = this.binding.slot;
+        }
+        return this._slot;
+    }
+    get fork() {
+        if (this._fork === null) {
+            this._fork = this.binding.fork;
+        }
+        return this._fork;
+    }
+    get epoch() {
+        if (this._epoch === null) {
+            this._epoch = this.binding.epoch;
+        }
+        return this._epoch;
+    }
+    get genesisTime() {
+        if (this._genesisTime === null) {
+            this._genesisTime = this.binding.genesisTime;
+        }
+        return this._genesisTime;
+    }
+    get genesisValidatorsRoot() {
+        if (this._genesisValidatorsRoot === null) {
+            this._genesisValidatorsRoot = this.binding.genesisValidatorsRoot;
+        }
+        return this._genesisValidatorsRoot;
+    }
+    get eth1Data() {
+        if (this._eth1Data === null) {
+            this._eth1Data = this.binding.eth1Data;
+        }
+        return this._eth1Data;
+    }
+    get latestBlockHeader() {
+        if (this._latestBlockHeader === null) {
+            this._latestBlockHeader = this.binding.latestBlockHeader;
+        }
+        return this._latestBlockHeader;
+    }
+    get previousJustifiedCheckpoint() {
+        if (this._previousJustifiedCheckpoint === null) {
+            this._previousJustifiedCheckpoint = this.binding.previousJustifiedCheckpoint;
+        }
+        return this._previousJustifiedCheckpoint;
+    }
+    get currentJustifiedCheckpoint() {
+        if (this._currentJustifiedCheckpoint === null) {
+            this._currentJustifiedCheckpoint = this.binding.currentJustifiedCheckpoint;
+        }
+        return this._currentJustifiedCheckpoint;
+    }
+    get finalizedCheckpoint() {
+        if (this._finalizedCheckpoint === null) {
+            this._finalizedCheckpoint = this.binding.finalizedCheckpoint;
+        }
+        return this._finalizedCheckpoint;
+    }
+    getBlockRootAtSlot(slot) {
+        let cached = this._getBlockRootAtSlot.get(slot);
+        if (cached === undefined) {
+            cached = this.binding.getBlockRootAtSlot(slot);
+            this._getBlockRootAtSlot.set(slot, cached);
+        }
+        return cached;
+    }
+    getBlockRootAtEpoch(epoch) {
+        let cached = this._getBlockRootAtEpoch.get(epoch);
+        if (cached === undefined) {
+            cached = this.binding.getBlockRootAtEpoch(epoch);
+            this._getBlockRootAtEpoch.set(epoch, cached);
+        }
+        return cached;
+    }
+    getStateRootAtSlot(slot) {
+        let cached = this._getStateRootAtSlot.get(slot);
+        if (cached === undefined) {
+            cached = this.binding.getStateRootAtSlot(slot);
+            this._getStateRootAtSlot.set(slot, cached);
+        }
+        return cached;
+    }
+    getRandaoMix(epoch) {
+        let cached = this._getRandaoMix.get(epoch);
+        if (cached === undefined) {
+            cached = this.binding.getRandaoMix(epoch);
+            this._getRandaoMix.set(epoch, cached);
+        }
+        return cached;
+    }
+    // Shuffling and committees
+    getShufflingAtEpoch(epoch) {
+        let cached = this._getShufflingAtEpoch.get(epoch);
+        if (cached === undefined) {
+            cached = this.binding.getShufflingAtEpoch(epoch);
+            this._getShufflingAtEpoch.set(epoch, cached);
+        }
+        return cached;
+    }
+    get previousDecisionRoot() {
+        if (this._previousDecisionRoot === null) {
+            this._previousDecisionRoot = this.binding.previousDecisionRoot;
+        }
+        return this._previousDecisionRoot;
+    }
+    get currentDecisionRoot() {
+        if (this._currentDecisionRoot === null) {
+            this._currentDecisionRoot = this.binding.currentDecisionRoot;
+        }
+        return this._currentDecisionRoot;
+    }
+    get nextDecisionRoot() {
+        if (this._nextDecisionRoot === null) {
+            this._nextDecisionRoot = this.binding.nextDecisionRoot;
+        }
+        return this._nextDecisionRoot;
+    }
+    getShufflingDecisionRoot(epoch) {
+        let cached = this._getShufflingDecisionRoot.get(epoch);
+        if (cached === undefined) {
+            cached = this.binding.getShufflingDecisionRoot(epoch);
+            this._getShufflingDecisionRoot.set(epoch, cached);
+        }
+        return cached;
+    }
+    getPreviousShuffling() {
+        if (this._getPreviousShuffling === null) {
+            this._getPreviousShuffling = this.binding.getPreviousShuffling();
+        }
+        return this._getPreviousShuffling;
+    }
+    getCurrentShuffling() {
+        if (this._getCurrentShuffling === null) {
+            this._getCurrentShuffling = this.binding.getCurrentShuffling();
+        }
+        return this._getCurrentShuffling;
+    }
+    getNextShuffling() {
+        if (this._getNextShuffling === null) {
+            this._getNextShuffling = this.binding.getNextShuffling();
+        }
+        return this._getNextShuffling;
+    }
+    // Proposer shuffling
+    get previousProposers() {
+        if (this._previousProposers === undefined) {
+            this._previousProposers = this.binding.previousProposers;
+        }
+        return this._previousProposers;
+    }
+    get currentProposers() {
+        if (this._currentProposers === null) {
+            this._currentProposers = this.binding.currentProposers;
+        }
+        return this._currentProposers;
+    }
+    get nextProposers() {
+        if (this._nextProposers === null) {
+            this._nextProposers = this.binding.nextProposers;
+        }
+        return this._nextProposers;
+    }
+    getBeaconProposer(slot) {
+        let cached = this._getBeaconProposer.get(slot);
+        if (cached === undefined) {
+            cached = this.binding.getBeaconProposer(slot);
+            this._getBeaconProposer.set(slot, cached);
+        }
+        return cached;
+    }
+    getBeaconProposerOrNull(slot) {
+        if (!this._getBeaconProposerOrNull.has(slot)) {
+            this._getBeaconProposerOrNull.set(slot, this.binding.getBeaconProposerOrNull(slot));
+        }
+        // biome-ignore lint/style/noNonNullAssertion: has() check guarantees a value
+        return this._getBeaconProposerOrNull.get(slot);
+    }
+    // Validators and balances
+    get effectiveBalanceIncrements() {
+        if (this._effectiveBalanceIncrements === null) {
+            this._effectiveBalanceIncrements = this.binding.effectiveBalanceIncrements;
+        }
+        return this._effectiveBalanceIncrements;
+    }
+    getEffectiveBalanceIncrementsZeroInactive() {
+        if (this._getEffectiveBalanceIncrementsZeroInactive === null) {
+            this._getEffectiveBalanceIncrementsZeroInactive = this.binding.getEffectiveBalanceIncrementsZeroInactive();
+        }
+        return this._getEffectiveBalanceIncrementsZeroInactive;
+    }
+    getBalance(index) {
+        let cached = this._getBalance.get(index);
+        if (cached === undefined) {
+            cached = this.binding.getBalance(index);
+            this._getBalance.set(index, cached);
+        }
+        return cached;
+    }
+    getValidator(index) {
+        let cached = this._getValidator.get(index);
+        if (cached === undefined) {
+            cached = this.binding.getValidator(index);
+            this._getValidator.set(index, cached);
+        }
+        return cached;
+    }
+    getValidatorsByStatus(statuses, currentEpoch) {
+        return this.binding.getValidatorsByStatus(statuses, currentEpoch);
+    }
+    get validatorCount() {
+        if (this._validatorCount === null) {
+            this._validatorCount = this.binding.validatorCount;
+        }
+        return this._validatorCount;
+    }
+    get activeValidatorCount() {
+        if (this._activeValidatorCount === null) {
+            this._activeValidatorCount = this.binding.activeValidatorCount;
+        }
+        return this._activeValidatorCount;
+    }
+    getAllValidators() {
+        if (this._getAllValidators === null) {
+            this._getAllValidators = this.binding.getAllValidators();
+        }
+        return this._getAllValidators;
+    }
+    getAllBalances() {
+        if (this._getAllBalances === null) {
+            this._getAllBalances = this.binding.getAllBalances();
+        }
+        return this._getAllBalances;
+    }
+    // API
+    get proposerRewards() {
+        return this.binding.proposerRewards;
+    }
+    computeBlockRewards(block, proposerRewards) {
+        return this.binding.computeBlockRewards(block, proposerRewards);
+    }
+    computeAttestationsRewards(validatorIds) {
+        return this.binding.computeAttestationsRewards(validatorIds);
+    }
+    getLatestWeakSubjectivityCheckpointEpoch() {
+        if (this._getLatestWeakSubjectivityCheckpointEpoch === null) {
+            this._getLatestWeakSubjectivityCheckpointEpoch = this.binding.getLatestWeakSubjectivityCheckpointEpoch();
+        }
+        return this._getLatestWeakSubjectivityCheckpointEpoch;
+    }
+    // Validation
+    getVoluntaryExitValidity(signedVoluntaryExit, verifySignature) {
+        return this.binding.getVoluntaryExitValidity(signedVoluntaryExit, verifySignature);
+    }
+    isValidVoluntaryExit(signedVoluntaryExit, verifySignature) {
+        return this.binding.isValidVoluntaryExit(signedVoluntaryExit, verifySignature);
+    }
+    // Proofs
+    getFinalizedRootProof() {
+        if (this._getFinalizedRootProof === null) {
+            this._getFinalizedRootProof = this.binding.getFinalizedRootProof();
+        }
+        return this._getFinalizedRootProof;
+    }
+    getSingleProof(gindex) {
+        let cached = this._getSingleProof.get(gindex);
+        if (cached === undefined) {
+            cached = this.binding.getSingleProof(gindex);
+            this._getSingleProof.set(gindex, cached);
+        }
+        return cached;
+    }
+    createMultiProof(descriptor) {
+        return this.binding.createMultiProof(descriptor);
+    }
+    // Fork choice
+    computeUnrealizedCheckpoints() {
+        if (this._computeUnrealizedCheckpoints === null) {
+            this._computeUnrealizedCheckpoints = this.binding.computeUnrealizedCheckpoints();
+        }
+        return this._computeUnrealizedCheckpoints;
+    }
+    computeAnchorCheckpoint() {
+        if (this._computeAnchorCheckpoint === null) {
+            this._computeAnchorCheckpoint = this.binding.computeAnchorCheckpoint();
+        }
+        return this._computeAnchorCheckpoint;
+    }
+    // Backward compatibility
+    get clonedCount() {
+        return this.binding.clonedCount;
+    }
+    get clonedCountWithTransferCache() {
+        return this.binding.clonedCountWithTransferCache;
+    }
+    get createdWithTransferCache() {
+        if (this._createdWithTransferCache === null) {
+            this._createdWithTransferCache = this.binding.createdWithTransferCache;
+        }
+        return this._createdWithTransferCache;
+    }
+    isStateValidatorsNodesPopulated() {
+        if (this._isStateValidatorsNodesPopulated === null) {
+            this._isStateValidatorsNodesPopulated = this.binding.isStateValidatorsNodesPopulated();
+        }
+        return this._isStateValidatorsNodesPopulated;
+    }
+    // Serialization
+    loadOtherState(stateBytes, seedValidatorsBytes, opts) {
+        return new NativeBeaconStateView(this.binding.loadOtherState(stateBytes, seedValidatorsBytes, opts));
+    }
+    toValue() {
+        if (this._toValue === null) {
+            this._toValue = this.binding.toValue();
+        }
+        return this._toValue;
+    }
+    serialize() {
+        if (this._serialize === null) {
+            this._serialize = this.binding.serialize();
+        }
+        return this._serialize;
+    }
+    serializedSize() {
+        if (this._serializedSize === null) {
+            this._serializedSize = this.binding.serializedSize();
+        }
+        return this._serializedSize;
+    }
+    serializeToBytes(output, offset) {
+        return this.binding.serializeToBytes(output, offset);
+    }
+    serializeValidators() {
+        if (this._serializeValidators === null) {
+            this._serializeValidators = this.binding.serializeValidators();
+        }
+        return this._serializeValidators;
+    }
+    serializedValidatorsSize() {
+        if (this._serializedValidatorsSize === null) {
+            this._serializedValidatorsSize = this.binding.serializedValidatorsSize();
+        }
+        return this._serializedValidatorsSize;
+    }
+    serializeValidatorsToBytes(output, offset) {
+        return this.binding.serializeValidatorsToBytes(output, offset);
+    }
+    hashTreeRoot() {
+        if (this._hashTreeRoot === null) {
+            this._hashTreeRoot = this.binding.hashTreeRoot();
+        }
+        return this._hashTreeRoot;
+    }
+    // State transition
+    stateTransition(signedBlock, options, modules) {
+        return new NativeBeaconStateView(this.binding.stateTransition(signedBlock, options, modules));
+    }
+    processSlots(slot, epochTransitionCacheOpts, modules) {
+        return new NativeBeaconStateView(this.binding.processSlots(slot, epochTransitionCacheOpts, modules));
+    }
+    // ─── altair ──────────────────────────────────────────────────────────────
+    get previousEpochParticipation() {
+        if (this._previousEpochParticipation === null) {
+            this._previousEpochParticipation = this.binding.previousEpochParticipation;
+        }
+        return this._previousEpochParticipation;
+    }
+    get currentEpochParticipation() {
+        if (this._currentEpochParticipation === null) {
+            this._currentEpochParticipation = this.binding.currentEpochParticipation;
+        }
+        return this._currentEpochParticipation;
+    }
+    getPreviousEpochParticipation(validatorIndex) {
+        return this.previousEpochParticipation[validatorIndex];
+    }
+    getCurrentEpochParticipation(validatorIndex) {
+        return this.currentEpochParticipation[validatorIndex];
+    }
+    get currentSyncCommittee() {
+        if (this._currentSyncCommittee === null) {
+            this._currentSyncCommittee = this.binding.currentSyncCommittee;
+        }
+        return this._currentSyncCommittee;
+    }
+    get nextSyncCommittee() {
+        if (this._nextSyncCommittee === null) {
+            this._nextSyncCommittee = this.binding.nextSyncCommittee;
+        }
+        return this._nextSyncCommittee;
+    }
+    get currentSyncCommitteeIndexed() {
+        if (this._currentSyncCommitteeIndexed === null) {
+            this._currentSyncCommitteeIndexed = this.binding.currentSyncCommitteeIndexed;
+        }
+        return this._currentSyncCommitteeIndexed;
+    }
+    get syncProposerReward() {
+        if (this._syncProposerReward === null) {
+            this._syncProposerReward = this.binding.syncProposerReward;
+        }
+        return this._syncProposerReward;
+    }
+    getIndexedSyncCommitteeAtEpoch(epoch) {
+        let cached = this._getIndexedSyncCommitteeAtEpoch.get(epoch);
+        if (cached === undefined) {
+            cached = this.binding.getIndexedSyncCommitteeAtEpoch(epoch);
+            this._getIndexedSyncCommitteeAtEpoch.set(epoch, cached);
+        }
+        return cached;
+    }
+    getIndexedSyncCommittee(slot) {
+        let cached = this._getIndexedSyncCommittee.get(slot);
+        if (cached === undefined) {
+            cached = this.binding.getIndexedSyncCommittee(slot);
+            this._getIndexedSyncCommittee.set(slot, cached);
+        }
+        return cached;
+    }
+    computeSyncCommitteeRewards(block, validatorIds) {
+        return this.binding.computeSyncCommitteeRewards(block, validatorIds);
+    }
+    getSyncCommitteesWitness() {
+        if (this._getSyncCommitteesWitness === null) {
+            this._getSyncCommitteesWitness = this.binding.getSyncCommitteesWitness();
+        }
+        return this._getSyncCommitteesWitness;
+    }
+    // ─── bellatrix ───────────────────────────────────────────────────────────
+    get latestExecutionPayloadHeader() {
+        if (this._latestExecutionPayloadHeader === null) {
+            this._latestExecutionPayloadHeader = this.binding.latestExecutionPayloadHeader;
+        }
+        return this._latestExecutionPayloadHeader;
+    }
+    get payloadBlockNumber() {
+        if (this._payloadBlockNumber === null) {
+            this._payloadBlockNumber = this.binding.payloadBlockNumber;
+        }
+        return this._payloadBlockNumber;
+    }
+    get isExecutionStateType() {
+        if (this._isExecutionStateType === null) {
+            this._isExecutionStateType = this.binding.isExecutionStateType;
+        }
+        return this._isExecutionStateType;
+    }
+    get isMergeTransitionComplete() {
+        if (this._isMergeTransitionComplete === null) {
+            this._isMergeTransitionComplete = this.binding.isMergeTransitionComplete;
+        }
+        return this._isMergeTransitionComplete;
+    }
+    isExecutionEnabled(block) {
+        return this.binding.isExecutionEnabled(block);
+    }
+    // ─── capella ─────────────────────────────────────────────────────────────
+    get historicalSummaries() {
+        if (this._historicalSummaries === null) {
+            this._historicalSummaries = this.binding.historicalSummaries;
+        }
+        return this._historicalSummaries;
+    }
+    getExpectedWithdrawals() {
+        if (this._getExpectedWithdrawals === null) {
+            this._getExpectedWithdrawals = this.binding.getExpectedWithdrawals();
+        }
+        return this._getExpectedWithdrawals;
+    }
+    // ─── electra ─────────────────────────────────────────────────────────────
+    get pendingDeposits() {
+        if (this._pendingDeposits === null) {
+            this._pendingDeposits = this.binding.pendingDeposits;
+        }
+        return this._pendingDeposits;
+    }
+    get pendingDepositsCount() {
+        if (this._pendingDepositsCount === null) {
+            this._pendingDepositsCount = this.binding.pendingDepositsCount;
+        }
+        return this._pendingDepositsCount;
+    }
+    get pendingPartialWithdrawals() {
+        if (this._pendingPartialWithdrawals === null) {
+            this._pendingPartialWithdrawals = this.binding.pendingPartialWithdrawals;
+        }
+        return this._pendingPartialWithdrawals;
+    }
+    get pendingPartialWithdrawalsCount() {
+        if (this._pendingPartialWithdrawalsCount === null) {
+            this._pendingPartialWithdrawalsCount = this.binding.pendingPartialWithdrawalsCount;
+        }
+        return this._pendingPartialWithdrawalsCount;
+    }
+    get pendingConsolidations() {
+        if (this._pendingConsolidations === null) {
+            this._pendingConsolidations = this.binding.pendingConsolidations;
+        }
+        return this._pendingConsolidations;
+    }
+    get pendingConsolidationsCount() {
+        if (this._pendingConsolidationsCount === null) {
+            this._pendingConsolidationsCount = this.binding.pendingConsolidationsCount;
+        }
+        return this._pendingConsolidationsCount;
+    }
+    // ─── fulu ────────────────────────────────────────────────────────────────
+    get proposerLookahead() {
+        if (this._proposerLookahead === null) {
+            this._proposerLookahead = this.binding.proposerLookahead;
+        }
+        return this._proposerLookahead;
+    }
+    // ─── gloas ───────────────────────────────────────────────────────────────
+    get latestBlockHash() {
+        if (this._latestBlockHash === null) {
+            this._latestBlockHash = this.binding.latestBlockHash;
+        }
+        return this._latestBlockHash;
+    }
+    // executionPayloadAvailability getter is defined near the top of the class.
+    get latestExecutionPayloadBid() {
+        if (this._latestExecutionPayloadBid === null) {
+            this._latestExecutionPayloadBid = this.binding.latestExecutionPayloadBid;
+        }
+        return this._latestExecutionPayloadBid;
+    }
+    get payloadExpectedWithdrawals() {
+        if (this._payloadExpectedWithdrawals === null) {
+            this._payloadExpectedWithdrawals = this.binding.payloadExpectedWithdrawals;
+        }
+        return this._payloadExpectedWithdrawals;
+    }
+    getBuilder(index) {
+        let cached = this._getBuilder.get(index);
+        if (cached === undefined) {
+            cached = this.binding.getBuilder(index);
+            this._getBuilder.set(index, cached);
+        }
+        return cached;
+    }
+    canBuilderCoverBid(builderIndex, bidAmount) {
+        return this.binding.canBuilderCoverBid(builderIndex, bidAmount);
+    }
+    getEpochPTCs(epoch) {
+        let cached = this._getEpochPTCs.get(epoch);
+        if (cached === undefined) {
+            cached = this.binding.getEpochPTCs(epoch);
+            this._getEpochPTCs.set(epoch, cached);
+        }
+        return cached;
+    }
+    getIndicesInPayloadTimelinessCommittee(validatorIndex, slot) {
+        return this.binding.getIndicesInPayloadTimelinessCommittee(validatorIndex, slot);
+    }
+    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