@lodestar/state-transition 1.41.0-dev.702f7932c2 → 1.41.0-dev.95cf2edc4c

package/src/stateView/index.ts

@@ -0,0 +1,2 @@
+export * from "./beaconStateView.js";
+export * from "./interface.js";

package/src/stateView/interface.ts

@@ -0,0 +1,196 @@
+import {CompactMultiProof} from "@chainsafe/persistent-merkle-tree";
+import {ByteViews} from "@chainsafe/ssz";
+import {
+  BeaconBlock,
+  BlindedBeaconBlock,
+  BuilderIndex,
+  Bytes32,
+  Epoch,
+  ExecutionPayloadBid,
+  ExecutionPayloadHeader,
+  Root,
+  RootHex,
+  SignedBeaconBlock,
+  SignedBlindedBeaconBlock,
+  Slot,
+  ValidatorIndex,
+  altair,
+  capella,
+  electra,
+  fulu,
+  gloas,
+  phase0,
+  rewards,
+} from "@lodestar/types";
+import {Checkpoint, Fork} from "@lodestar/types/phase0";
+import {VoluntaryExitValidity} from "../block/processVoluntaryExit.js";
+import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
+import {EpochTransitionCacheOpts} from "../cache/epochTransitionCache.js";
+import {RewardCache} from "../cache/rewardCache.js";
+import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
+import {SyncCommitteeWitness} from "../lightClient/types.js";
+import {StateTransitionModules, StateTransitionOpts} from "../stateTransition.js";
+import {EpochShuffling} from "../util/epochShuffling.js";
+
+/**
+ * A read-only view of the BeaconState.
+ */
+export interface IBeaconStateView {
+  // State access
+
+  // phase0
+  slot: Slot;
+  fork: Fork;
+  epoch: Epoch;
+  genesisTime: number;
+  genesisValidatorsRoot: Root;
+  eth1Data: phase0.Eth1Data;
+  latestBlockHeader: phase0.BeaconBlockHeader;
+  previousJustifiedCheckpoint: Checkpoint;
+  currentJustifiedCheckpoint: Checkpoint;
+  finalizedCheckpoint: Checkpoint;
+  getBlockRootAtSlot(slot: Slot): Root;
+  getBlockRootAtEpoch(epoch: Epoch): Root;
+  getStateRootAtSlot(slot: Slot): Root;
+  getRandaoMix(epoch: Epoch): Bytes32;
+
+  // altair
+  previousEpochParticipation: number[];
+  currentEpochParticipation: number[];
+
+  // bellatrix
+  latestExecutionPayloadHeader: ExecutionPayloadHeader;
+
+  // capella
+  historicalSummaries: capella.HistoricalSummaries;
+
+  // electra
+  pendingDeposits: electra.PendingDeposits;
+  pendingDepositsCount: number;
+  pendingPartialWithdrawals: electra.PendingPartialWithdrawals;
+  pendingPartialWithdrawalsCount: number;
+  pendingConsolidations: electra.PendingConsolidations;
+  pendingConsolidationsCount: number;
+
+  // fulu
+  proposerLookahead: fulu.ProposerLookahead;
+
+  // gloas
+  executionPayloadAvailability: boolean[];
+  latestExecutionPayloadBid: ExecutionPayloadBid;
+  getBuilder(index: BuilderIndex): gloas.Builder;
+  canBuilderCoverBid(builderIndex: BuilderIndex, bidAmount: number): boolean;
+  validatorPTCCommitteeIndex(validatorIndex: ValidatorIndex, slot: Slot): number;
+
+  // Shuffling and committees
+  getShufflingAtEpoch(epoch: Epoch): EpochShuffling;
+  // Decision roots
+  previousDecisionRoot: RootHex;
+  currentDecisionRoot: RootHex;
+  nextDecisionRoot: RootHex;
+  getShufflingDecisionRoot(epoch: Epoch): RootHex;
+  getPreviousShuffling(): EpochShuffling;
+  getCurrentShuffling(): EpochShuffling;
+  getNextShuffling(): EpochShuffling;
+
+  // utils: proposers, anchor checkpoint
+  previousProposers: ValidatorIndex[] | null;
+  currentProposers: ValidatorIndex[];
+  nextProposers: ValidatorIndex[];
+  getBeaconProposer(slot: Slot): ValidatorIndex;
+  computeAnchorCheckpoint(): {checkpoint: phase0.Checkpoint; blockHeader: phase0.BeaconBlockHeader};
+
+  // Sync committees
+  currentSyncCommittee: altair.SyncCommittee;
+  nextSyncCommittee: altair.SyncCommittee;
+  currentSyncCommitteeIndexed: SyncCommitteeCache;
+  syncProposerReward: number;
+  getIndexedSyncCommitteeAtEpoch(epoch: Epoch): SyncCommitteeCache;
+
+  // Validators and balances
+  effectiveBalanceIncrements: EffectiveBalanceIncrements;
+  getEffectiveBalanceIncrementsZeroInactive(): EffectiveBalanceIncrements;
+  getBalance(index: number): number;
+  // readonly
+  getValidator(index: ValidatorIndex): phase0.Validator;
+  getValidatorsByStatus(statuses: Set<string>, currentEpoch: Epoch): phase0.Validator[];
+  validatorCount: number;
+  // this get number of active validators in the current shuffling
+  activeValidatorCount: number;
+  // this is needed for apis only
+  getAllValidators(): phase0.Validator[];
+  getAllBalances(): number[];
+
+  // Merge
+  isExecutionStateType: boolean;
+  isMergeTransitionComplete: boolean;
+  // TODO this should go away (or rather only need block)
+  isExecutionEnabled(block: BeaconBlock | BlindedBeaconBlock): boolean;
+
+  // Block production
+  getExpectedWithdrawals(): {
+    expectedWithdrawals: capella.Withdrawal[];
+    processedBuilderWithdrawalsCount: number;
+    processedPartialWithdrawalsCount: number;
+    processedValidatorSweepCount: number;
+  };
+
+  // API
+  proposerRewards: RewardCache;
+  computeBlockRewards(block: BeaconBlock, proposerRewards?: RewardCache): Promise<rewards.BlockRewards>;
+  computeAttestationsRewards(validatorIds?: (ValidatorIndex | string)[]): Promise<rewards.AttestationsRewards>;
+  computeSyncCommitteeRewards(
+    block: BeaconBlock,
+    validatorIds: (ValidatorIndex | string)[]
+  ): Promise<rewards.SyncCommitteeRewards>;
+  getLatestWeakSubjectivityCheckpointEpoch(): Epoch;
+
+  // Validation
+  getVoluntaryExitValidity(
+    signedVoluntaryExit: phase0.SignedVoluntaryExit,
+    verifySignature: boolean
+  ): VoluntaryExitValidity;
+  isValidVoluntaryExit(signedVoluntaryExit: phase0.SignedVoluntaryExit, verifySignature: boolean): boolean;
+
+  // Proofs
+  getFinalizedRootProof(): Uint8Array[];
+  getSyncCommitteesWitness(): SyncCommitteeWitness;
+  getSingleProof(gindex: bigint): Uint8Array[];
+  createMultiProof(descriptor: Uint8Array): CompactMultiProof;
+
+  // Fork choice
+  computeUnrealizedCheckpoints(): {
+    justifiedCheckpoint: phase0.Checkpoint;
+    finalizedCheckpoint: phase0.Checkpoint;
+  };
+
+  // this is for backward compatible
+  clonedCount: number;
+  clonedCountWithTransferCache: number;
+  createdWithTransferCache: boolean;
+  // TODO is there a better name that is less implementation specific but still conveys the meaning?
+  isStateValidatorsNodesPopulated(): boolean;
+
+  // Serialization
+  loadOtherState(stateBytes: Uint8Array, seedValidatorsBytes?: Uint8Array): IBeaconStateView;
+  serialize(): Uint8Array;
+  serializedSize(): number;
+  serializeToBytes(output: ByteViews, offset: number): number;
+  serializeValidators(): Uint8Array;
+  serializedValidatorsSize(): number;
+  serializeValidatorsToBytes(output: ByteViews, offset: number): number;
+
+  hashTreeRoot(): Uint8Array;
+
+  // State transition
+  stateTransition(
+    signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock,
+    options: StateTransitionOpts,
+    modules: StateTransitionModules
+  ): IBeaconStateView;
+  processSlots(
+    slot: Slot,
+    epochTransitionCacheOpts?: EpochTransitionCacheOpts & {dontTransferCache?: boolean},
+    modules?: StateTransitionModules
+  ): IBeaconStateView;
+}

package/src/util/gloas.ts

@@ -28,12 +28,18 @@ export function getBuilderPaymentQuorumThreshold(state: CachedBeaconStateGloas):
   return Math.floor(quorum / BUILDER_PAYMENT_THRESHOLD_DENOMINATOR);
 }
 
+function hasBuilderIndexFlag(index: number): boolean {
+  // Equivalent to `(index & BUILDER_INDEX_FLAG) != 0`
+  return Math.floor(index / BUILDER_INDEX_FLAG) % 2 === 1;
+}
+
 /**
  * Check if a validator index represents a builder (has the builder flag set).
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-is_builder_index
  */
 export function isBuilderIndex(validatorIndex: number): boolean {
-  return (validatorIndex & BUILDER_INDEX_FLAG) !== 0;
+  // Note: Can't use bitwise AND (&) because BUILDER_INDEX_FLAG exceeds 32 bits in JS bitwise operations.
+  return hasBuilderIndexFlag(validatorIndex);
 }
 
 /**
@@ -41,7 +47,8 @@ export function isBuilderIndex(validatorIndex: number): boolean {
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-convert_builder_index_to_validator_index
  */
 export function convertBuilderIndexToValidatorIndex(builderIndex: BuilderIndex): ValidatorIndex {
-  return builderIndex | BUILDER_INDEX_FLAG;
+  // Note: Can't use bitwise OR (|) because BUILDER_INDEX_FLAG exceeds 32 bits in JS bitwise operations.
+  return hasBuilderIndexFlag(builderIndex) ? builderIndex : builderIndex + BUILDER_INDEX_FLAG;
 }
 
 /**
@@ -49,7 +56,8 @@ export function convertBuilderIndexToValidatorIndex(builderIndex: BuilderIndex):
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-convert_validator_index_to_builder_index
  */
 export function convertValidatorIndexToBuilderIndex(validatorIndex: ValidatorIndex): BuilderIndex {
-  return validatorIndex & ~BUILDER_INDEX_FLAG;
+  // Note: Can't use bitwise AND (&) because BUILDER_INDEX_FLAG exceeds 32 bits in JS bitwise operations.
+  return hasBuilderIndexFlag(validatorIndex) ? validatorIndex - BUILDER_INDEX_FLAG : validatorIndex;
 }
 
 /**

package/src/util/seed.ts

@@ -21,7 +21,7 @@ import {
 import {Bytes32, DomainType, Epoch, ValidatorIndex} from "@lodestar/types";
 import {assert, bytesToBigInt, bytesToInt, intToBytes} from "@lodestar/utils";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
-import {BeaconStateAllForks, BeaconStateGloas, CachedBeaconStateAllForks} from "../types.js";
+import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
 
 /**
@@ -268,29 +268,117 @@ export function getNextSyncCommitteeIndices(
   );
 }
 
-export function naiveGetPayloadTimlinessCommitteeIndices(
-  state: BeaconStateGloas,
-  shuffling: {committees: Uint32Array[][]},
-  effectiveBalanceIncrements: EffectiveBalanceIncrements,
-  epoch: Epoch
-): ValidatorIndex[][] {
+/**
+ * Compute PTC for all slots in an epoch eagerly.
+ */
+export function computePayloadTimelinessCommitteesForEpoch(
+  state: BeaconStateAllForks,
+  epoch: number,
+  committees: Uint32Array[][],
+  effectiveBalanceIncrements: EffectiveBalanceIncrements
+): Uint32Array[] {
   const epochSeed = getSeed(state, epoch, DOMAIN_PTC_ATTESTER);
-  const startSlot = computeStartSlotAtEpoch(epoch);
-  const committeeIndices = [];
+  const startSlot = epoch * SLOTS_PER_EPOCH;
+  const result: Uint32Array[] = new Array(SLOTS_PER_EPOCH);
+
+  // Pre-allocate slot seed buffer once, reuse across all slots
+  const slotSeedInput = new Uint8Array(epochSeed.length + 8);
+  slotSeedInput.set(epochSeed, 0);
+  const slotSeedView = new DataView(slotSeedInput.buffer, slotSeedInput.byteOffset, slotSeedInput.byteLength);
+
+  for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
+    const slot = startSlot + i;
+    // Write slot as little-endian uint64 (fits in uint32 range)
+    slotSeedView.setUint32(epochSeed.length, slot, true);
+    slotSeedView.setUint32(epochSeed.length + 4, 0, true);
+    const slotSeed = digest(slotSeedInput);
+
+    result[i] = computePayloadTimelinessCommitteeForSlot(slotSeed, committees[i], effectiveBalanceIncrements);
+  }
+  return result;
+}
 
-  for (let slot = startSlot; slot < startSlot + SLOTS_PER_EPOCH; slot++) {
-    const slotCommittees = shuffling.committees[slot % SLOTS_PER_EPOCH];
-    const indices = naiveComputePayloadTimelinessCommitteeIndices(
-      effectiveBalanceIncrements,
-      slotCommittees.flatMap((c) => Array.from(c)),
-      digest(Buffer.concat([epochSeed, intToBytes(slot, 8)]))
-    );
-    committeeIndices.push(indices);
+/**
+ * Compute PTC for a single slot.
+ */
+export function computePayloadTimelinessCommitteeForSlot(
+  slotSeed: Uint8Array,
+  slotCommittees: Uint32Array[],
+  effectiveBalanceIncrements: EffectiveBalanceIncrements
+): Uint32Array {
+  // Concatenate all committee Uint32Arrays for this slot
+  const totalLen = slotCommittees.reduce((sum, c) => sum + c.length, 0);
+  const allIndices = new Uint32Array(totalLen);
+  let offset = 0;
+  for (const c of slotCommittees) {
+    allIndices.set(c, offset);
+    offset += c.length;
+  }
+  return computePayloadTimelinessCommitteeIndices(effectiveBalanceIncrements, allIndices, slotSeed);
+}
+
+/**
+ * Optimized version of PTC indices computation.
+ * Avoids BigInt conversions and uses DataView for efficient byte reading.
+ */
+export function computePayloadTimelinessCommitteeIndices(
+  effectiveBalanceIncrements: EffectiveBalanceIncrements,
+  indices: Uint32Array,
+  seed: Uint8Array
+): Uint32Array {
+  if (indices.length === 0) {
+    throw Error("Validator indices must not be empty");
   }
 
-  return committeeIndices;
+  const result = new Uint32Array(PTC_SIZE);
+  let resultLen = 0;
+
+  const MAX_RANDOM_VALUE = 0xffff; // 2^16 - 1
+  const MAX_EFFECTIVE_BALANCE_INCREMENT = MAX_EFFECTIVE_BALANCE_ELECTRA / EFFECTIVE_BALANCE_INCREMENT;
+  const indicesLen = indices.length;
+
+  // Pre-allocate hash input buffer: seed + 8 bytes for block index
+  const hashInput = new Uint8Array(seed.length + 8);
+  hashInput.set(seed, 0);
+  const hashInputView = new DataView(hashInput.buffer, hashInput.byteOffset, hashInput.byteLength);
+  const seedLen = seed.length;
+
+  let i = 0;
+  let randomBytesView: DataView = new DataView(new ArrayBuffer(0));
+  let lastBlock = -1;
+
+  while (resultLen < PTC_SIZE) {
+    const candidateIndex = indices[i % indicesLen];
+
+    // Only recompute hash every 16 iterations
+    const block = i >>> 4; // Math.floor(i / 16)
+    if (block !== lastBlock) {
+      // Write block as little-endian uint64 (block always fits in uint32 range)
+      hashInputView.setUint32(seedLen, block, true);
+      hashInputView.setUint32(seedLen + 4, 0, true);
+      const randomBytes = digest(hashInput);
+      randomBytesView = new DataView(randomBytes.buffer, randomBytes.byteOffset, randomBytes.byteLength);
+      lastBlock = block;
+    }
+
+    const randomValue = randomBytesView.getUint16((i & 15) * 2, true);
+
+    const effectiveBalanceIncrement = effectiveBalanceIncrements[candidateIndex];
+    if (effectiveBalanceIncrement * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_INCREMENT * randomValue) {
+      result[resultLen++] = candidateIndex;
+    }
+    i += 1;
+  }
+
+  return result;
 }
 
+/**
+ * Naive version of PTC indices computation.
+ * Used to verify the optimized `computePayloadTimelinessCommitteeIndices`.
+ *
+ * SLOW CODE - 🐢
+ */
 export function naiveComputePayloadTimelinessCommitteeIndices(
   effectiveBalanceIncrements: EffectiveBalanceIncrements,
   indices: ArrayLike<ValidatorIndex>,

package/src/util/signatureSets.ts

@@ -1,6 +1,6 @@
 import {PublicKey, Signature, aggregatePublicKeys, fastAggregateVerify, verify} from "@chainsafe/blst";
 import {Root} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 
 export enum SignatureSetType {
   single = "single",
@@ -49,18 +49,21 @@ export type ISignatureSet = SingleSignatureSet | IndexedSignatureSet | Aggregate
 
 /**
  * Get the pubkey for a signature set, performing aggregation if necessary.
- * Requires index2pubkey cache for indexed and aggregate sets.
+ * Requires pubkeyCache for indexed and aggregate sets.
  */
-export function getSignatureSetPubkey(signatureSet: ISignatureSet, index2pubkey: Index2PubkeyCache): PublicKey {
+export function getSignatureSetPubkey(signatureSet: ISignatureSet, pubkeyCache: PubkeyCache): PublicKey {
   switch (signatureSet.type) {
     case SignatureSetType.single:
       return signatureSet.pubkey;
 
-    case SignatureSetType.indexed:
-      return index2pubkey[signatureSet.index];
+    case SignatureSetType.indexed: {
+      return pubkeyCache.getOrThrow(signatureSet.index);
+    }
 
     case SignatureSetType.aggregate: {
-      const pubkeys = signatureSet.indices.map((i) => index2pubkey[i]);
+      const pubkeys = signatureSet.indices.map((i) => {
+        return pubkeyCache.getOrThrow(i);
+      });
       return aggregatePublicKeys(pubkeys);
     }
 
@@ -69,11 +72,11 @@ export function getSignatureSetPubkey(signatureSet: ISignatureSet, index2pubkey:
   }
 }
 
-export function verifySignatureSet(signatureSet: SingleSignatureSet, index2pubkey?: Index2PubkeyCache): boolean;
-export function verifySignatureSet(signatureSet: IndexedSignatureSet, index2pubkey: Index2PubkeyCache): boolean;
-export function verifySignatureSet(signatureSet: AggregatedSignatureSet, index2pubkey: Index2PubkeyCache): boolean;
-export function verifySignatureSet(signatureSet: ISignatureSet, index2pubkey: Index2PubkeyCache): boolean;
-export function verifySignatureSet(signatureSet: ISignatureSet, index2pubkey?: Index2PubkeyCache): boolean {
+export function verifySignatureSet(signatureSet: SingleSignatureSet, pubkeyCache?: PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: IndexedSignatureSet, pubkeyCache: PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: AggregatedSignatureSet, pubkeyCache: PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: ISignatureSet, pubkeyCache: PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: ISignatureSet, pubkeyCache?: PubkeyCache): boolean {
   // All signatures are not trusted and must be group checked (p2.subgroup_check)
   const signature = Signature.fromBytes(signatureSet.signature, true);
 
@@ -82,17 +85,20 @@ export function verifySignatureSet(signatureSet: ISignatureSet, index2pubkey?: I
       return verify(signatureSet.signingRoot, signatureSet.pubkey, signature);
 
     case SignatureSetType.indexed: {
-      if (!index2pubkey) {
-        throw Error("index2pubkey required for indexed signature set");
+      if (!pubkeyCache) {
+        throw Error("pubkeyCache required for indexed signature set");
       }
-      return verify(signatureSet.signingRoot, index2pubkey[signatureSet.index], signature);
+      const pubkey = pubkeyCache.getOrThrow(signatureSet.index);
+      return verify(signatureSet.signingRoot, pubkey, signature);
     }
 
     case SignatureSetType.aggregate: {
-      if (!index2pubkey) {
-        throw Error("index2pubkey required for aggregate signature set");
+      if (!pubkeyCache) {
+        throw Error("pubkeyCache required for aggregate signature set");
       }
-      const pubkeys = signatureSet.indices.map((i) => index2pubkey[i]);
+      const pubkeys = signatureSet.indices.map((i) => {
+        return pubkeyCache.getOrThrow(i);
+      });
       return fastAggregateVerify(signatureSet.signingRoot, pubkeys, signature);
     }
 

package/src/util/weakSubjectivity.ts

@@ -47,7 +47,7 @@ export function computeWeakSubjectivityPeriodCachedState(
   state: CachedBeaconStateAllForks
 ): number {
   const activeValidatorCount = state.epochCtx.currentShuffling.activeIndices.length;
-  const fork = state.config.getForkName(state.slot);
+  const fork = config.getForkName(state.slot);
 
   return isForkPostElectra(fork)
     ? computeWeakSubjectivityPeriodFromConstituentsElectra(