@lodestar/state-transition 1.42.0 → 1.43.0-dev.07452fe3b7

package/src/epoch/processPtcWindow.ts

@@ -0,0 +1,38 @@
+import {MIN_SEED_LOOKAHEAD} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+import {CachedBeaconStateGloas, EpochTransitionCache} from "../types.js";
+import {computeEpochShuffling} from "../util/epochShuffling.js";
+import {computePayloadTimelinessCommitteesForEpoch} from "../util/seed.js";
+
+/**
+ * Update the `ptc_window` field in the beacon state by shifting out the oldest epoch's
+ * PTC entries and appending newly computed entries for the next lookahead epoch.
+ * Stashes the computed PTCs in the transition cache for finalProcessEpoch to shift
+ * into the epoch cache without reading from state.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.4/specs/gloas/beacon-chain.md#new-process_ptc_window
+ */
+export function processPtcWindow(state: CachedBeaconStateGloas, cache: EpochTransitionCache): void {
+  const nextEpoch = state.epochCtx.epoch + MIN_SEED_LOOKAHEAD + 1;
+  const nextEpochShuffling =
+    cache.nextShuffling ?? computeEpochShuffling(state, cache.nextShufflingActiveIndices, nextEpoch);
+  cache.nextShuffling = nextEpochShuffling;
+
+  const newNextPayloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+    state,
+    nextEpoch,
+    nextEpochShuffling.committees,
+    state.epochCtx.effectiveBalanceIncrements
+  );
+
+  // Stash for finalProcessEpoch to shift into epoch cache
+  cache.nextEpochPayloadTimelinessCommittees = newNextPayloadTimelinessCommittees;
+
+  // Write shifted window to state: current(N) + next(N+1) + newlyComputed(N+2)
+  // From the perspective of upcoming epoch N+1, this is previous + current + next
+  state.ptcWindow = ssz.gloas.PtcWindow.toViewDU([
+    ...state.epochCtx.payloadTimelinessCommittees,
+    ...state.epochCtx.nextPayloadTimelinessCommittees,
+    ...newNextPayloadTimelinessCommittees,
+  ]);
+}

package/src/index.ts

@@ -35,14 +35,32 @@ export {
   isStateValidatorsNodesPopulated,
   loadCachedBeaconState,
 } from "./cache/stateCache.js";
-export {type SyncCommitteeCache} from "./cache/syncCommitteeCache.js";
+export {type SyncCommitteeCache, SyncCommitteeCacheEmpty} from "./cache/syncCommitteeCache.js";
 export * from "./constants/index.js";
 export type {EpochTransitionStep} from "./epoch/index.js";
 export {type BeaconStateTransitionMetrics, getMetrics} from "./metrics.js";
 export * from "./rewards/index.js";
 export * from "./signatureSets/index.js";
 export * from "./stateTransition.js";
-export * from "./stateView/index.js";
+export {BeaconStateView} from "./stateView/beaconStateView.js";
+export {
+  type IBeaconStateView,
+  type IBeaconStateViewAltair,
+  type IBeaconStateViewBellatrix,
+  type IBeaconStateViewCapella,
+  type IBeaconStateViewDeneb,
+  type IBeaconStateViewElectra,
+  type IBeaconStateViewFulu,
+  type IBeaconStateViewGloas,
+  isStatePostAltair,
+  isStatePostBellatrix,
+  isStatePostCapella,
+  isStatePostDeneb,
+  isStatePostElectra,
+  isStatePostFulu,
+  isStatePostGloas,
+} from "./stateView/interface.js";
+export {createBeaconStateView, createBeaconStateViewForHistoricalRegen} from "./stateView/stateViewFactory.js";
 export type {
   BeaconStateAllForks,
   BeaconStateAltair,

package/src/signatureSets/executionPayloadEnvelope.ts

@@ -3,7 +3,7 @@ import {BeaconConfig} from "@lodestar/config";
 import {BUILDER_INDEX_SELF_BUILD, DOMAIN_BEACON_BUILDER} from "@lodestar/params";
 import {ValidatorIndex, gloas, ssz} from "@lodestar/types";
 import {PubkeyCache} from "../cache/pubkeyCache.js";
-import {IBeaconStateView} from "../stateView/interface.js";
+import {IBeaconStateView, isStatePostGloas} from "../stateView/interface.js";
 import {computeSigningRoot} from "../util/index.js";
 import {type SingleSignatureSet, createSingleSignatureSetFromComponents} from "../util/signatureSets.js";
 
@@ -11,7 +11,7 @@ export function getExecutionPayloadEnvelopeSigningRoot(
   config: BeaconConfig,
   envelope: gloas.ExecutionPayloadEnvelope
 ): Uint8Array {
-  const domain = config.getDomain(envelope.slot, DOMAIN_BEACON_BUILDER);
+  const domain = config.getDomain(envelope.payload.slotNumber, DOMAIN_BEACON_BUILDER);
 
   return computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, envelope, domain);
 }
@@ -23,6 +23,10 @@ export function getExecutionPayloadEnvelopeSignatureSet(
   signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
   proposerIndex: ValidatorIndex
 ): SingleSignatureSet {
+  if (!isStatePostGloas(state)) {
+    throw new Error(`Expected gloas+ state for execution payload envelope signature, got fork=${state.forkName}`);
+  }
+
   const envelope = signedEnvelope.message;
   const pubkey =
     envelope.builderIndex === BUILDER_INDEX_SELF_BUILD

package/src/signatureSets/index.ts

@@ -20,6 +20,7 @@ export * from "./executionPayloadEnvelope.js";
 export * from "./indexedAttestation.js";
 export * from "./indexedPayloadAttestation.js";
 export * from "./proposer.js";
+export * from "./proposerPreferences.js";
 export * from "./proposerSlashings.js";
 export * from "./randao.js";
 export * from "./voluntaryExits.js";

package/src/signatureSets/proposerPreferences.ts

@@ -0,0 +1,12 @@
+import {BeaconConfig} from "@lodestar/config";
+import {DOMAIN_PROPOSER_PREFERENCES} from "@lodestar/params";
+import {gloas, ssz} from "@lodestar/types";
+import {computeSigningRoot} from "../util/index.js";
+
+export function getProposerPreferencesSigningRoot(
+  config: BeaconConfig,
+  preferences: gloas.ProposerPreferences
+): Uint8Array {
+  const domain = config.getDomain(preferences.proposalSlot, DOMAIN_PROPOSER_PREFERENCES);
+  return computeSigningRoot(ssz.gloas.ProposerPreferences, preferences, domain);
+}

package/src/signatureSets/voluntaryExits.ts

@@ -3,7 +3,7 @@ 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 {IBeaconStateView, IBeaconStateViewGloas, isStatePostGloas} from "../stateView/interface.js";
 import {
   ISignatureSet,
   SignatureSetType,
@@ -34,6 +34,9 @@ export function getVoluntaryExitSignatureSet(
   const fork = config.getForkSeq(state.slot);
 
   if (fork >= ForkSeq.gloas && isBuilderVoluntaryExit(signedVoluntaryExit)) {
+    if (!isStatePostGloas(state)) {
+      throw new Error(`Expected gloas+ state for builder voluntary exit signature, got fork=${state.forkName}`);
+    }
     return getBuilderVoluntaryExitSignatureSet(config, state, signedVoluntaryExit);
   }
 
@@ -68,7 +71,7 @@ export function getValidatorVoluntaryExitSignatureSet(
 
 export function getBuilderVoluntaryExitSignatureSet(
   config: BeaconConfig,
-  state: IBeaconStateView,
+  state: IBeaconStateViewGloas,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
   const messageSlot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);

package/src/slot/upgradeStateToGloas.ts

@@ -5,7 +5,7 @@ import {isValidDepositSignature} from "../block/processDeposit.js";
 import {applyDepositForBuilder} from "../block/processDepositRequest.js";
 import {getCachedBeaconState} from "../cache/stateCache.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
-import {isBuilderWithdrawalCredential} from "../util/gloas.js";
+import {initializePtcWindow, isBuilderWithdrawalCredential} from "../util/gloas.js";
 import {isValidatorKnown} from "../util/index.js";
 
 /**
@@ -48,6 +48,9 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
   stateGloasView.currentSyncCommittee = stateGloasCloned.currentSyncCommittee;
   stateGloasView.nextSyncCommittee = stateGloasCloned.nextSyncCommittee;
   stateGloasView.latestExecutionPayloadBid.blockHash = stateFulu.latestExecutionPayloadHeader.blockHash;
+  stateGloasView.latestExecutionPayloadBid.executionRequestsRoot = ssz.electra.ExecutionRequests.hashTreeRoot(
+    ssz.electra.ExecutionRequests.defaultValue()
+  );
   stateGloasView.nextWithdrawalIndex = stateGloasCloned.nextWithdrawalIndex;
   stateGloasView.nextWithdrawalValidatorIndex = stateGloasCloned.nextWithdrawalValidatorIndex;
   stateGloasView.historicalSummaries = stateGloasCloned.historicalSummaries;
@@ -61,6 +64,7 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
   stateGloasView.pendingPartialWithdrawals = stateGloasCloned.pendingPartialWithdrawals;
   stateGloasView.pendingConsolidations = stateGloasCloned.pendingConsolidations;
   stateGloasView.proposerLookahead = stateGloasCloned.proposerLookahead;
+  stateGloasView.ptcWindow = ssz.gloas.PtcWindow.toViewDU(initializePtcWindow(stateFulu));
 
   for (let i = 0; i < SLOTS_PER_HISTORICAL_ROOT; i++) {
     stateGloasView.executionPayloadAvailability.set(i, true);

package/src/stateTransition.ts

@@ -76,7 +76,6 @@ export enum StateHashTreeRootSource {
   prepareNextEpoch = "prepare_next_epoch",
   regenState = "regen_state",
   computeNewStateRoot = "compute_new_state_root",
-  computeEnvelopeStateRoot = "compute_envelope_state_root",
 }
 
 /**
@@ -283,7 +282,7 @@ function processSlotsWithTransientCache(
       {
         const timer = metrics?.epochTransitionStepTime.startTimer({step: EpochTransitionStep.finalProcessEpoch});
         // last step to prepare epoch data that depends on the upgraded state, for example proposerLookahead of BeaconStateFulu
-        postState.epochCtx.finalProcessEpoch(postState);
+        postState.epochCtx.finalProcessEpoch(postState, epochTransitionCache);
         timer?.();
       }
 

package/src/stateView/beaconStateView.ts

@@ -1,7 +1,7 @@
 import {CompactMultiProof, ProofType, Tree, createProof} from "@chainsafe/persistent-merkle-tree";
 import {BitArray, ByteViews} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
-import {ForkSeq, SLOTS_PER_HISTORICAL_ROOT, isForkPostGloas} from "@lodestar/params";
+import {ForkName, ForkSeq, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {
   BeaconBlock,
   BeaconState,
@@ -28,8 +28,7 @@ import {
   rewards,
 } from "@lodestar/types";
 import {Checkpoint, Fork} from "@lodestar/types/phase0";
-import {processExecutionPayloadEnvelope} from "../block/index.js";
-import {ProcessExecutionPayloadEnvelopeOpts} from "../block/processExecutionPayloadEnvelope.js";
+import {applyParentExecutionPayload} from "../block/processParentExecutionPayload.js";
 import {VoluntaryExitValidity, getVoluntaryExitValidity} from "../block/processVoluntaryExit.js";
 import {getExpectedWithdrawals} from "../block/processWithdrawals.js";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
@@ -59,14 +58,19 @@ import {getBlockRootAtSlot} from "../util/blockRoot.js";
 import {computeAnchorCheckpoint} from "../util/computeAnchorCheckpoint.js";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "../util/epoch.js";
 import {EpochShuffling} from "../util/epochShuffling.js";
-import {isExecutionEnabled, isExecutionStateType, isMergeTransitionComplete} from "../util/execution.js";
+import {
+  isExecutionEnabled,
+  isExecutionStateType,
+  isGloasStateType,
+  isMergeTransitionComplete,
+} from "../util/execution.js";
 import {canBuilderCoverBid} from "../util/gloas.js";
 import {loadState} from "../util/loadState/loadState.js";
 import {getRandaoMix} from "../util/seed.js";
 import {getLatestWeakSubjectivityCheckpointEpoch} from "../util/weakSubjectivity.js";
-import {IBeaconStateView} from "./interface.js";
+import {IBeaconStateView, IBeaconStateViewGloas, IBeaconStateViewLatestFork, isStatePostGloas} from "./interface.js";
 
-export class BeaconStateView implements IBeaconStateView {
+export class BeaconStateView implements IBeaconStateViewLatestFork {
   private readonly config: BeaconConfig;
   // Cached values extracted from the tree
   // phase0
@@ -79,8 +83,6 @@ export class BeaconStateView implements IBeaconStateView {
   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
@@ -92,6 +94,7 @@ export class BeaconStateView implements IBeaconStateView {
   // gloas
   private _executionPayloadAvailability: BitArray | null = null;
   private _latestExecutionPayloadBid: ExecutionPayloadBid | null = null;
+  private _payloadExpectedWithdrawals: capella.Withdrawal[] | null = null;
 
   constructor(readonly cachedState: CachedBeaconStateAllForks) {
     this.config = cachedState.config;
@@ -99,6 +102,10 @@ export class BeaconStateView implements IBeaconStateView {
 
   // phase0
 
+  get forkName(): ForkName {
+    return this.config.getForkName(this.cachedState.slot);
+  }
+
   get slot(): number {
     return this.cachedState.slot;
   }
@@ -208,9 +215,13 @@ export class BeaconStateView implements IBeaconStateView {
   // bellatrix
 
   get latestExecutionPayloadHeader(): ExecutionPayloadHeader {
-    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.bellatrix) {
+    const forkSeq = this.config.getForkSeq(this.cachedState.slot);
+    if (forkSeq < ForkSeq.bellatrix) {
       throw new Error("latestExecutionPayloadHeader is not available before Bellatrix");
     }
+    if (forkSeq >= ForkSeq.gloas) {
+      throw new Error("latestExecutionPayloadHeader is not available after Gloas");
+    }
 
     if (this._latestExecutionPayloadHeader === null) {
       this._latestExecutionPayloadHeader = (
@@ -221,30 +232,6 @@ 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.
@@ -355,9 +342,16 @@ export class BeaconStateView implements IBeaconStateView {
 
   // gloas
 
+  get latestBlockHash(): Bytes32 {
+    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
+      throw new Error("latestBlockHash is not available before Gloas");
+    }
+    return (this.cachedState as CachedBeaconStateGloas).latestBlockHash;
+  }
+
   get executionPayloadAvailability(): BitArray {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
-      throw new Error("executionPayloadAvailability is not available before GLOAS");
+      throw new Error("executionPayloadAvailability is not available before Gloas");
     }
 
     if (this._executionPayloadAvailability === null) {
@@ -371,7 +365,7 @@ export class BeaconStateView implements IBeaconStateView {
 
   get latestExecutionPayloadBid(): ExecutionPayloadBid {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
-      throw new Error("latestExecutionPayloadBid is not available before GLOAS");
+      throw new Error("latestExecutionPayloadBid is not available before Gloas");
     }
 
     if (this._latestExecutionPayloadBid === null) {
@@ -382,9 +376,22 @@ export class BeaconStateView implements IBeaconStateView {
     return this._latestExecutionPayloadBid;
   }
 
+  get payloadExpectedWithdrawals(): capella.Withdrawal[] {
+    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
+      throw new Error("payloadExpectedWithdrawals is not available before Gloas");
+    }
+
+    if (this._payloadExpectedWithdrawals === null) {
+      this._payloadExpectedWithdrawals = (
+        this.cachedState as CachedBeaconStateGloas
+      ).payloadExpectedWithdrawals.toValue();
+    }
+    return this._payloadExpectedWithdrawals;
+  }
+
   getBuilder(index: BuilderIndex): gloas.Builder {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
-      throw new Error("Builders are not supported before GLOAS");
+      throw new Error("Builders are not supported before Gloas");
     }
 
     return (this.cachedState as CachedBeaconStateGloas).builders.getReadonly(index);
@@ -392,19 +399,36 @@ export class BeaconStateView implements IBeaconStateView {
 
   canBuilderCoverBid(builderIndex: BuilderIndex, bidAmount: number): boolean {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
-      throw new Error("Builders are not supported before GLOAS");
+      throw new Error("Builders are not supported before Gloas");
     }
 
     return canBuilderCoverBid(this.cachedState as CachedBeaconStateGloas, builderIndex, bidAmount);
   }
 
+  /**
+   * Return the PTCs for an epoch
+   */
+  getEpochPTCs(epoch: Epoch): Uint32Array[] {
+    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
+      throw new Error("PTC committees are not supported before Gloas");
+    }
+
+    const epochCtx = (this.cachedState as CachedBeaconStateGloas).epochCtx;
+    if (epoch === epochCtx.epoch) {
+      return epochCtx.payloadTimelinessCommittees;
+    }
+    if (epoch === epochCtx.nextEpoch) {
+      return epochCtx.nextPayloadTimelinessCommittees;
+    }
+    throw new Error(`PTC committees are not available for epoch=${epoch}`);
+  }
   /**
    * Return the index of the validator in the PTC committee for the given slot.
    * return -1 if validator is not in the PTC committee for the given slot.
    */
   getIndexInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
-      throw new Error("PTC committees are not supported before GLOAS");
+      throw new Error("PTC committees are not supported before Gloas");
     }
 
     const ptcCommittee = (this.cachedState as CachedBeaconStateGloas).epochCtx.getPayloadTimelinessCommittee(slot);
@@ -571,7 +595,10 @@ export class BeaconStateView implements IBeaconStateView {
   }
 
   get isMergeTransitionComplete(): boolean {
-    return isExecutionStateType(this.cachedState) && isMergeTransitionComplete(this.cachedState);
+    return (
+      (isExecutionStateType(this.cachedState) || isGloasStateType(this.cachedState)) &&
+      isMergeTransitionComplete(this.cachedState)
+    );
   }
 
   // Block production
@@ -693,7 +720,11 @@ export class BeaconStateView implements IBeaconStateView {
 
   // Serialization
 
-  loadOtherState(stateBytes: Uint8Array, seedValidatorsBytes?: Uint8Array): IBeaconStateView {
+  loadOtherState(
+    stateBytes: Uint8Array,
+    seedValidatorsBytes?: Uint8Array,
+    opts?: {preloadValidatorsAndBalances?: boolean}
+  ): IBeaconStateView {
     const {state} = loadState(this.config, this.cachedState, stateBytes, seedValidatorsBytes);
 
     const cachedState = createCachedBeaconState(
@@ -708,9 +739,10 @@ export class BeaconStateView implements IBeaconStateView {
       }
     );
 
-    // load all cache in order for consumers (usually regen.getState()) to process blocks faster
-    cachedState.validators.getAllReadonlyValues();
-    cachedState.balances.getAll();
+    if (opts?.preloadValidatorsAndBalances) {
+      cachedState.validators.getAllReadonlyValues();
+      cachedState.balances.getAll();
+    }
 
     return new BeaconStateView(cachedState);
   }
@@ -768,19 +800,22 @@ export class BeaconStateView implements IBeaconStateView {
     return new BeaconStateView(newState);
   }
 
-  processExecutionPayloadEnvelope(
-    signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
-    opts?: ProcessExecutionPayloadEnvelopeOpts
-  ): BeaconStateView {
-    const fork = this.config.getForkName(this.cachedState.slot);
-    if (!isForkPostGloas(fork)) {
-      throw Error(`processExecutionPayloadEnvelope is only available for gloas+ forks, got fork=${fork}`);
+  /**
+   * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/validator.md#executionpayload
+   */
+  withParentPayloadApplied(executionRequests: electra.ExecutionRequests): IBeaconStateViewGloas {
+    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
+      throw new Error("withParentPayloadApplied is not available before Gloas");
     }
-    const postPayloadState = processExecutionPayloadEnvelope(
-      this.cachedState as CachedBeaconStateGloas,
-      signedEnvelope,
-      opts
-    );
-    return new BeaconStateView(postPayloadState);
+    const stateCopy = this.cachedState.clone(true) as CachedBeaconStateGloas;
+
+    applyParentExecutionPayload(stateCopy, executionRequests);
+
+    const stateView = new BeaconStateView(stateCopy);
+    if (!isStatePostGloas(stateView)) {
+      throw new Error("Expected gloas state after clone");
+    }
+
+    return stateView;
   }
 }