@lodestar/state-transition 1.43.0-dev.bc569affb9 → 1.43.0-dev.c5efeb6c90

package/src/stateView/beaconStateView.ts

@@ -68,7 +68,7 @@ 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, IBeaconStateViewLatestFork} from "./interface.js";
+import {IBeaconStateView, IBeaconStateViewGloas, IBeaconStateViewLatestFork, isStatePostGloas} from "./interface.js";
 
 export class BeaconStateView implements IBeaconStateViewLatestFork {
   private readonly config: BeaconConfig;
@@ -406,16 +406,44 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
   }
 
   /**
-   * 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.
+   * Return the PTCs for an epoch
    */
-  getIndexInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number {
+  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 all positions of the validator in the PTC committee for the given slot.
+   *
+   * `compute_ptc` samples by effective balance and may place the same validator at multiple
+   * positions, so a validator can have more than one index. Returns an empty array if the
+   * validator is not in the PTC for the given slot.
+   *
+   * Spec: gloas/fork-choice.md#new-on_payload_attestation_message
+   */
+  getIndicesInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number[] {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
       throw new Error("PTC committees are not supported before Gloas");
     }
 
     const ptcCommittee = (this.cachedState as CachedBeaconStateGloas).epochCtx.getPayloadTimelinessCommittee(slot);
-    return ptcCommittee.indexOf(validatorIndex);
+    const indices: number[] = [];
+    for (let i = 0; i < ptcCommittee.length; i++) {
+      if (ptcCommittee[i] === validatorIndex) {
+        indices.push(i);
+      }
+    }
+    return indices;
   }
 
   // Shuffling and committees
@@ -786,16 +814,19 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
   /**
    * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/validator.md#executionpayload
    */
-  getExpectedWithdrawalsForFullParent(executionRequests: electra.ExecutionRequests): capella.Withdrawal[] {
-    const fork = this.config.getForkSeq(this.cachedState.slot);
-    if (fork < ForkSeq.gloas) {
-      throw new Error("getExpectedWithdrawalsForFullParent is not available before Gloas");
+  withParentPayloadApplied(executionRequests: electra.ExecutionRequests): IBeaconStateViewGloas {
+    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
+      throw new Error("withParentPayloadApplied is not available before Gloas");
     }
-    // Make a copy of the state to avoid mutability issues
     const stateCopy = this.cachedState.clone(true) as CachedBeaconStateGloas;
-    // Apply parent payload before computing withdrawals
+
     applyParentExecutionPayload(stateCopy, executionRequests);
 
-    return getExpectedWithdrawals(fork, stateCopy).expectedWithdrawals;
+    const stateView = new BeaconStateView(stateCopy);
+    if (!isStatePostGloas(stateView)) {
+      throw new Error("Expected gloas state after clone");
+    }
+
+    return stateView;
   }
 }

package/src/stateView/interface.ts

@@ -252,13 +252,15 @@ export interface IBeaconStateViewGloas extends IBeaconStateViewFulu {
   payloadExpectedWithdrawals: capella.Withdrawal[];
   getBuilder(index: BuilderIndex): gloas.Builder;
   canBuilderCoverBid(builderIndex: BuilderIndex, bidAmount: number): boolean;
-  getIndexInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number;
+  getEpochPTCs(epoch: Epoch): Uint32Array[];
+  getIndicesInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number[];
   /**
-   * Compute expected withdrawals as if the parent was FULL.
-   * Clones the state, applies parent payload effects, then computes withdrawals.
-   * Used by prepare_execution_payload when building on FULL parent.
+   * Clone the state and apply parent execution payload effects.
+   * Used during block production and prepareNextSlot so that withdrawals and
+   * operation selection (e.g. voluntary exits) see the same post-apply state that the block
+   * processor will see at import.
    */
-  getExpectedWithdrawalsForFullParent(executionRequests: electra.ExecutionRequests): capella.Withdrawal[];
+  withParentPayloadApplied(executionRequests: electra.ExecutionRequests): IBeaconStateViewGloas;
 }
 
 /**

package/src/util/epoch.ts

@@ -1,7 +1,13 @@
-import {EPOCHS_PER_SYNC_COMMITTEE_PERIOD, GENESIS_EPOCH, MAX_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {
+  EPOCHS_PER_SYNC_COMMITTEE_PERIOD,
+  ForkSeq,
+  GENESIS_EPOCH,
+  MAX_SEED_LOOKAHEAD,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
 import {BeaconState, Epoch, Gwei, Slot, SyncPeriod} from "@lodestar/types";
 import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
-import {getActivationExitChurnLimit, getConsolidationChurnLimit} from "./validator.js";
+import {getActivationExitChurnLimit, getConsolidationChurnLimit, getExitChurnLimit} from "./validator.js";
 
 /**
  * Return the epoch number at the given slot.
@@ -45,8 +51,10 @@ export function computeExitEpochAndUpdateChurn(
   state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   exitBalance: Gwei
 ): number {
+  const fork = state.config.getForkSeq(state.slot);
   let earliestExitEpoch = Math.max(state.earliestExitEpoch, computeActivationExitEpoch(state.epochCtx.epoch));
-  const perEpochChurn = getActivationExitChurnLimit(state.epochCtx);
+  const perEpochChurn =
+    fork >= ForkSeq.gloas ? getExitChurnLimit(state.epochCtx) : getActivationExitChurnLimit(state.epochCtx);
 
   // New epoch for exits.
   let exitBalanceToConsume =
@@ -71,11 +79,12 @@ export function computeConsolidationEpochAndUpdateChurn(
   state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationBalance: Gwei
 ): number {
+  const fork = state.config.getForkSeq(state.slot);
   let earliestConsolidationEpoch = Math.max(
     state.earliestConsolidationEpoch,
     computeActivationExitEpoch(state.epochCtx.epoch)
   );
-  const perEpochConsolidationChurn = getConsolidationChurnLimit(state.epochCtx);
+  const perEpochConsolidationChurn = getConsolidationChurnLimit(fork, state.epochCtx);
 
   // New epoch for consolidations
   let consolidationBalanceToConsume =

package/src/util/gloas.ts

@@ -172,11 +172,6 @@ export function isAttestationSameSlotRootCache(rootCache: RootCache, data: Attes
   return isMatchingBlockRoot && isCurrentBlockRoot;
 }
 
-// TODO GLOAS: This function no longer exists in v1.7.0-alpha.5 specs. Remove it when appropriate to do so
-export function isParentBlockFull(state: CachedBeaconStateGloas): boolean {
-  return byteArrayEquals(state.latestExecutionPayloadBid.blockHash, state.latestBlockHash);
-}
-
 export function initializePtcWindow(state: CachedBeaconStateFulu): Uint32Array[] {
   const ptcWindow: Uint32Array[] = Array.from({length: SLOTS_PER_EPOCH}, () => new Uint32Array(PTC_SIZE));
   const currentEpoch = state.epochCtx.epoch;

package/src/util/index.ts

@@ -18,6 +18,7 @@ export * from "./genesis.js";
 export * from "./gloas.js";
 export * from "./interop.js";
 export * from "./loadState/index.js";
+export * from "./pendingDepositsLookup.js";
 export * from "./rootCache.js";
 export * from "./seed.js";
 export * from "./shuffling.js";

package/src/util/loadState/loadState.ts

@@ -110,8 +110,8 @@ function loadInactivityScores(
   seedState: BeaconStateAltair,
   inactivityScoresBytes: Uint8Array
 ): void {
-  // migratedState starts with the same inactivityScores to seed state
-  migratedState.inactivityScores = seedState.inactivityScores.clone();
+  // true = do not transfer cache
+  migratedState.inactivityScores = seedState.inactivityScores.clone(true);
   const oldValidator = migratedState.inactivityScores.length;
   // UintNum64 = 8 bytes
   const newValidator = inactivityScoresBytes.length / 8;
@@ -187,8 +187,8 @@ function loadValidators(
   const newValidatorCount = Math.floor(newValidatorsBytes.length / VALIDATOR_BYTES_SIZE);
   const isMoreValidator = newValidatorCount >= seedValidatorCount;
   const minValidatorCount = Math.min(seedValidatorCount, newValidatorCount);
-  // migrated state starts with the same validators to seed state
-  migratedState.validators = seedState.validators.clone();
+  // true = do not transfer cache
+  migratedState.validators = seedState.validators.clone(true);
   // 80% of validators serialization time comes from memory allocation
   // seedStateValidatorsBytes is an optimization at beacon-node side to avoid memory allocation here
   const seedValidatorsBytes = seedStateValidatorsBytes ?? seedState.validators.serialize();

package/src/util/pendingDepositsLookup.ts

@@ -0,0 +1,105 @@
+import {BeaconConfig} from "@lodestar/config";
+import {PubkeyHex, electra} from "@lodestar/types";
+import {toPubkeyHex} from "@lodestar/utils";
+import {isValidDepositSignature} from "../block/processDeposit.js";
+import {CachedBeaconStateGloas} from "../types.js";
+
+type PendingDepositsValidation = {
+  hasValidSignature: boolean;
+  validatedCount: number;
+};
+
+/**
+ * Mutable lookup for the pending-deposit sequence used by builder-routing logic.
+ *
+ * This is to implement the spec's `is_pending_validator(pending_deposits, pubkey)` lazily:
+ * deposits are grouped by pubkey without verifying signatures, and BLS verification is
+ * deferred until a builder deposit needs to know whether the same pubkey already has a
+ * valid pending validator deposit.
+ *
+ * Call `add()` whenever a deposit is appended to the represented sequence. A cached `true`
+ * result short-circuits all subsequent checks for that pubkey; a cached `false` records
+ * how many deposits were already verified, so appending a new deposit only verifies the
+ * newly-appended tail rather than re-running BLS on previously-invalid entries.
+ */
+export class PendingDepositsLookup {
+  private constructor(
+    private readonly depositsByPubkey: Map<PubkeyHex, electra.PendingDeposit[]>,
+    private readonly validationCache: Map<PubkeyHex, PendingDepositsValidation>
+  ) {}
+
+  /** Build an empty lookup for a sequence that will be populated incrementally. */
+  static buildEmpty(): PendingDepositsLookup {
+    return new PendingDepositsLookup(new Map(), new Map());
+  }
+
+  /**
+   * Build a pubkey -> pending-deposits lookup from `state.pendingDeposits`.
+   * No BLS work is done here; signature verification happens lazily in `hasPendingValidator`.
+   */
+  static build(state: CachedBeaconStateGloas): PendingDepositsLookup {
+    const lookup = PendingDepositsLookup.buildEmpty();
+    for (const pendingDeposit of state.pendingDeposits.getAllReadonly()) {
+      lookup.add(pendingDeposit);
+    }
+    return lookup;
+  }
+
+  /**
+   * Append a pending deposit to the represented sequence.
+   * Pass `pubkeyHex` if the caller has already computed it.
+   */
+  add(pendingDeposit: electra.PendingDeposit, pubkeyHex?: PubkeyHex): void {
+    const key = pubkeyHex ?? toPubkeyHex(pendingDeposit.pubkey);
+    const existing = this.depositsByPubkey.get(key);
+    if (existing) {
+      existing.push(pendingDeposit);
+    } else {
+      this.depositsByPubkey.set(key, [pendingDeposit]);
+    }
+  }
+
+  /**
+   * Returns true if any pending deposit for `pubkeyHex` has a valid BLS deposit signature.
+   * Memoizes the result in `validationCache` so repeated checks for the same pubkey
+   * within a block only verify deposits that have not already been checked.
+   */
+  hasPendingValidator(config: BeaconConfig, pubkeyHex: PubkeyHex): boolean {
+    const validation = this.validationCache.get(pubkeyHex);
+    if (validation?.hasValidSignature === true) {
+      return true;
+    }
+
+    const deposits = this.depositsByPubkey.get(pubkeyHex);
+    if (deposits === undefined) {
+      return false;
+    }
+
+    // hasValidSignature is false or undefined; resume from the last validatedCount so
+    // previously-checked invalid deposits are not re-verified.
+    const startIndex = validation?.validatedCount ?? 0;
+    if (startIndex === deposits.length) {
+      // Nothing new to check; the cached false result still holds.
+      return false;
+    }
+
+    for (let i = startIndex; i < deposits.length; i++) {
+      const deposit = deposits[i];
+      if (
+        isValidDepositSignature(
+          config,
+          deposit.pubkey,
+          deposit.withdrawalCredentials,
+          deposit.amount,
+          deposit.signature
+        )
+      ) {
+        this.validationCache.set(pubkeyHex, {hasValidSignature: true, validatedCount: i + 1});
+        return true;
+      }
+    }
+
+    this.validationCache.set(pubkeyHex, {hasValidSignature: false, validatedCount: deposits.length});
+    return false;
+  }
+}

package/src/util/shuffling.ts

@@ -17,29 +17,31 @@ import {computeStartSlotAtEpoch} from "./epoch.js";
 import {EpochShuffling} from "./epochShuffling.js";
 
 /**
- * Returns the block root which decided the proposer shuffling for the current epoch. This root
- * can be used to key this proposer shuffling.
+ * Block root that decided the proposer shuffling for `proposalEpoch` (keys that shuffling).
+ * Computed for the requested epoch, not `state.epoch`, so it is correct when `state` is one
+ * epoch off the requested epoch (e.g. serving next-epoch duties from the current state).
  *
- * Returns `null` on the one-off scenario where the genesis block decides its own shuffling.
- * It should be set to the latest block applied to this `state` or the genesis block root.
+ * Returns `null` when the genesis block decides its own shuffling (caller falls back to the
+ * genesis block root).
  */
-export function proposerShufflingDecisionRoot(fork: ForkName, state: IBeaconStateView): Root | null {
-  const decisionSlot = proposerShufflingDecisionSlot(fork, state);
+export function proposerShufflingDecisionRoot(
+  fork: ForkName,
+  state: IBeaconStateView,
+  proposalEpoch: Epoch
+): Root | null {
+  const decisionSlot = proposerShufflingDecisionSlot(fork, proposalEpoch);
   if (state.slot === decisionSlot) {
     return null;
   }
   return state.getBlockRootAtSlot(decisionSlot);
 }
 
-/**
- * Returns the slot at which the proposer shuffling was decided. The block root at this slot
- * can be used to key the proposer shuffling for the current epoch.
- */
-function proposerShufflingDecisionSlot(fork: ForkName, state: IBeaconStateView): Slot {
-  // After fulu, the decision slot is in previous epoch due to deterministic proposer lookahead
-  const epoch = isForkPostFulu(fork) ? state.epoch - 1 : state.epoch;
-  const startSlot = computeStartSlotAtEpoch(epoch);
-  return Math.max(startSlot - 1, 0);
+/** Slot whose block root keys the proposer shuffling for `proposalEpoch`. */
+function proposerShufflingDecisionSlot(fork: ForkName, proposalEpoch: Epoch): Slot {
+  // Post-Fulu the shuffling is decided one epoch earlier (deterministic proposer lookahead,
+  // MIN_SEED_LOOKAHEAD = 1); pre-Fulu it is the last block before `proposalEpoch`.
+  const decisionEpoch = isForkPostFulu(fork) ? proposalEpoch - 1 : proposalEpoch;
+  return Math.max(computeStartSlotAtEpoch(decisionEpoch) - 1, 0);
 }
 
 /**

package/src/util/validator.ts

@@ -44,7 +44,12 @@ export function getActiveValidatorIndices(state: BeaconStateAllForks, epoch: Epo
   return new Uint32Array(indices);
 }
 
-export function getActivationChurnLimit(config: ChainForkConfig, fork: ForkSeq, activeValidatorCount: number): number {
+// Deneb fork upgrade only
+export function getValidatorActivationChurnLimit(
+  config: ChainForkConfig,
+  fork: ForkSeq,
+  activeValidatorCount: number
+): number {
   if (fork >= ForkSeq.deneb) {
     return Math.min(config.MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT, getChurnLimit(config, activeValidatorCount));
   }
@@ -84,7 +89,42 @@ export function getActivationExitChurnLimit(epochCtx: EpochCache): number {
   return Math.min(epochCtx.config.MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT, getBalanceChurnLimitFromCache(epochCtx));
 }
 
-export function getConsolidationChurnLimit(epochCtx: EpochCache): number {
+/**
+ * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/beacon-chain.md#new-get_activation_churn_limit
+ */
+export function getActivationChurnLimit(epochCtx: EpochCache): number {
+  const churn = getBalanceChurnLimit(
+    epochCtx.totalActiveBalanceIncrements,
+    epochCtx.config.CHURN_LIMIT_QUOTIENT_GLOAS,
+    epochCtx.config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
+  );
+  return Math.min(epochCtx.config.MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS, churn);
+}
+
+/**
+ * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/beacon-chain.md#new-get_exit_churn_limit
+ */
+export function getExitChurnLimit(epochCtx: EpochCache): number {
+  return getBalanceChurnLimit(
+    epochCtx.totalActiveBalanceIncrements,
+    epochCtx.config.CHURN_LIMIT_QUOTIENT_GLOAS,
+    epochCtx.config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
+  );
+}
+
+/**
+ * Spec (electra): get_consolidation_churn_limit (uses combined balance churn minus activation+exit churn)
+ * Spec (gloas): get_consolidation_churn_limit (independent quotient, no MIN floor)
+ */
+export function getConsolidationChurnLimit(fork: ForkSeq, epochCtx: EpochCache): number {
+  if (fork >= ForkSeq.gloas) {
+    // No MIN floor — pass 0 so getBalanceChurnLimit's max(churn, min) is a no-op.
+    return getBalanceChurnLimit(
+      epochCtx.totalActiveBalanceIncrements,
+      epochCtx.config.CONSOLIDATION_CHURN_LIMIT_QUOTIENT,
+      0
+    );
+  }
   return getBalanceChurnLimitFromCache(epochCtx) - getActivationExitChurnLimit(epochCtx);
 }