@lodestar/state-transition 1.41.0-dev.be5acbb8f7 → 1.41.0-dev.c11b797bd6

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/util/seed.ts

@@ -417,8 +417,6 @@ export function naiveComputePayloadTimelinessCommitteeIndices(
  * https://link.springer.com/content/pdf/10.1007%2F978-3-642-32009-5_1.pdf
  *
  * See the 'generalized domain' algorithm on page 3.
- * This is the naive implementation just to make sure lodestar follows the spec, this is not for production.
- * The optimized version is in `getComputeShuffledIndexFn`.
  */
 export function computeShuffledIndex(index: number, indexCount: number, seed: Bytes32): number {
   let permuted = index;
@@ -439,75 +437,6 @@ export function computeShuffledIndex(index: number, indexCount: number, seed: By
   return permuted;
 }
 
-type ComputeShuffledIndexFn = (index: number) => number;
-
-/**
- * An optimized version of `computeShuffledIndex`, this is for production.
- */
-export function getComputeShuffledIndexFn(indexCount: number, seed: Bytes32): ComputeShuffledIndexFn {
-  // there are possibly SHUFFLE_ROUND_COUNT (90 for mainnet) values for this cache
-  // this cache will always hit after the 1st call
-  const pivotByIndex: Map<number, number> = new Map();
-  // given 2M active validators, there are 2 M / 256 = 8k possible positionDiv
-  // it means there are at most 8k different sources for each round
-  const sourceByPositionDivByIndex: Map<number, Map<number, Uint8Array>> = new Map();
-  // 32 bytes seed + 1 byte i
-  const pivotBuffer = Buffer.alloc(32 + 1);
-  pivotBuffer.set(seed, 0);
-  // 32 bytes seed + 1 byte i + 4 bytes positionDiv
-  const sourceBuffer = Buffer.alloc(32 + 1 + 4);
-  sourceBuffer.set(seed, 0);
-
-  return (index): number => {
-    assert.lt(index, indexCount, "indexCount must be less than index");
-    assert.lte(indexCount, 2 ** 40, "indexCount too big");
-    let permuted = index;
-    // const _seed = seed;
-    for (let i = 0; i < SHUFFLE_ROUND_COUNT; i++) {
-      // optimized version of the below naive code
-      // const pivot = Number(
-      //   bytesToBigInt(digest(Buffer.concat([_seed, intToBytes(i, 1)])).slice(0, 8)) % BigInt(indexCount)
-      // );
-
-      let pivot = pivotByIndex.get(i);
-      if (pivot == null) {
-        // naive version always creates a new buffer, we can reuse the buffer
-        // pivot = Number(
-        //   bytesToBigInt(digest(Buffer.concat([_seed, intToBytes(i, 1)])).slice(0, 8)) % BigInt(indexCount)
-        // );
-        pivotBuffer[32] = i % 256;
-        pivot = Number(bytesToBigInt(digest(pivotBuffer).subarray(0, 8)) % BigInt(indexCount));
-        pivotByIndex.set(i, pivot);
-      }
-
-      const flip = (pivot + indexCount - permuted) % indexCount;
-      const position = Math.max(permuted, flip);
-
-      // optimized version of the below naive code
-      // const source = digest(Buffer.concat([_seed, intToBytes(i, 1), intToBytes(Math.floor(position / 256), 4)]));
-      let sourceByPositionDiv = sourceByPositionDivByIndex.get(i);
-      if (sourceByPositionDiv == null) {
-        sourceByPositionDiv = new Map<number, Uint8Array>();
-        sourceByPositionDivByIndex.set(i, sourceByPositionDiv);
-      }
-      const positionDiv256 = Math.floor(position / 256);
-      let source = sourceByPositionDiv.get(positionDiv256);
-      if (source == null) {
-        // naive version always creates a new buffer, we can reuse the buffer
-        // don't want to go through intToBytes() to avoid BigInt
-        sourceBuffer[32] = i % 256;
-        sourceBuffer.writeUint32LE(positionDiv256, 33);
-        source = digest(sourceBuffer);
-        sourceByPositionDiv.set(positionDiv256, source);
-      }
-      const byte = source[Math.floor((position % 256) / 8)];
-      const bit = (byte >> (position % 8)) % 2;
-      permuted = bit ? flip : permuted;
-    }
-    return permuted;
-  };
-}
-
 /**
  * Return the randao mix at a recent [[epoch]].
  */