@lodestar/state-transition 1.43.0 → 1.44.0-dev.055b83cb3d

package/src/lightClient/spec/validateLightClientUpdate.ts

@@ -0,0 +1,145 @@
+import {PublicKey, Signature, fastAggregateVerify} from "@chainsafe/blst";
+import {ChainForkConfig} from "@lodestar/config";
+import {
+  DOMAIN_SYNC_COMMITTEE,
+  FINALIZED_ROOT_DEPTH,
+  FINALIZED_ROOT_DEPTH_ELECTRA,
+  FINALIZED_ROOT_INDEX,
+  FINALIZED_ROOT_INDEX_ELECTRA,
+  GENESIS_SLOT,
+  MIN_SYNC_COMMITTEE_PARTICIPANTS,
+  NEXT_SYNC_COMMITTEE_DEPTH,
+  NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA,
+  NEXT_SYNC_COMMITTEE_INDEX,
+  NEXT_SYNC_COMMITTEE_INDEX_ELECTRA,
+} from "@lodestar/params";
+import {LightClientUpdate, Root, isElectraLightClientUpdate, ssz} from "@lodestar/types";
+import type {ILightClientStore, SyncCommitteeFast} from "./store.js";
+import {
+  ZERO_HASH,
+  getParticipantPubkeys,
+  isFinalityUpdate,
+  isSyncCommitteeUpdate,
+  isValidLightClientHeader,
+  isValidMerkleBranch,
+  isZeroedHeader,
+  isZeroedSyncCommittee,
+  sumBits,
+} from "./utils.js";
+
+export function validateLightClientUpdate(
+  config: ChainForkConfig,
+  store: ILightClientStore,
+  update: LightClientUpdate,
+  syncCommittee: SyncCommitteeFast
+): void {
+  // Verify sync committee has sufficient participants
+  if (sumBits(update.syncAggregate.syncCommitteeBits) < MIN_SYNC_COMMITTEE_PARTICIPANTS) {
+    throw Error("Sync committee has not sufficient participants");
+  }
+
+  if (!isValidLightClientHeader(config, update.attestedHeader)) {
+    throw Error("Attested Header is not Valid Light Client Header");
+  }
+
+  // Sanity check that slots are in correct order
+  if (update.signatureSlot <= update.attestedHeader.beacon.slot) {
+    throw Error(
+      `signature slot ${update.signatureSlot} must be after attested header slot ${update.attestedHeader.beacon.slot}`
+    );
+  }
+  if (update.attestedHeader.beacon.slot < update.finalizedHeader.beacon.slot) {
+    throw Error(
+      `attested header slot ${update.signatureSlot} must be after finalized header slot ${update.finalizedHeader.beacon.slot}`
+    );
+  }
+
+  // Verify that the `finality_branch`, if present, confirms `finalized_header`
+  // to match the finalized checkpoint root saved in the state of `attested_header`.
+  // Note that the genesis finalized checkpoint root is represented as a zero hash.
+  if (!isFinalityUpdate(update)) {
+    if (!isZeroedHeader(update.finalizedHeader.beacon)) {
+      throw Error("finalizedHeader must be zero for non-finality update");
+    }
+  } else {
+    let finalizedRoot: Root;
+
+    if (update.finalizedHeader.beacon.slot === GENESIS_SLOT) {
+      if (!isZeroedHeader(update.finalizedHeader.beacon)) {
+        throw Error("finalizedHeader must be zero for not finality update");
+      }
+      finalizedRoot = ZERO_HASH;
+    } else {
+      if (!isValidLightClientHeader(config, update.finalizedHeader)) {
+        throw Error("Finalized Header is not valid Light Client Header");
+      }
+
+      finalizedRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(update.finalizedHeader.beacon);
+    }
+
+    if (
+      !isValidMerkleBranch(
+        finalizedRoot,
+        update.finalityBranch,
+        isElectraLightClientUpdate(update) ? FINALIZED_ROOT_DEPTH_ELECTRA : FINALIZED_ROOT_DEPTH,
+        isElectraLightClientUpdate(update) ? FINALIZED_ROOT_INDEX_ELECTRA : FINALIZED_ROOT_INDEX,
+        update.attestedHeader.beacon.stateRoot
+      )
+    ) {
+      throw Error("Invalid finality header merkle branch");
+    }
+  }
+
+  // Verify that the `next_sync_committee`, if present, actually is the next sync committee saved in the
+  // state of the `attested_header`
+  if (!isSyncCommitteeUpdate(update)) {
+    if (!isZeroedSyncCommittee(update.nextSyncCommittee)) {
+      throw Error("nextSyncCommittee must be zero for non sync committee update");
+    }
+  } else {
+    if (
+      !isValidMerkleBranch(
+        ssz.altair.SyncCommittee.hashTreeRoot(update.nextSyncCommittee),
+        update.nextSyncCommitteeBranch,
+        isElectraLightClientUpdate(update) ? NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA : NEXT_SYNC_COMMITTEE_DEPTH,
+        isElectraLightClientUpdate(update) ? NEXT_SYNC_COMMITTEE_INDEX_ELECTRA : NEXT_SYNC_COMMITTEE_INDEX,
+        update.attestedHeader.beacon.stateRoot
+      )
+    ) {
+      throw Error("Invalid next sync committee merkle branch");
+    }
+  }
+
+  // Verify sync committee aggregate signature
+
+  const participantPubkeys = getParticipantPubkeys(syncCommittee.pubkeys, update.syncAggregate.syncCommitteeBits);
+
+  const signingRoot = ssz.phase0.SigningData.hashTreeRoot({
+    objectRoot: ssz.phase0.BeaconBlockHeader.hashTreeRoot(update.attestedHeader.beacon),
+    domain: store.config.getDomain(update.signatureSlot - 1, DOMAIN_SYNC_COMMITTEE),
+  });
+
+  if (!isValidBlsAggregate(participantPubkeys, signingRoot, update.syncAggregate.syncCommitteeSignature)) {
+    throw Error("Invalid aggregate signature");
+  }
+}
+
+/**
+ * Same as BLS.verifyAggregate but with detailed error messages
+ */
+function isValidBlsAggregate(publicKeys: PublicKey[], message: Uint8Array, signature: Uint8Array): boolean {
+  let sig: Signature;
+  try {
+    sig = Signature.fromBytes(signature, true);
+  } catch (e) {
+    (e as Error).message = `Error deserializing signature: ${(e as Error).message}`;
+    throw e;
+  }
+
+  try {
+    return fastAggregateVerify(message, publicKeys, sig);
+  } catch (e) {
+    (e as Error).message = `Error verifying signature: ${(e as Error).message}`;
+    throw e;
+  }
+}

package/src/slot/upgradeStateToGloas.ts

@@ -1,12 +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 {toPubkeyHex} from "@lodestar/utils";
 import {applyDepositForBuilder} from "../block/processDepositRequest.js";
 import {getCachedBeaconState} from "../cache/stateCache.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
 import {initializePtcWindow, isBuilderWithdrawalCredential} from "../util/gloas.js";
 import {isValidatorKnown} from "../util/index.js";
+import {PendingDepositsLookup} from "../util/pendingDepositsLookup.js";
 
 /**
  * Upgrade a state from Fulu to Gloas.
@@ -48,6 +48,7 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
   stateGloasView.currentSyncCommittee = stateGloasCloned.currentSyncCommittee;
   stateGloasView.nextSyncCommittee = stateGloasCloned.nextSyncCommittee;
   stateGloasView.latestExecutionPayloadBid.blockHash = stateFulu.latestExecutionPayloadHeader.blockHash;
+  stateGloasView.latestExecutionPayloadBid.gasLimit = BigInt(stateFulu.latestExecutionPayloadHeader.gasLimit);
   stateGloasView.latestExecutionPayloadBid.executionRequestsRoot = ssz.electra.ExecutionRequests.hashTreeRoot(
     ssz.electra.ExecutionRequests.defaultValue()
   );
@@ -86,66 +87,63 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
 
 /**
  * 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
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.8/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();
+  const pendingDeposits = ssz.electra.PendingDeposits.defaultViewDU();
+  const pendingDepositsLookup = PendingDepositsLookup.buildEmpty();
+
   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);
+    const pubkeyHex = toPubkeyHex(deposit.pubkey);
 
-    // Deposits for existing validators stay in pending queue
-    if (isValidatorKnown(state, validatorIndex) || validatorPubkeys.has(pubkeyHex)) {
-      remainingPendingDeposits.push(deposit);
+    // Deposits for existing validators stay in the pending queue
+    if (isValidatorKnown(state, validatorIndex)) {
+      pendingDeposits.push(deposit);
+      pendingDepositsLookup.add(deposit, pubkeyHex);
       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);
+    // `applyDepositForBuilder` can mutate the state and add a builder to the registry, so
+    // the set of builder pubkeys must be recomputed each iteration. `builderPubkeys` stands
+    // in for the spec's `[b.pubkey for b in state.builders]`: `state.builders` starts empty
+    // at the fork, so every builder is one added in a previous iteration of this loop.
+    if (!builderPubkeys.has(pubkeyHex)) {
+      // Deposits for non-builders stay in the pending queue. If there is a valid pending
+      // deposit for a new validator with this pubkey, keep this deposit in the pending
+      // queue to be applied to that validator later.
+      if (!isBuilderWithdrawalCredential(deposit.withdrawalCredentials)) {
+        pendingDeposits.push(deposit);
+        pendingDepositsLookup.add(deposit, pubkeyHex);
+        continue;
+      }
+      if (pendingDepositsLookup.hasPendingValidator(state.config, pubkeyHex)) {
+        pendingDeposits.push(deposit);
+        pendingDepositsLookup.add(deposit, pubkeyHex);
+        continue;
       }
-      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);
+    const buildersLenBefore = state.builders.length;
+    // TODO GLOAS: handle 20k 1ETH deposits on time
+    // there is a note in the spec https://github.com/ethereum/consensus-specs/pull/5227
+    applyDepositForBuilder(
+      state,
+      deposit.pubkey,
+      deposit.withdrawalCredentials,
+      deposit.amount,
+      deposit.signature,
+      deposit.slot
+    );
+    if (state.builders.length > buildersLenBefore) {
+      builderPubkeys.add(pubkeyHex);
     }
   }
 
-  state.pendingDeposits = remainingPendingDeposits;
+  state.pendingDeposits = pendingDeposits;
 }

package/src/stateView/beaconStateView.ts

@@ -423,16 +423,27 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
     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.
+   * 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
    */
-  getIndexInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number {
+  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
@@ -487,6 +498,14 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
     return this.cachedState.epochCtx.getBeaconProposer(slot);
   }
 
+  getBeaconProposerOrNull(slot: Slot): ValidatorIndex | null {
+    try {
+      return this.cachedState.epochCtx.getBeaconProposer(slot);
+    } catch {
+      return null;
+    }
+  }
+
   computeAnchorCheckpoint(): {checkpoint: phase0.Checkpoint; blockHeader: phase0.BeaconBlockHeader} {
     return computeAnchorCheckpoint(this.config, this.cachedState);
   }

package/src/stateView/interface.ts

@@ -89,6 +89,7 @@ export interface IBeaconStateView {
   currentProposers: ValidatorIndex[];
   nextProposers: ValidatorIndex[];
   getBeaconProposer(slot: Slot): ValidatorIndex;
+  getBeaconProposerOrNull(slot: Slot): ValidatorIndex | null;
 
   // Validators and balances
   effectiveBalanceIncrements: EffectiveBalanceIncrements;
@@ -253,7 +254,7 @@ export interface IBeaconStateViewGloas extends IBeaconStateViewFulu {
   getBuilder(index: BuilderIndex): gloas.Builder;
   canBuilderCoverBid(builderIndex: BuilderIndex, bidAmount: number): boolean;
   getEpochPTCs(epoch: Epoch): Uint32Array[];
-  getIndexInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number;
+  getIndicesInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number[];
   /**
    * Clone the state and apply parent execution payload effects.
    * Used during block production and prepareNextSlot so that withdrawals and

package/src/util/gloas.ts

@@ -73,6 +73,34 @@ export function isActiveBuilder(builder: gloas.Builder, finalizedEpoch: Epoch):
   return builder.depositEpoch < finalizedEpoch && builder.withdrawableEpoch === FAR_FUTURE_EPOCH;
 }
 
+/**
+ * Compute the gas limit that satisfies the EIP-1559 adjustment rule from `parentGasLimit`,
+ * clamping `targetGasLimit` into the allowed window of `±max(parentGasLimit / 1024, 1) - 1`.
+ *
+ * From https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md
+ */
+export function getExpectedGasLimit(parentGasLimit: number, targetGasLimit: number): number {
+  const maxGasLimitDifference = Math.max(Math.floor(parentGasLimit / 1024), 1) - 1;
+
+  if (targetGasLimit > parentGasLimit) {
+    const gasDiff = targetGasLimit - parentGasLimit;
+    return parentGasLimit + Math.min(gasDiff, maxGasLimitDifference);
+  }
+
+  const gasDiff = parentGasLimit - targetGasLimit;
+  return parentGasLimit - Math.min(gasDiff, maxGasLimitDifference);
+}
+
+/**
+ * Check if `gasLimit` is compatible with `targetGasLimit` under the EIP-1559 transition rule
+ * from `parentGasLimit`. The bid must hit `targetGasLimit` when the target is within one
+ * adjustment step of the parent, otherwise it must hit the clamped boundary.
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.8/specs/gloas/builder.md#new-is_gas_limit_target_compatible
+ */
+export function isGasLimitTargetCompatible(parentGasLimit: number, gasLimit: number, targetGasLimit: number): boolean {
+  return gasLimit === getExpectedGasLimit(parentGasLimit, targetGasLimit);
+}
+
 /**
  * Get the total pending balance to withdraw for a builder (from withdrawals + payments).
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-get_pending_balance_to_withdraw_for_builder

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/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);
 }
 
 /**