@lodestar/state-transition 1.41.0-dev.702f7932c2 → 1.41.0-dev.988363dff3

package/src/cache/epochCache.ts

@@ -36,6 +36,7 @@ import {
 import {
   computeActivationExitEpoch,
   computeEpochAtSlot,
+  computePayloadTimelinessCommitteesForEpoch,
   computeProposers,
   computeSyncPeriodAtEpoch,
   getActivationChurnLimit,
@@ -43,7 +44,6 @@ import {
   getSeed,
   isActiveValidator,
   isAggregatorFromCommitteeLength,
-  naiveGetPayloadTimlinessCommitteeIndices,
 } from "../util/index.js";
 import {
   AttesterDuty,
@@ -64,7 +64,7 @@ import {
   computeSyncCommitteeCache,
   getSyncCommitteeCache,
 } from "./syncCommitteeCache.js";
-import {BeaconStateAllForks, BeaconStateAltair, BeaconStateGloas, ShufflingGetter} from "./types.js";
+import {BeaconStateAllForks, BeaconStateAltair, ShufflingGetter} from "./types.js";
 
 /** `= PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT)` */
 export const PROPOSER_WEIGHT_FACTOR = PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT);
@@ -235,8 +235,8 @@ export class EpochCache {
   nextSyncCommitteeIndexed: SyncCommitteeCache;
 
   // TODO GLOAS: See if we need to cached PTC for prev/next epoch
-  // PTC for current epoch
-  payloadTimelinessCommittee: ValidatorIndex[][];
+  // PTC for current epoch, computed eagerly at epoch transition
+  payloadTimelinessCommittees: Uint32Array[];
 
   // TODO: Helper stats
   syncPeriod: SyncPeriod;
@@ -275,7 +275,7 @@ export class EpochCache {
     previousTargetUnslashedBalanceIncrements: number;
     currentSyncCommitteeIndexed: SyncCommitteeCache;
     nextSyncCommitteeIndexed: SyncCommitteeCache;
-    payloadTimelinessCommittee: ValidatorIndex[][];
+    payloadTimelinessCommittees: Uint32Array[];
     epoch: Epoch;
     syncPeriod: SyncPeriod;
   }) {
@@ -306,7 +306,7 @@ export class EpochCache {
     this.previousTargetUnslashedBalanceIncrements = data.previousTargetUnslashedBalanceIncrements;
     this.currentSyncCommitteeIndexed = data.currentSyncCommitteeIndexed;
     this.nextSyncCommitteeIndexed = data.nextSyncCommitteeIndexed;
-    this.payloadTimelinessCommittee = data.payloadTimelinessCommittee;
+    this.payloadTimelinessCommittees = data.payloadTimelinessCommittees;
     this.epoch = data.epoch;
     this.syncPeriod = data.syncPeriod;
   }
@@ -457,14 +457,14 @@ export class EpochCache {
       nextSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
     }
 
-    // Compute PTC for this epoch
-    let payloadTimelinessCommittee: ValidatorIndex[][] = [];
+    // Compute PTC eagerly for all slots in the epoch
+    let payloadTimelinessCommittees: Uint32Array[] = [];
     if (currentEpoch >= config.GLOAS_FORK_EPOCH) {
-      payloadTimelinessCommittee = naiveGetPayloadTimlinessCommitteeIndices(
-        state as BeaconStateGloas,
-        currentShuffling,
-        effectiveBalanceIncrements,
-        currentEpoch
+      payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+        state,
+        currentEpoch,
+        currentShuffling.committees,
+        effectiveBalanceIncrements
       );
     }
 
@@ -541,7 +541,7 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed,
-      payloadTimelinessCommittee: payloadTimelinessCommittee,
+      payloadTimelinessCommittees,
       epoch: currentEpoch,
       syncPeriod: computeSyncPeriodAtEpoch(currentEpoch),
     });
@@ -587,7 +587,7 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements: this.currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed: this.currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed: this.nextSyncCommitteeIndexed,
-      payloadTimelinessCommittee: this.payloadTimelinessCommittee,
+      payloadTimelinessCommittees: this.payloadTimelinessCommittees,
       epoch: this.epoch,
       syncPeriod: this.syncPeriod,
     });
@@ -698,11 +698,11 @@ export class EpochCache {
 
     this.proposersPrevEpoch = this.proposers;
     if (upcomingEpoch >= this.config.GLOAS_FORK_EPOCH) {
-      this.payloadTimelinessCommittee = naiveGetPayloadTimlinessCommitteeIndices(
-        state as BeaconStateGloas,
-        this.currentShuffling,
-        this.effectiveBalanceIncrements,
-        upcomingEpoch
+      this.payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+        state,
+        upcomingEpoch,
+        this.currentShuffling.committees,
+        this.effectiveBalanceIncrements
       );
     }
     if (upcomingEpoch >= this.config.FULU_FORK_EPOCH) {
@@ -1022,18 +1022,18 @@ export class EpochCache {
     return this.epoch >= this.config.ELECTRA_FORK_EPOCH;
   }
 
-  getPayloadTimelinessCommittee(slot: Slot): ValidatorIndex[] {
+  getPayloadTimelinessCommittee(slot: Slot): Uint32Array {
     const epoch = computeEpochAtSlot(slot);
 
     if (epoch < this.config.GLOAS_FORK_EPOCH) {
       throw new Error("Payload Timeliness Committee is not available before gloas fork");
     }
 
-    if (epoch === this.epoch) {
-      return this.payloadTimelinessCommittee[slot % SLOTS_PER_EPOCH];
+    if (epoch !== this.epoch) {
+      throw new Error(`Payload Timeliness Committee is not available for slot=${slot}`);
     }
 
-    throw new Error(`Payload Timeliness Committee is not available for slot=${slot}`);
+    return this.payloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
   }
 
   getIndexedPayloadAttestation(

package/src/signatureSets/indexedPayloadAttestation.ts

@@ -1,26 +1,24 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_PTC_ATTESTER} from "@lodestar/params";
-import {Slot, gloas, ssz} from "@lodestar/types";
-import {CachedBeaconStateGloas} from "../types.js";
+import {gloas, ssz} from "@lodestar/types";
 import {ISignatureSet, computeSigningRoot, createAggregateSignatureSetFromComponents} from "../util/index.js";
 
 export function getIndexedPayloadAttestationSignatureSet(
-  state: CachedBeaconStateGloas,
+  config: BeaconConfig,
   indexedPayloadAttestation: gloas.IndexedPayloadAttestation
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
     indexedPayloadAttestation.attestingIndices,
-    getPayloadAttestationDataSigningRoot(state.config, state.slot, indexedPayloadAttestation.data),
+    getPayloadAttestationDataSigningRoot(config, indexedPayloadAttestation.data),
     indexedPayloadAttestation.signature
   );
 }
 
 export function getPayloadAttestationDataSigningRoot(
   config: BeaconConfig,
-  stateSlot: Slot,
   data: gloas.PayloadAttestationData
 ): Uint8Array {
-  const domain = config.getDomain(stateSlot, DOMAIN_PTC_ATTESTER);
+  const domain = config.getDomain(data.slot, DOMAIN_PTC_ATTESTER);
 
   return computeSigningRoot(ssz.gloas.PayloadAttestationData, data, domain);
 }

package/src/slot/upgradeStateToGloas.ts

@@ -1,7 +1,12 @@
 import {SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
+import {toHex} from "@lodestar/utils";
+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 {isValidatorKnown} from "../util/index.js";
 
 /**
  * Upgrade a state from Fulu to Gloas.
@@ -64,6 +69,9 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
 
   const stateGloas = getCachedBeaconState(stateGloasView, stateFulu);
 
+  // Process pending builder deposits at the fork boundary
+  onboardBuildersFromPendingDeposits(stateGloas);
+
   stateGloas.commit();
   // Clear cache to ensure the cache of fulu fields is not used by new gloas fields
   // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
@@ -71,3 +79,69 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
 
   return stateGloas;
 }
+
+/**
+ * Applies any pending deposits for builders to onboard builders during the fork transition
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.2/specs/gloas/fork.md#new-onboard_builders_from_pending_deposits
+ */
+function onboardBuildersFromPendingDeposits(state: CachedBeaconStateGloas): void {
+  // Track pubkeys of new validators to keep their deposits pending
+  const validatorPubkeys = new Set<string>();
+
+  // Track pubkeys of new builders added when applying deposits
+  const builderPubkeys = new Set<string>();
+
+  const remainingPendingDeposits = ssz.electra.PendingDeposits.defaultViewDU();
+  for (let i = 0; i < state.pendingDeposits.length; i++) {
+    const deposit = state.pendingDeposits.getReadonly(i);
+
+    const validatorIndex = state.epochCtx.getValidatorIndex(deposit.pubkey);
+    const pubkeyHex = toHex(deposit.pubkey);
+
+    // Deposits for existing validators stay in pending queue
+    if (isValidatorKnown(state, validatorIndex) || validatorPubkeys.has(pubkeyHex)) {
+      remainingPendingDeposits.push(deposit);
+      continue;
+    }
+
+    // If the pubkey is associated with a builder that was created in a previous iteration
+    // or it is a builder deposit, try to apply the deposit to the new/existing builder
+    const isExistingBuilder = builderPubkeys.has(pubkeyHex);
+    const hasBuilderCredentials = isBuilderWithdrawalCredential(deposit.withdrawalCredentials);
+    if (isExistingBuilder || hasBuilderCredentials) {
+      const buildersLenBefore = state.builders.length;
+      applyDepositForBuilder(
+        state,
+        deposit.pubkey,
+        deposit.withdrawalCredentials,
+        deposit.amount,
+        deposit.signature,
+        deposit.slot
+      );
+      // Track newly added builders for subsequent iterations
+      if (!isExistingBuilder && state.builders.length > buildersLenBefore) {
+        builderPubkeys.add(pubkeyHex);
+      }
+      continue;
+    }
+
+    // If there is a pending deposit for a new validator that has a valid signature, track the
+    // pubkey so that subsequent builder deposits for the same pubkey stay in pending (applied to
+    // the validator later) rather than creating a builder. Deposits with invalid signatures are
+    // dropped here since they would fail in apply_pending_deposit anyway.
+    if (
+      isValidDepositSignature(
+        state.config,
+        deposit.pubkey,
+        deposit.withdrawalCredentials,
+        deposit.amount,
+        deposit.signature
+      )
+    ) {
+      validatorPubkeys.add(pubkeyHex);
+      remainingPendingDeposits.push(deposit);
+    }
+  }
+
+  state.pendingDeposits = remainingPendingDeposits;
+}

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>,