@lodestar/state-transition 1.44.0-dev.6ef8199cfa → 1.44.0-dev.762dd5f186

package/src/block/processDepositRequest.ts

@@ -1,135 +1,15 @@
-import {FAR_FUTURE_EPOCH, ForkSeq, UNSET_DEPOSIT_REQUESTS_START_INDEX} from "@lodestar/params";
-import {BLSPubkey, Bytes32, UintNum64, electra, ssz} from "@lodestar/types";
-import {toPubkeyHex} from "@lodestar/utils";
+import {ForkSeq, UNSET_DEPOSIT_REQUESTS_START_INDEX} from "@lodestar/params";
+import {electra, ssz} from "@lodestar/types";
 import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
-import {findBuilderIndexByPubkey, isBuilderWithdrawalCredential} from "../util/gloas.js";
-import {computeEpochAtSlot, isValidatorKnown} from "../util/index.js";
-import {PendingDepositsLookup} from "../util/pendingDepositsLookup.js";
-import {isValidDepositSignature} from "./processDeposit.js";
 
-/**
- * Apply a deposit for a builder. Either increases balance for existing builder or adds new builder to registry.
- * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-apply_deposit_for_builder
- */
-export function applyDepositForBuilder(
-  state: CachedBeaconStateGloas,
-  pubkey: BLSPubkey,
-  withdrawalCredentials: Bytes32,
-  amount: UintNum64,
-  signature: Bytes32,
-  slot: UintNum64
-): void {
-  const builderIndex = findBuilderIndexByPubkey(state, pubkey);
-
-  if (builderIndex !== null) {
-    // Existing builder - increase balance
-    const builder = state.builders.get(builderIndex);
-    builder.balance += amount;
-  } else {
-    // New builder - verify signature and add to registry
-    if (isValidDepositSignature(state.config, pubkey, withdrawalCredentials, amount, signature)) {
-      addBuilderToRegistry(state, pubkey, withdrawalCredentials, amount, slot);
-    }
-  }
-}
-
-/**
- * Add a new builder to the builders registry.
- * Reuses slots from exited and fully withdrawn builders if available.
- */
-function addBuilderToRegistry(
-  state: CachedBeaconStateGloas,
-  pubkey: BLSPubkey,
-  withdrawalCredentials: Bytes32,
-  amount: UintNum64,
-  slot: UintNum64
-): void {
-  const currentEpoch = computeEpochAtSlot(state.slot);
-  const depositEpoch = computeEpochAtSlot(slot);
-
-  // Try to find a reusable slot from an exited builder with zero balance
-  let builderIndex = state.builders.length;
-  for (let i = 0; i < state.builders.length; i++) {
-    const builder = state.builders.getReadonly(i);
-    if (builder.withdrawableEpoch <= currentEpoch && builder.balance === 0) {
-      builderIndex = i;
-      break;
-    }
-  }
-
-  // Create new builder
-  const newBuilder = ssz.gloas.Builder.toViewDU({
-    pubkey,
-    version: withdrawalCredentials[0],
-    executionAddress: withdrawalCredentials.subarray(12),
-    balance: amount,
-    depositEpoch: depositEpoch,
-    withdrawableEpoch: FAR_FUTURE_EPOCH,
-  });
-
-  if (builderIndex < state.builders.length) {
-    // Reuse existing slot
-    state.builders.set(builderIndex, newBuilder);
-  } else {
-    // Append to end
-    state.builders.push(newBuilder);
-  }
-}
-
-// TODO GLOAS: the PendingDepositsLookup is currently scoped to a single envelope of
-// deposit-requests. We can track it as ephemeral within EpochCache and transfer to the next block
-// transition to reuse cached signature verifications.
-// See https://github.com/ChainSafe/lodestar/issues/9181
 export function processDepositRequest(
   fork: ForkSeq,
   state: CachedBeaconStateElectra | CachedBeaconStateGloas,
-  depositRequest: electra.DepositRequest,
-  pendingDepositsLookup?: PendingDepositsLookup
+  depositRequest: electra.DepositRequest
 ): void {
   const {pubkey, withdrawalCredentials, amount, signature} = depositRequest;
 
-  if (fork >= ForkSeq.gloas) {
-    const stateGloas = state as CachedBeaconStateGloas;
-    const lookup = pendingDepositsLookup ?? PendingDepositsLookup.build(stateGloas);
-    const pubkeyHex = toPubkeyHex(pubkey);
-    const builderIndex = findBuilderIndexByPubkey(stateGloas, pubkey);
-    const validatorIndex = state.epochCtx.getValidatorIndex(pubkey);
-
-    const isBuilder = builderIndex !== null;
-    const isValidator = isValidatorKnown(state, validatorIndex);
-
-    if (isBuilder) {
-      // Top up an existing builder regardless of withdrawal credential prefix
-      applyDepositForBuilder(stateGloas, pubkey, withdrawalCredentials, amount, signature, state.slot);
-      return;
-    }
-
-    // Only check the (expensive) "pending validator" condition when needed
-    if (
-      isBuilderWithdrawalCredential(withdrawalCredentials) &&
-      !isValidator &&
-      !lookup.hasPendingValidator(state.config, pubkeyHex)
-    ) {
-      applyDepositForBuilder(stateGloas, pubkey, withdrawalCredentials, amount, signature, state.slot);
-      return;
-    }
-
-    const pendingDeposit = ssz.electra.PendingDeposit.toViewDU({
-      pubkey,
-      withdrawalCredentials,
-      amount,
-      signature,
-      slot: state.slot,
-    });
-    // Keep the lookup in sync with state.pendingDeposits so later deposit-requests
-    // in the same envelope see this deposit
-    lookup.add(pendingDeposit, pubkeyHex);
-    state.pendingDeposits.push(pendingDeposit);
-    return;
-  }
-
-  // Pre-Gloas (Electra) path
-  if (state.depositRequestsStartIndex === UNSET_DEPOSIT_REQUESTS_START_INDEX) {
+  if (fork === ForkSeq.electra && state.depositRequestsStartIndex === UNSET_DEPOSIT_REQUESTS_START_INDEX) {
     state.depositRequestsStartIndex = depositRequest.index;
   }
 

package/src/block/processExecutionPayloadBid.ts

@@ -1,15 +1,17 @@
 import {PublicKey, Signature, verify} from "@chainsafe/blst";
-import {BUILDER_INDEX_SELF_BUILD, ForkPostGloas, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {BeaconBlock, gloas, ssz} from "@lodestar/types";
+import {BUILDER_INDEX_SELF_BUILD, GENESIS_SLOT, PAYLOAD_BUILDER_VERSION, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
 import {G2_POINT_AT_INFINITY} from "../constants/constants.js";
 import {getExecutionPayloadBidSigningRoot} from "../signatureSets/executionPayloadBid.js";
 import {CachedBeaconStateGloas} from "../types.js";
 import {canBuilderCoverBid, isActiveBuilder} from "../util/gloas.js";
-import {getCurrentEpoch, getRandaoMix} from "../util/index.js";
+import {getBlockRootAtSlot, getCurrentEpoch, getRandaoMix} from "../util/index.js";
 
-export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block: BeaconBlock<ForkPostGloas>): void {
-  const signedBid = block.body.signedExecutionPayloadBid;
+export function processExecutionPayloadBid(
+  state: CachedBeaconStateGloas,
+  signedBid: gloas.SignedExecutionPayloadBid
+): void {
   const bid = signedBid.message;
   const {builderIndex, value: amount} = bid;
 
@@ -31,6 +33,13 @@ export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block:
       throw Error(`Invalid execution payload bid: builder ${builderIndex} is not active`);
     }
 
+    // Verify that the builder is a payload builder
+    if (builder.version !== PAYLOAD_BUILDER_VERSION) {
+      throw Error(
+        `Invalid execution payload bid: builder ${builderIndex} version ${builder.version} != ${PAYLOAD_BUILDER_VERSION}`
+      );
+    }
+
     // Verify that the builder has funds to cover the bid
     if (!canBuilderCoverBid(state, builderIndex, amount)) {
       throw Error(`Invalid execution payload bid: builder ${builderIndex} has insufficient balance`);
@@ -42,8 +51,12 @@ export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block:
     }
   }
 
-  if (bid.slot !== block.slot) {
-    throw Error(`Bid slot ${bid.slot} does not match block slot ${block.slot}`);
+  if (bid.slot !== state.slot) {
+    throw Error(`Bid slot ${bid.slot} does not match state slot ${state.slot}`);
+  }
+
+  if (state.slot <= GENESIS_SLOT) {
+    throw Error(`Execution payload bid not allowed at genesis slot ${state.slot}`);
   }
 
   if (!byteArrayEquals(bid.parentBlockHash, state.latestBlockHash)) {
@@ -52,9 +65,10 @@ export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block:
     );
   }
 
-  if (!byteArrayEquals(bid.parentBlockRoot, block.parentRoot)) {
+  const parentBlockRoot = getBlockRootAtSlot(state, state.slot - 1);
+  if (!byteArrayEquals(bid.parentBlockRoot, parentBlockRoot)) {
     throw Error(
-      `Parent block root ${toRootHex(bid.parentBlockRoot)} of bid does not match block's parent root ${toRootHex(block.parentRoot)}`
+      `Parent block root ${toRootHex(bid.parentBlockRoot)} of bid does not match state's parent block root ${toRootHex(parentBlockRoot)}`
     );
   }
 
@@ -79,6 +93,7 @@ export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block:
         amount,
         builderIndex,
       }),
+      proposerIndex: state.epochCtx.getBeaconProposer(state.slot),
     });
 
     state.builderPendingPayments.set(SLOTS_PER_EPOCH + (bid.slot % SLOTS_PER_EPOCH), pendingPaymentView);

package/src/block/processOperations.ts

@@ -39,8 +39,9 @@ export function processOperations(
   opts: ProcessBlockOpts = {verifySignatures: true},
   metrics?: BeaconStateTransitionMetrics | null
 ): void {
-  // verify that outstanding deposits are processed up to the maximum number of deposits
-  const maxDeposits = getEth1DepositCount(state);
+  // verify that outstanding deposits are processed up to the maximum number of deposits.
+  // From Fulu the eth1 bridge deposit mechanism was removed, so blocks must not contain any deposits.
+  const maxDeposits = fork >= ForkSeq.fulu ? 0 : getEth1DepositCount(state);
   if (body.deposits.length !== maxDeposits) {
     throw new Error(
       `Block contains incorrect number of deposits: depositCount=${body.deposits.length} expected=${maxDeposits}`

package/src/block/processParentExecutionPayload.ts

@@ -1,9 +1,10 @@
 import {ForkPostGloas, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
-import {BeaconBlock, electra, ssz} from "@lodestar/types";
+import {BeaconBlock, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot} from "../util/epoch.js";
-import {PendingDepositsLookup} from "../util/pendingDepositsLookup.js";
+import {processBuilderDepositRequest} from "./processBuilderDepositRequest.js";
+import {processBuilderExitRequest} from "./processBuilderExitRequest.js";
 import {processConsolidationRequest} from "./processConsolidationRequest.js";
 import {processDepositRequest} from "./processDepositRequest.js";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
@@ -26,7 +27,7 @@ export function processParentExecutionPayload(state: CachedBeaconStateGloas, blo
   }
 
   // Parent was FULL -- verify the bid commitment and apply the payload
-  const requestsRoot = ssz.electra.ExecutionRequests.hashTreeRoot(requests);
+  const requestsRoot = ssz.gloas.ExecutionRequests.hashTreeRoot(requests);
   if (!byteArrayEquals(requestsRoot, parentBid.executionRequestsRoot)) {
     throw new Error(
       `Parent execution requests root mismatch actual=${toRootHex(requestsRoot)} expected=${toRootHex(parentBid.executionRequestsRoot)}`
@@ -45,7 +46,7 @@ export function processParentExecutionPayload(state: CachedBeaconStateGloas, blo
  *
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/beacon-chain.md#new-apply_parent_execution_payload
  */
-export function applyParentExecutionPayload(state: CachedBeaconStateGloas, requests: electra.ExecutionRequests): void {
+export function applyParentExecutionPayload(state: CachedBeaconStateGloas, requests: gloas.ExecutionRequests): void {
   const fork = state.config.getForkSeq(state.slot);
   const parentBid = state.latestExecutionPayloadBid;
   const parentSlot = parentBid.slot;
@@ -54,11 +55,8 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
 
   // Process execution requests from parent's payload. The execution
   // requests are processed at state.slot (child's slot), not the parent's slot.
-  if (requests.deposits.length > 0) {
-    const pendingDepositsLookup = PendingDepositsLookup.build(state);
-    for (const deposit of requests.deposits) {
-      processDepositRequest(fork, state, deposit, pendingDepositsLookup);
-    }
+  for (const deposit of requests.deposits) {
+    processDepositRequest(fork, state, deposit);
   }
 
   for (const withdrawal of requests.withdrawals) {
@@ -69,6 +67,14 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
     processConsolidationRequest(state, consolidation);
   }
 
+  for (const builderDeposit of requests.builderDeposits) {
+    processBuilderDepositRequest(state, builderDeposit);
+  }
+
+  for (const builderExit of requests.builderExits) {
+    processBuilderExitRequest(state, builderExit);
+  }
+
   // Settle the builder payment
   if (parentEpoch === currentEpoch) {
     settleBuilderPayment(state, SLOTS_PER_EPOCH + (parentSlot % SLOTS_PER_EPOCH));
@@ -110,8 +116,14 @@ function settleBuilderPayment(state: CachedBeaconStateGloas, paymentIndex: numbe
   state.builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
 }
 
-function assertEmptyExecutionRequests(requests: electra.ExecutionRequests): void {
-  if (requests.deposits.length !== 0 || requests.withdrawals.length !== 0 || requests.consolidations.length !== 0) {
+function assertEmptyExecutionRequests(requests: gloas.ExecutionRequests): void {
+  if (
+    requests.deposits.length !== 0 ||
+    requests.withdrawals.length !== 0 ||
+    requests.consolidations.length !== 0 ||
+    requests.builderDeposits.length !== 0 ||
+    requests.builderExits.length !== 0
+  ) {
     throw new Error("Parent execution requests must be empty when parent block is EMPTY");
   }
 }

package/src/block/processProposerSlashing.ts

@@ -32,6 +32,10 @@ export function processProposerSlashing(
   );
 
   if (fork >= ForkSeq.gloas) {
+    // Remove the BuilderPendingPayment corresponding to this proposal if it is still in the
+    // 2-epoch window. Only clear it when the slashed validator is the proposer associated with
+    // the payment; otherwise an unrelated same-slot equivocation could grief an honest proposer's
+    // payment.
     const slot = Number(proposerSlashing.signedHeader1.message.slot);
     const proposalEpoch = computeEpochAtSlot(slot);
     const currentEpoch = state.epochCtx.epoch;
@@ -45,10 +49,11 @@ export function processProposerSlashing(
           : undefined;
 
     if (paymentIndex !== undefined) {
-      (state as CachedBeaconStateGloas).builderPendingPayments.set(
-        paymentIndex,
-        ssz.gloas.BuilderPendingPayment.defaultViewDU()
-      );
+      const builderPendingPayments = (state as CachedBeaconStateGloas).builderPendingPayments;
+      const payment = builderPendingPayments.get(paymentIndex);
+      if (payment.proposerIndex === proposerSlashing.signedHeader1.message.proposerIndex) {
+        builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
+      }
     }
   }
 

package/src/block/processVoluntaryExit.ts

@@ -2,14 +2,7 @@ import {FAR_FUTURE_EPOCH, ForkSeq} from "@lodestar/params";
 import {phase0} from "@lodestar/types";
 import {verifyVoluntaryExitSignature} from "../signatureSets/index.js";
 import {BeaconStateView} from "../stateView/beaconStateView.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
-import {
-  convertValidatorIndexToBuilderIndex,
-  getPendingBalanceToWithdrawForBuilder,
-  initiateBuilderExit,
-  isActiveBuilder,
-  isBuilderIndex,
-} from "../util/gloas.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateElectra} from "../types.js";
 import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/index.js";
 import {initiateValidatorExit} from "./index.js";
 
@@ -24,7 +17,7 @@ export enum VoluntaryExitValidity {
 }
 
 /**
- * Process a VoluntaryExit operation. Initiates the exit of a validator or builder.
+ * Process a VoluntaryExit operation. Initiates the exit of a validator.
  *
  * PERF: Work depends on number of VoluntaryExit per block. On regular networks the average is 0 / block.
  */
@@ -34,21 +27,11 @@ export function processVoluntaryExit(
   signedVoluntaryExit: phase0.SignedVoluntaryExit,
   verifySignature = true
 ): void {
-  const voluntaryExit = signedVoluntaryExit.message;
-
   const validity = getVoluntaryExitValidity(fork, state, signedVoluntaryExit, verifySignature);
   if (validity !== VoluntaryExitValidity.valid) {
     throw Error(`Invalid voluntary exit at forkSeq=${fork} reason=${validity}`);
   }
 
-  if (fork >= ForkSeq.gloas && isBuilderIndex(voluntaryExit.validatorIndex)) {
-    initiateBuilderExit(
-      state as CachedBeaconStateGloas,
-      convertValidatorIndexToBuilderIndex(voluntaryExit.validatorIndex)
-    );
-    return;
-  }
-
   const validator = state.validators.get(signedVoluntaryExit.message.validatorIndex);
   initiateValidatorExit(fork, state, validator);
 }
@@ -67,51 +50,9 @@ export function getVoluntaryExitValidity(
     return VoluntaryExitValidity.earlyEpoch;
   }
 
-  // Check if this is a builder exit
-  if (fork >= ForkSeq.gloas && isBuilderIndex(voluntaryExit.validatorIndex)) {
-    return getBuilderVoluntaryExitValidity(state as CachedBeaconStateGloas, signedVoluntaryExit, verifySignature);
-  }
-
   return getValidatorVoluntaryExitValidity(fork, state, signedVoluntaryExit, verifySignature);
 }
 
-function getBuilderVoluntaryExitValidity(
-  state: CachedBeaconStateGloas,
-  signedVoluntaryExit: phase0.SignedVoluntaryExit,
-  verifySignature: boolean
-): VoluntaryExitValidity {
-  const {config, epochCtx} = state;
-  const builderIndex = convertValidatorIndexToBuilderIndex(signedVoluntaryExit.message.validatorIndex);
-
-  if (builderIndex >= state.builders.length) {
-    return VoluntaryExitValidity.inactive;
-  }
-
-  const builder = state.builders.getReadonly(builderIndex);
-
-  // Verify the builder is active
-  if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
-    return builder.withdrawableEpoch !== FAR_FUTURE_EPOCH
-      ? VoluntaryExitValidity.alreadyExited
-      : VoluntaryExitValidity.inactive;
-  }
-
-  // Only exit builder if it has no pending withdrawals in the queue
-  if (getPendingBalanceToWithdrawForBuilder(state, builderIndex) !== 0) {
-    return VoluntaryExitValidity.pendingWithdrawals;
-  }
-
-  // Verify signature
-  if (
-    verifySignature &&
-    !verifyVoluntaryExitSignature(config, epochCtx.pubkeyCache, new BeaconStateView(state), signedVoluntaryExit)
-  ) {
-    return VoluntaryExitValidity.invalidSignature;
-  }
-
-  return VoluntaryExitValidity.valid;
-}
-
 function getValidatorVoluntaryExitValidity(
   fork: ForkSeq,
   state: CachedBeaconStateAllForks,

package/src/cache/epochCache.ts

@@ -782,14 +782,17 @@ export class EpochCache {
    */
   getBeaconProposer(slot: Slot): ValidatorIndex {
     const epoch = computeEpochAtSlot(slot);
-    if (epoch !== this.currentShuffling.epoch) {
-      throw new EpochCacheError({
-        code: EpochCacheErrorCode.PROPOSER_EPOCH_MISMATCH,
-        currentEpoch: this.currentShuffling.epoch,
-        requestedEpoch: epoch,
-      });
+    if (epoch === this.currentShuffling.epoch) {
+      return this.proposers[slot % SLOTS_PER_EPOCH];
+    }
+    if (epoch === this.nextEpoch) {
+      return this.getBeaconProposersNextEpoch()[slot % SLOTS_PER_EPOCH];
     }
-    return this.proposers[slot % SLOTS_PER_EPOCH];
+    throw new EpochCacheError({
+      code: EpochCacheErrorCode.PROPOSER_EPOCH_MISMATCH,
+      currentEpoch: this.currentShuffling.epoch,
+      requestedEpoch: epoch,
+    });
   }
 
   getBeaconProposers(): ValidatorIndex[] {

package/src/epoch/processPendingDeposits.ts

@@ -37,7 +37,9 @@ export function processPendingDeposits(state: CachedBeaconStateElectra, cache: E
 
     for (const deposit of deposits) {
       // Do not process deposit requests if Eth1 bridge deposits are not yet applied.
+      // The eth1 bridge deposit mechanism was removed in Fulu, so this gate only applies pre-Fulu.
       if (
+        fork < ForkSeq.fulu &&
         // Is deposit request
         deposit.slot > GENESIS_SLOT &&
         // There are pending Eth1 bridge deposits

package/src/epoch/processProposerLookahead.ts

@@ -1,6 +1,7 @@
 import {ForkSeq, MIN_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {CachedBeaconStateFulu, EpochTransitionCache} from "../types.js";
+import {FLAG_UNSLASHED} from "../util/attesterStatus.js";
 import {computeEpochShuffling} from "../util/epochShuffling.js";
 import {computeProposerIndices} from "../util/seed.js";
 
@@ -26,7 +27,13 @@ export function processProposerLookahead(
   // Save shuffling to cache so afterProcessEpoch can reuse it instead of recomputing
   cache.nextShuffling = shuffling;
 
-  const lastEpochProposerLookahead = computeProposerIndices(fork, state, shuffling, epoch);
+  const activeIndices =
+    fork >= ForkSeq.gloas
+      ? // Exclude slashed validators from proposing (EIP-8045)
+        shuffling.activeIndices.filter((index) => (cache.flags[index] & FLAG_UNSLASHED) !== 0)
+      : shuffling.activeIndices;
+
+  const lastEpochProposerLookahead = computeProposerIndices(fork, state, {activeIndices}, epoch);
 
   state.proposerLookahead = ssz.fulu.ProposerLookahead.toViewDU([
     ...remainingProposerLookahead,

package/src/slot/upgradeStateToGloas.ts

@@ -1,10 +1,10 @@
-import {SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {PAYLOAD_BUILDER_VERSION, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {toPubkeyHex} from "@lodestar/utils";
-import {applyDepositForBuilder} from "../block/processDepositRequest.js";
+import {isValidDepositSignature} from "../block/processDeposit.js";
 import {getCachedBeaconState} from "../cache/stateCache.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
-import {initializePtcWindow, isBuilderWithdrawalCredential} from "../util/gloas.js";
+import {addBuilderToRegistry, initializePtcWindow, isBuilderWithdrawalCredential} from "../util/gloas.js";
 import {isValidatorKnown} from "../util/index.js";
 import {PendingDepositsLookup} from "../util/pendingDepositsLookup.js";
 
@@ -48,9 +48,9 @@ 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()
+  stateGloasView.latestExecutionPayloadBid.gasLimit = stateFulu.latestExecutionPayloadHeader.gasLimit;
+  stateGloasView.latestExecutionPayloadBid.executionRequestsRoot = ssz.gloas.ExecutionRequests.hashTreeRoot(
+    ssz.gloas.ExecutionRequests.defaultValue()
   );
   stateGloasView.nextWithdrawalIndex = stateGloasCloned.nextWithdrawalIndex;
   stateGloasView.nextWithdrawalValidatorIndex = stateGloasCloned.nextWithdrawalValidatorIndex;
@@ -90,7 +90,8 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
  * 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 builders added when applying deposits
+  // Track pubkeys of new builders added when applying deposits. `state.builders` starts empty
+  // at the fork, so every builder pubkey here is one added in an earlier iteration.
   const builderPubkeys = new Set<string>();
 
   const pendingDeposits = ssz.electra.PendingDeposits.defaultViewDU();
@@ -109,40 +110,55 @@ function onboardBuildersFromPendingDeposits(state: CachedBeaconStateGloas): void
       continue;
     }
 
-    // `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;
+    if (builderPubkeys.has(pubkeyHex)) {
+      // Top up an already-onboarded builder
+      // TODO GLOAS: linear search; consider builder pubkey cache when we drop the upgrade-time set
+      for (let j = 0; j < state.builders.length; j++) {
+        if (toPubkeyHex(state.builders.getReadonly(j).pubkey) === pubkeyHex) {
+          state.builders.get(j).balance += deposit.amount;
+          break;
+        }
       }
+      continue;
     }
 
-    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(
+    // 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 pending so the validator
+    // can pick it up 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;
+    }
+
+    // Verify the deposit signature (proof of possession). If invalid the deposit is silently
+    // dropped — stake is forfeited, matching the validator deposit contract behavior.
+    if (
+      !isValidDepositSignature(
+        state.config,
+        deposit.pubkey,
+        deposit.withdrawalCredentials,
+        deposit.amount,
+        deposit.signature
+      )
+    ) {
+      continue;
+    }
+
+    addBuilderToRegistry(
       state,
       deposit.pubkey,
-      deposit.withdrawalCredentials,
+      PAYLOAD_BUILDER_VERSION,
+      deposit.withdrawalCredentials.subarray(12),
       deposit.amount,
-      deposit.signature,
       deposit.slot
     );
-    if (state.builders.length > buildersLenBefore) {
-      builderPubkeys.add(pubkeyHex);
-    }
+    builderPubkeys.add(pubkeyHex);
   }
 
   state.pendingDeposits = pendingDeposits;

package/src/stateView/beaconStateView.ts

@@ -8,6 +8,7 @@ import {
   BlindedBeaconBlock,
   BuilderIndex,
   Bytes32,
+  CommitteeIndex,
   Epoch,
   ExecutionPayloadBid,
   ExecutionPayloadHeader,
@@ -452,6 +453,14 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
     return this.cachedState.epochCtx.getShufflingAtEpoch(epoch);
   }
 
+  getBeaconCommittee(slot: Slot, index: CommitteeIndex): Uint32Array {
+    return this.cachedState.epochCtx.getBeaconCommittee(slot, index);
+  }
+
+  getBeaconCommitteeCountPerSlot(epoch: Epoch): number {
+    return this.cachedState.epochCtx.getCommitteeCountPerSlot(epoch);
+  }
+
   get previousDecisionRoot(): RootHex {
     return this.cachedState.epochCtx.previousDecisionRoot;
   }
@@ -498,6 +507,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);
   }
@@ -814,7 +831,7 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
   /**
    * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/validator.md#executionpayload
    */
-  withParentPayloadApplied(executionRequests: electra.ExecutionRequests): IBeaconStateViewGloas {
+  withParentPayloadApplied(executionRequests: gloas.ExecutionRequests): IBeaconStateViewGloas {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
       throw new Error("withParentPayloadApplied is not available before Gloas");
     }