@lodestar/state-transition 1.41.0-dev.b847afb846 → 1.41.0-dev.bb16850567

package/src/block/processExecutionPayloadEnvelope.ts

@@ -7,18 +7,25 @@ import {
 } from "@lodestar/params";
 import {gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {computeSigningRoot, computeTimeAtSlot} from "../util/index.ts";
-import {processConsolidationRequest} from "./processConsolidationRequest.ts";
-import {processDepositRequest} from "./processDepositRequest.ts";
-import {processWithdrawalRequest} from "./processWithdrawalRequest.ts";
-
-// This function does not call execution engine to verify payload. Need to call it from other place
+import {CachedBeaconStateGloas} from "../types.js";
+import {computeSigningRoot, computeTimeAtSlot} from "../util/index.js";
+import {processConsolidationRequest} from "./processConsolidationRequest.js";
+import {processDepositRequest} from "./processDepositRequest.js";
+import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
+
+export type ProcessExecutionPayloadEnvelopeOpts = {
+  dontTransferCache?: boolean;
+};
+
+// Unlike other block processing functions which mutate state in-place, this function
+// clones the state and returns the post-state, similar to stateTransition().
+// This function does not call execution engine to verify payload. Need to call it from other place.
 export function processExecutionPayloadEnvelope(
   state: CachedBeaconStateGloas,
   signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
-  verify: boolean
-): void {
+  verify: boolean,
+  opts?: ProcessExecutionPayloadEnvelopeOpts
+): CachedBeaconStateGloas {
   const envelope = signedEnvelope.message;
   const payload = envelope.payload;
   const fork = state.config.getForkSeq(envelope.slot);
@@ -27,42 +34,49 @@ export function processExecutionPayloadEnvelope(
     throw Error(`Execution payload envelope has invalid signature builderIndex=${envelope.builderIndex}`);
   }
 
-  validateExecutionPayloadEnvelope(state, envelope);
+  // .clone() before mutating state, similar to stateTransition()
+  const postState = state.clone(opts?.dontTransferCache) as CachedBeaconStateGloas;
+
+  validateExecutionPayloadEnvelope(postState, envelope);
 
   const requests = envelope.executionRequests;
 
   for (const deposit of requests.deposits) {
-    processDepositRequest(fork, state, deposit);
+    processDepositRequest(fork, postState, deposit);
   }
 
   for (const withdrawal of requests.withdrawals) {
-    processWithdrawalRequest(fork, state, withdrawal);
+    processWithdrawalRequest(fork, postState, withdrawal);
   }
 
   for (const consolidation of requests.consolidations) {
-    processConsolidationRequest(state, consolidation);
+    processConsolidationRequest(postState, consolidation);
   }
 
   // Queue the builder payment
-  const paymentIndex = SLOTS_PER_EPOCH + (state.slot % SLOTS_PER_EPOCH);
-  const payment = state.builderPendingPayments.get(paymentIndex).clone();
+  const paymentIndex = SLOTS_PER_EPOCH + (postState.slot % SLOTS_PER_EPOCH);
+  const payment = postState.builderPendingPayments.get(paymentIndex).clone();
   const amount = payment.withdrawal.amount;
 
   if (amount > 0) {
-    state.builderPendingWithdrawals.push(payment.withdrawal);
+    postState.builderPendingWithdrawals.push(payment.withdrawal);
   }
 
-  state.builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
+  postState.builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
 
   // Cache the execution payload hash
-  state.executionPayloadAvailability.set(state.slot % SLOTS_PER_HISTORICAL_ROOT, true);
-  state.latestBlockHash = payload.blockHash;
+  postState.executionPayloadAvailability.set(postState.slot % SLOTS_PER_HISTORICAL_ROOT, true);
+  postState.latestBlockHash = payload.blockHash;
 
-  if (verify && !byteArrayEquals(envelope.stateRoot, state.hashTreeRoot())) {
+  postState.commit();
+
+  if (verify && !byteArrayEquals(envelope.stateRoot, postState.hashTreeRoot())) {
     throw new Error(
-      `Envelope's state root does not match state envelope=${toRootHex(envelope.stateRoot)} state=${toRootHex(state.hashTreeRoot())}`
+      `Envelope's state root does not match state envelope=${toRootHex(envelope.stateRoot)} state=${toRootHex(postState.hashTreeRoot())}`
     );
   }
+
+  return postState;
 }
 
 function validateExecutionPayloadEnvelope(

package/src/block/processOperations.ts

@@ -14,7 +14,7 @@ import {processBlsToExecutionChange} from "./processBlsToExecutionChange.js";
 import {processConsolidationRequest} from "./processConsolidationRequest.js";
 import {processDeposit} from "./processDeposit.js";
 import {processDepositRequest} from "./processDepositRequest.js";
-import {processPayloadAttestation} from "./processPayloadAttestation.ts";
+import {processPayloadAttestation} from "./processPayloadAttestation.js";
 import {processProposerSlashing} from "./processProposerSlashing.js";
 import {processVoluntaryExit} from "./processVoluntaryExit.js";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.js";

package/src/block/processPayloadAttestation.ts

@@ -1,7 +1,7 @@
 import {gloas} from "@lodestar/types";
 import {byteArrayEquals} from "@lodestar/utils";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.ts";
+import {CachedBeaconStateGloas} from "../types.js";
+import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.js";
 
 export function processPayloadAttestation(
   state: CachedBeaconStateGloas,

package/src/block/processVoluntaryExit.ts

@@ -1,7 +1,7 @@
-import {PublicKey, Signature, verify} from "@chainsafe/blst";
 import {FAR_FUTURE_EPOCH, ForkSeq} from "@lodestar/params";
-import {phase0, ssz} from "@lodestar/types";
+import {phase0} from "@lodestar/types";
 import {verifyVoluntaryExitSignature} from "../signatureSets/index.js";
+import {BeaconStateView} from "../stateView/beaconStateView.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {
   convertValidatorIndexToBuilderIndex,
@@ -10,7 +10,7 @@ import {
   isActiveBuilder,
   isBuilderIndex,
 } from "../util/gloas.js";
-import {computeSigningRoot, getCurrentEpoch, getPendingBalanceToWithdraw, isActiveValidator} from "../util/index.js";
+import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/index.js";
 import {initiateValidatorExit} from "./index.js";
 
 export enum VoluntaryExitValidity {
@@ -35,57 +35,20 @@ export function processVoluntaryExit(
   verifySignature = true
 ): void {
   const voluntaryExit = signedVoluntaryExit.message;
-  const currentEpoch = getCurrentEpoch(state);
 
-  // Exits must specify an epoch when they become valid; they are not valid before then
-  if (currentEpoch < voluntaryExit.epoch) {
-    throw Error(`Voluntary exit epoch ${voluntaryExit.epoch} is after current epoch ${currentEpoch}`);
+  const validity = getVoluntaryExitValidity(fork, state, signedVoluntaryExit, verifySignature);
+  if (validity !== VoluntaryExitValidity.valid) {
+    throw Error(`Invalid voluntary exit at forkSeq=${fork} reason=${validity}`);
   }
 
-  // Check if this is a builder exit
   if (fork >= ForkSeq.gloas && isBuilderIndex(voluntaryExit.validatorIndex)) {
-    const stateGloas = state as CachedBeaconStateGloas;
-    const builderIndex = convertValidatorIndexToBuilderIndex(voluntaryExit.validatorIndex);
-    const builder = stateGloas.builders.getReadonly(builderIndex);
-
-    // Verify the builder is active
-    if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
-      throw Error(`Builder ${builderIndex} is not active`);
-    }
-
-    // Only exit builder if it has no pending withdrawals in the queue
-    if (getPendingBalanceToWithdrawForBuilder(stateGloas, builderIndex) !== 0) {
-      throw Error(`Builder ${builderIndex} has pending withdrawals`);
-    }
-
-    // Verify signature
-    if (verifySignature) {
-      const domain = state.config.getDomainForVoluntaryExit(state.slot);
-      const signingRoot = computeSigningRoot(ssz.phase0.VoluntaryExit, voluntaryExit, domain);
-
-      try {
-        const publicKey = PublicKey.fromBytes(builder.pubkey);
-        const signature = Signature.fromBytes(signedVoluntaryExit.signature, true);
-
-        if (!verify(signingRoot, publicKey, signature)) {
-          throw Error("BLS verify failed");
-        }
-      } catch (e) {
-        throw Error(`Builder ${builderIndex} invalid exit signature reason=${(e as Error).message}`);
-      }
-    }
-
-    // Initiate builder exit
-    initiateBuilderExit(stateGloas, builderIndex);
+    initiateBuilderExit(
+      state as CachedBeaconStateGloas,
+      convertValidatorIndexToBuilderIndex(voluntaryExit.validatorIndex)
+    );
     return;
   }
 
-  // Handle validator exit
-  const validity = getVoluntaryExitValidity(fork, state, signedVoluntaryExit, verifySignature);
-  if (validity !== VoluntaryExitValidity.valid) {
-    throw Error(`Invalid voluntary exit at forkSeq=${fork} reason=${validity}`);
-  }
-
   const validator = state.validators.get(signedVoluntaryExit.message.validatorIndex);
   initiateValidatorExit(fork, state, validator);
 }
@@ -95,10 +58,74 @@ export function getVoluntaryExitValidity(
   state: CachedBeaconStateAllForks,
   signedVoluntaryExit: phase0.SignedVoluntaryExit,
   verifySignature = true
+): VoluntaryExitValidity {
+  const currentEpoch = state.epochCtx.epoch;
+  const voluntaryExit = signedVoluntaryExit.message;
+
+  // Exits must specify an epoch when they become valid; they are not valid before then
+  if (currentEpoch < voluntaryExit.epoch) {
+    return VoluntaryExitValidity.earlyEpoch;
+  }
+
+  // Check if this is a builder exit
+  if (fork >= ForkSeq.gloas && isBuilderIndex(voluntaryExit.validatorIndex)) {
+    return getBuilderVoluntaryExitValidity(state as CachedBeaconStateGloas, signedVoluntaryExit, verifySignature);
+  }
+
+  return getValidatorVoluntaryExitValidity(fork, state, signedVoluntaryExit, verifySignature);
+}
+
+function getBuilderVoluntaryExitValidity(
+  state: CachedBeaconStateGloas,
+  signedVoluntaryExit: phase0.SignedVoluntaryExit,
+  verifySignature: boolean
+): VoluntaryExitValidity {
+  const {config, epochCtx} = state;
+  const builderIndex = convertValidatorIndexToBuilderIndex(signedVoluntaryExit.message.validatorIndex);
+
+  if (builderIndex >= state.builders.length) {
+    return VoluntaryExitValidity.inactive;
+  }
+
+  const builder = state.builders.getReadonly(builderIndex);
+
+  // Verify the builder is active
+  if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
+    return builder.withdrawableEpoch !== FAR_FUTURE_EPOCH
+      ? VoluntaryExitValidity.alreadyExited
+      : VoluntaryExitValidity.inactive;
+  }
+
+  // Only exit builder if it has no pending withdrawals in the queue
+  if (getPendingBalanceToWithdrawForBuilder(state, builderIndex) !== 0) {
+    return VoluntaryExitValidity.pendingWithdrawals;
+  }
+
+  // Verify signature
+  if (
+    verifySignature &&
+    !verifyVoluntaryExitSignature(config, epochCtx.pubkeyCache, new BeaconStateView(state), signedVoluntaryExit)
+  ) {
+    return VoluntaryExitValidity.invalidSignature;
+  }
+
+  return VoluntaryExitValidity.valid;
+}
+
+function getValidatorVoluntaryExitValidity(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  signedVoluntaryExit: phase0.SignedVoluntaryExit,
+  verifySignature: boolean
 ): VoluntaryExitValidity {
   const {config, epochCtx} = state;
   const voluntaryExit = signedVoluntaryExit.message;
-  const validator = state.validators.get(voluntaryExit.validatorIndex);
+
+  if (voluntaryExit.validatorIndex >= state.validators.length) {
+    return VoluntaryExitValidity.inactive;
+  }
+
+  const validator = state.validators.getReadonly(voluntaryExit.validatorIndex);
   const currentEpoch = epochCtx.epoch;
 
   // verify the validator is active
@@ -111,11 +138,6 @@ export function getVoluntaryExitValidity(
     return VoluntaryExitValidity.alreadyExited;
   }
 
-  // exits must specify an epoch when they become valid; they are not valid before then
-  if (currentEpoch < voluntaryExit.epoch) {
-    return VoluntaryExitValidity.earlyEpoch;
-  }
-
   // verify the validator had been active long enough
   if (currentEpoch < validator.activationEpoch + config.SHARD_COMMITTEE_PERIOD) {
     return VoluntaryExitValidity.shortTimeActive;
@@ -129,9 +151,10 @@ export function getVoluntaryExitValidity(
     return VoluntaryExitValidity.pendingWithdrawals;
   }
 
+  // Verify signature
   if (
     verifySignature &&
-    !verifyVoluntaryExitSignature(state.config, epochCtx.pubkeyCache, state.slot, signedVoluntaryExit)
+    !verifyVoluntaryExitSignature(config, epochCtx.pubkeyCache, new BeaconStateView(state), signedVoluntaryExit)
   ) {
     return VoluntaryExitValidity.invalidSignature;
   }

package/src/block/processWithdrawals.ts

@@ -16,7 +16,7 @@ import {
   convertValidatorIndexToBuilderIndex,
   isBuilderIndex,
   isParentBlockFull,
-} from "../util/gloas.ts";
+} from "../util/gloas.js";
 import {
   decreaseBalance,
   getMaxEffectiveBalance,

package/src/epoch/index.ts

@@ -16,7 +16,7 @@ import {
   CachedBeaconStatePhase0,
   EpochTransitionCache,
 } from "../types.js";
-import {processBuilderPendingPayments} from "./processBuilderPendingPayments.ts";
+import {processBuilderPendingPayments} from "./processBuilderPendingPayments.js";
 import {processEffectiveBalanceUpdates} from "./processEffectiveBalanceUpdates.js";
 import {processEth1DataReset} from "./processEth1DataReset.js";
 import {processHistoricalRootsUpdate} from "./processHistoricalRootsUpdate.js";

package/src/epoch/processBuilderPendingPayments.ts

@@ -1,7 +1,7 @@
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {getBuilderPaymentQuorumThreshold} from "../util/gloas.ts";
+import {CachedBeaconStateGloas} from "../types.js";
+import {getBuilderPaymentQuorumThreshold} from "../util/gloas.js";
 
 /**
  * Processes the builder pending payments from the previous epoch.

package/src/signatureSets/index.ts

@@ -3,6 +3,8 @@ import {ForkSeq} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, altair, capella} from "@lodestar/types";
 import {getSyncCommitteeSignatureSet} from "../block/processSyncCommittee.js";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
+import {BeaconStateView} from "../stateView/beaconStateView.js";
+import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet} from "../util/index.js";
 import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
 import {getBlsToExecutionChangeSignatureSets} from "./blsToExecutionChange.js";
@@ -30,6 +32,7 @@ export * from "./voluntaryExits.js";
 export function getBlockSignatureSets(
   config: BeaconConfig,
   currentSyncCommitteeIndexed: SyncCommitteeCache,
+  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[],
   opts?: {
@@ -45,7 +48,7 @@ export function getBlockSignatureSets(
     ...getProposerSlashingsSignatureSets(config, signedBlock),
     ...getAttesterSlashingsSignatureSets(config, signedBlock),
     ...getAttestationsSignatureSets(config, signedBlock, indexedAttestations),
-    ...getVoluntaryExitsSignatureSets(config, signedBlock),
+    ...getVoluntaryExitsSignatureSets(config, new BeaconStateView(state), signedBlock),
   ];
 
   if (!opts?.skipProposerSignature) {

package/src/signatureSets/voluntaryExits.ts

@@ -1,27 +1,56 @@
+import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
+import {ForkSeq} from "@lodestar/params";
 import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
 import {PubkeyCache} from "../cache/pubkeyCache.js";
+import {IBeaconStateView} from "../stateView/interface.js";
 import {
   ISignatureSet,
   SignatureSetType,
   computeSigningRoot,
   computeStartSlotAtEpoch,
+  convertValidatorIndexToBuilderIndex,
+  isBuilderIndex,
   verifySignatureSet,
 } from "../util/index.js";
 
 export function verifyVoluntaryExitSignature(
   config: BeaconConfig,
   pubkeyCache: PubkeyCache,
-  stateSlot: Slot,
+  state: IBeaconStateView,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(config, stateSlot, signedVoluntaryExit), pubkeyCache);
+  return verifySignatureSet(getVoluntaryExitSignatureSet(config, state, signedVoluntaryExit), pubkeyCache);
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
 export function getVoluntaryExitSignatureSet(
+  config: BeaconConfig,
+  state: IBeaconStateView,
+  signedVoluntaryExit: phase0.SignedVoluntaryExit
+): ISignatureSet {
+  const fork = config.getForkSeq(state.slot);
+
+  if (fork >= ForkSeq.gloas && isBuilderVoluntaryExit(signedVoluntaryExit)) {
+    return getBuilderVoluntaryExitSignatureSet(config, state, signedVoluntaryExit);
+  }
+
+  return getValidatorVoluntaryExitSignatureSet(config, state.slot, signedVoluntaryExit);
+}
+
+export function getVoluntaryExitsSignatureSets(
+  config: BeaconConfig,
+  state: IBeaconStateView,
+  signedBlock: SignedBeaconBlock
+): ISignatureSet[] {
+  return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
+    getVoluntaryExitSignatureSet(config, state, voluntaryExit)
+  );
+}
+
+export function getValidatorVoluntaryExitSignatureSet(
   config: BeaconConfig,
   stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
@@ -37,11 +66,24 @@ export function getVoluntaryExitSignatureSet(
   };
 }
 
-export function getVoluntaryExitsSignatureSets(config: BeaconConfig, signedBlock: SignedBeaconBlock): ISignatureSet[] {
-  // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
-  // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
-  const blockSlot = signedBlock.message.slot;
-  return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(config, blockSlot, voluntaryExit)
-  );
+export function getBuilderVoluntaryExitSignatureSet(
+  config: BeaconConfig,
+  state: IBeaconStateView,
+  signedVoluntaryExit: phase0.SignedVoluntaryExit
+): ISignatureSet {
+  const messageSlot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
+  const domain = config.getDomainForVoluntaryExit(state.slot, messageSlot);
+  const builderIndex = convertValidatorIndexToBuilderIndex(signedVoluntaryExit.message.validatorIndex);
+  const builder = state.getBuilder(builderIndex);
+
+  return {
+    type: SignatureSetType.single,
+    pubkey: PublicKey.fromBytes(builder.pubkey),
+    signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
+    signature: signedVoluntaryExit.signature,
+  };
+}
+
+export function isBuilderVoluntaryExit(signedVoluntaryExit: phase0.SignedVoluntaryExit): boolean {
+  return isBuilderIndex(signedVoluntaryExit.message.validatorIndex);
 }

package/src/stateView/beaconStateView.ts

@@ -1,7 +1,7 @@
 import {CompactMultiProof, ProofType, Tree, createProof} from "@chainsafe/persistent-merkle-tree";
 import {ByteViews} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
-import {ForkSeq, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {ForkSeq, SLOTS_PER_HISTORICAL_ROOT, isForkPostGloas} from "@lodestar/params";
 import {
   BeaconBlock,
   BlindedBeaconBlock,
@@ -27,6 +27,7 @@ import {
   rewards,
 } from "@lodestar/types";
 import {Checkpoint, Fork} from "@lodestar/types/phase0";
+import {processExecutionPayloadEnvelope} from "../block/index.js";
 import {VoluntaryExitValidity, getVoluntaryExitValidity} from "../block/processVoluntaryExit.js";
 import {getExpectedWithdrawals} from "../block/processWithdrawals.js";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
@@ -75,10 +76,12 @@ export class BeaconStateView implements IBeaconStateView {
   // altair
   private _currentSyncCommittee: SyncCommittee | null = null;
   private _nextSyncCommittee: SyncCommittee | null = null;
-  private _previousEpochParticipation: number[] | null = null;
-  private _currentEpochParticipation: number[] | null = null;
+  private _previousEpochParticipation: Uint8Array | null = null;
+  private _currentEpochParticipation: Uint8Array | null = null;
   // bellatrix
   private _latestExecutionPayloadHeader: ExecutionPayloadHeader | null = null;
+  // Caches the cross-fork latestBlockHash value
+  private _latestBlockHash: Bytes32 | null = null;
   // capella
   private _historicalSummaries: capella.HistoricalSummaries | null = null;
   // electra
@@ -159,7 +162,7 @@ export class BeaconStateView implements IBeaconStateView {
     return getRandaoMix(this.cachedState, epoch);
   }
 
-  get previousEpochParticipation(): number[] {
+  get previousEpochParticipation(): Uint8Array {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.altair) {
       throw new Error("previousEpochParticipation is not available before Altair");
     }
@@ -167,7 +170,7 @@ export class BeaconStateView implements IBeaconStateView {
     if (this._previousEpochParticipation === null) {
       this._previousEpochParticipation = (
         this.cachedState as CachedBeaconStateAltair
-      ).previousEpochParticipation.toValue();
+      ).previousEpochParticipation.serialize();
     }
 
     return this._previousEpochParticipation;
@@ -175,7 +178,7 @@ export class BeaconStateView implements IBeaconStateView {
 
   // altair
 
-  get currentEpochParticipation(): number[] {
+  get currentEpochParticipation(): Uint8Array {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.altair) {
       throw new Error("currentEpochParticipation is not available before Altair");
     }
@@ -183,12 +186,26 @@ export class BeaconStateView implements IBeaconStateView {
     if (this._currentEpochParticipation === null) {
       this._currentEpochParticipation = (
         this.cachedState as CachedBeaconStateAltair
-      ).currentEpochParticipation.toValue();
+      ).currentEpochParticipation.serialize();
     }
 
     return this._currentEpochParticipation;
   }
 
+  getPreviousEpochParticipation(validatorIndex: ValidatorIndex): number {
+    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.altair) {
+      throw new Error("previousEpochParticipation is not available before Altair");
+    }
+    return (this.cachedState as CachedBeaconStateAltair).previousEpochParticipation.get(validatorIndex);
+  }
+
+  getCurrentEpochParticipation(validatorIndex: ValidatorIndex): number {
+    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.altair) {
+      throw new Error("currentEpochParticipation is not available before Altair");
+    }
+    return (this.cachedState as CachedBeaconStateAltair).currentEpochParticipation.get(validatorIndex);
+  }
+
   // bellatrix
 
   get latestExecutionPayloadHeader(): ExecutionPayloadHeader {
@@ -205,6 +222,46 @@ export class BeaconStateView implements IBeaconStateView {
     return this._latestExecutionPayloadHeader;
   }
 
+  /**
+   * Cross-fork accessor for the execution block hash of the most recently included payload.
+   * Pre-gloas: reads from latestExecutionPayloadHeader.blockHash.
+   * Gloas+: reads the dedicated latestBlockHash field (EIP-7732).
+   */
+  get latestBlockHash(): Bytes32 {
+    const forkSeq = this.config.getForkSeq(this.cachedState.slot);
+    if (forkSeq < ForkSeq.bellatrix) {
+      throw new Error("latestBlockHash is not available before Bellatrix");
+    }
+
+    if (this._latestBlockHash === null) {
+      if (forkSeq >= ForkSeq.gloas) {
+        this._latestBlockHash = (this.cachedState as CachedBeaconStateGloas).latestBlockHash;
+      } else {
+        this._latestBlockHash = (
+          this.cachedState as CachedBeaconStateExecutions
+        ).latestExecutionPayloadHeader.blockHash;
+      }
+    }
+
+    return this._latestBlockHash;
+  }
+
+  /**
+   * The execution block number of the most recently included payload.
+   * Named payloadBlockNumber (not latestBlockNumber) to mirror ExecutionPayloadHeader.blockNumber pre-gloas.
+   * Only available from bellatrix through fulu — not tracked on BeaconState in gloas+ (EIP-7732).
+   */
+  get payloadBlockNumber(): number {
+    const forkSeq = this.config.getForkSeq(this.cachedState.slot);
+    if (forkSeq < ForkSeq.bellatrix) {
+      throw new Error("payloadBlockNumber is not available before Bellatrix");
+    }
+    if (forkSeq >= ForkSeq.gloas) {
+      throw new Error("payloadBlockNumber is not available post-gloas");
+    }
+    return (this.cachedState as CachedBeaconStateExecutions).latestExecutionPayloadHeader.blockNumber;
+  }
+
   // capella
 
   get historicalSummaries(): capella.HistoricalSummaries {
@@ -703,6 +760,14 @@ export class BeaconStateView implements IBeaconStateView {
     const newState = processSlots(this.cachedState, slot, epochTransitionCacheOpts, modules);
     return new BeaconStateView(newState);
   }
+
+  processExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope, verify: boolean): void {
+    const fork = this.config.getForkName(this.cachedState.slot);
+    if (!isForkPostGloas(fork)) {
+      throw Error(`processExecutionPayloadEnvelope is only available for gloas+ forks, got fork=${fork}`);
+    }
+    processExecutionPayloadEnvelope(this.cachedState as CachedBeaconStateGloas, signedEnvelope, verify);
+  }
 }
 
 /**

package/src/stateView/interface.ts

@@ -55,11 +55,27 @@ export interface IBeaconStateView {
   getRandaoMix(epoch: Epoch): Bytes32;
 
   // altair
-  previousEpochParticipation: number[];
-  currentEpochParticipation: number[];
+  previousEpochParticipation: Uint8Array;
+  currentEpochParticipation: Uint8Array;
+  getPreviousEpochParticipation(validatorIndex: ValidatorIndex): number;
+  getCurrentEpochParticipation(validatorIndex: ValidatorIndex): number;
 
   // bellatrix
   latestExecutionPayloadHeader: ExecutionPayloadHeader;
+  /**
+   * Cross-fork accessor for the execution block hash of the most recently included payload.
+   * Pre-gloas: returns latestExecutionPayloadHeader.blockHash (bellatrix–fulu).
+   * Gloas+: returns the dedicated latestBlockHash state field (EIP-7732).
+   * Throws before bellatrix.
+   */
+  latestBlockHash: Bytes32;
+  /**
+   * The execution block number of the most recently included payload.
+   * Named payloadBlockNumber (not latestBlockNumber) to mirror ExecutionPayloadHeader.blockNumber pre-gloas.
+   * Only available from bellatrix through fulu — not tracked on BeaconState in gloas+ (EIP-7732).
+   * Throws before bellatrix and from gloas onwards.
+   */
+  payloadBlockNumber: number;
 
   // capella
   historicalSummaries: capella.HistoricalSummaries;
@@ -193,4 +209,5 @@ export interface IBeaconStateView {
     epochTransitionCacheOpts?: EpochTransitionCacheOpts & {dontTransferCache?: boolean},
     modules?: StateTransitionModules
   ): IBeaconStateView;
+  processExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope, verify: boolean): void;
 }

package/src/testUtils/cache.ts

@@ -0,0 +1,8 @@
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+
+// Global variable __dirname no longer available in ES6 modules.
+// Solutions: https://stackoverflow.com/questions/46745014/alternative-for-dirname-in-node-js-when-using-es6-modules
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export const testCachePath = path.join(__dirname, "../../test/test-cache");

package/src/testUtils/index.ts

@@ -0,0 +1,5 @@
+export * from "./cache.js";
+export * from "./interop.js";
+export * from "./params.js";
+export * from "./testFileCache.js";
+export * from "./util.js";

package/src/testUtils/infura.ts

@@ -0,0 +1,10 @@
+import {NetworkName} from "@lodestar/config/networks";
+
+export function getInfuraBeaconUrl(network: NetworkName): string {
+  const INFURA_ETH2_CREDENTIALS = process.env.INFURA_ETH2_CREDENTIALS;
+  if (!INFURA_ETH2_CREDENTIALS) {
+    throw Error("Must set ENV INFURA_ETH2_CREDENTIALS");
+  }
+
+  return `https://${INFURA_ETH2_CREDENTIALS}@eth2-beacon-${network}.infura.io`;
+}