@lodestar/state-transition 1.44.0-dev.481dde6669 → 1.44.0-dev.4b91ba8c2f

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

@@ -831,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");
     }

package/src/stateView/interface.ts

@@ -264,7 +264,7 @@ export interface IBeaconStateViewGloas extends IBeaconStateViewFulu {
    * operation selection (e.g. voluntary exits) see the same post-apply state that the block
    * processor will see at import.
    */
-  withParentPayloadApplied(executionRequests: electra.ExecutionRequests): IBeaconStateViewGloas;
+  withParentPayloadApplied(executionRequests: gloas.ExecutionRequests): IBeaconStateViewGloas;
 }
 
 /**

package/src/stateView/nativeBeaconStateView.ts

@@ -905,7 +905,7 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     return this.binding.getIndicesInPayloadTimelinessCommittee(validatorIndex, slot);
   }
 
-  withParentPayloadApplied(executionRequests: electra.ExecutionRequests): IBeaconStateViewGloas {
+  withParentPayloadApplied(executionRequests: gloas.ExecutionRequests): IBeaconStateViewGloas {
     const view = new NativeBeaconStateView(this.binding.withParentPayloadApplied(executionRequests));
     if (!isStatePostGloas(view)) {
       throw new Error("Expected gloas state from withParentPayloadApplied");

package/src/util/epochShuffling.ts

@@ -124,7 +124,7 @@ export async function computeEpochShufflingAsync(
 }
 
 export function calculateDecisionRoot(state: BeaconStateAllForks, epoch: Epoch): RootHex {
-  const pivotSlot = computeStartSlotAtEpoch(epoch - 1) - 1;
+  const pivotSlot = Math.max(GENESIS_SLOT, computeStartSlotAtEpoch(epoch - 1) - 1);
   return toRootHex(getBlockRootAtSlot(state, pivotSlot));
 }
 

package/src/util/gloas.ts

@@ -1,8 +1,11 @@
+import {PublicKey, Signature, verify} from "@chainsafe/blst";
+import {BeaconConfig} from "@lodestar/config";
 import {
   BUILDER_INDEX_FLAG,
   BUILDER_PAYMENT_THRESHOLD_DENOMINATOR,
   BUILDER_PAYMENT_THRESHOLD_NUMERATOR,
   BUILDER_WITHDRAWAL_PREFIX,
+  DOMAIN_BUILDER_DEPOSIT,
   EFFECTIVE_BALANCE_INCREMENT,
   FAR_FUTURE_EPOCH,
   MIN_DEPOSIT_AMOUNT,
@@ -10,15 +13,18 @@ import {
   PTC_SIZE,
   SLOTS_PER_EPOCH,
 } from "@lodestar/params";
-import {BuilderIndex, Epoch, ValidatorIndex, gloas} from "@lodestar/types";
+import {BuilderIndex, Epoch, ValidatorIndex, gloas, ssz} from "@lodestar/types";
 import {AttestationData} from "@lodestar/types/phase0";
 import {byteArrayEquals} from "@lodestar/utils";
+import {ZERO_HASH} from "../constants/index.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
 import {getBlockRootAtSlot} from "./blockRoot.js";
+import {computeDomain} from "./domain.js";
 import {computeEpochAtSlot} from "./epoch.js";
 import {computeEpochShuffling} from "./epochShuffling.js";
 import {RootCache} from "./rootCache.js";
 import {computePayloadTimelinessCommitteesForEpoch} from "./seed.js";
+import {computeSigningRoot} from "./signingRoot.js";
 import {getActiveValidatorIndices} from "./validator.js";
 
 export function isBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
@@ -241,3 +247,72 @@ export function getPtcWindowEpochCacheData(state: CachedBeaconStateGloas): {
     nextPayloadTimelinessCommittees: toUint32Arrays(nextPtcWindow),
   };
 }
+
+/**
+ * Add a new builder to the builders registry. Reuses slots from exited and fully withdrawn
+ * builders when available, otherwise appends.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-add_builder_to_registry
+ */
+export function addBuilderToRegistry(
+  state: CachedBeaconStateGloas,
+  pubkey: Uint8Array,
+  version: number,
+  executionAddress: Uint8Array,
+  amount: number,
+  slot: number
+): void {
+  const currentEpoch = computeEpochAtSlot(state.slot);
+  const depositEpoch = computeEpochAtSlot(slot);
+
+  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;
+    }
+  }
+
+  const newBuilder = ssz.gloas.Builder.toViewDU({
+    pubkey,
+    version,
+    executionAddress,
+    balance: amount,
+    depositEpoch,
+    withdrawableEpoch: FAR_FUTURE_EPOCH,
+  });
+
+  if (builderIndex < state.builders.length) {
+    state.builders.set(builderIndex, newBuilder);
+  } else {
+    state.builders.push(newBuilder);
+  }
+}
+
+/**
+ * Verify the proof of possession on a builder deposit request.
+ *
+ * The dedicated `DOMAIN_BUILDER_DEPOSIT` (vs the validator `DOMAIN_DEPOSIT`) prevents replay
+ * of validator deposit signatures against the builder deposit contract and vice versa.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-is_valid_builder_deposit_signature
+ */
+export function isValidBuilderDepositSignature(
+  config: BeaconConfig,
+  pubkey: Uint8Array,
+  withdrawalCredentials: Uint8Array,
+  amount: number,
+  signature: Uint8Array
+): boolean {
+  const depositMessage = {pubkey, withdrawalCredentials, amount};
+  const domain = computeDomain(DOMAIN_BUILDER_DEPOSIT, config.GENESIS_FORK_VERSION, ZERO_HASH);
+  const signingRoot = computeSigningRoot(ssz.phase0.DepositMessage, depositMessage, domain);
+  try {
+    const publicKey = PublicKey.fromBytes(pubkey, true);
+    const sig = Signature.fromBytes(signature, true);
+    return verify(signingRoot, publicKey, sig);
+  } catch (_e) {
+    return false;
+  }
+}

package/src/util/shuffling.ts

@@ -21,8 +21,8 @@ import {EpochShuffling} from "./epochShuffling.js";
  * 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` when the genesis block decides its own shuffling (caller falls back to the
- * genesis block root).
+ * Returns `null` when the decision block is not in the state's past (the genesis block decides
+ * its own shuffling, or it has not been produced yet); caller supplies the fallback.
  */
 export function proposerShufflingDecisionRoot(
   fork: ForkName,
@@ -30,7 +30,8 @@ export function proposerShufflingDecisionRoot(
   proposalEpoch: Epoch
 ): Root | null {
   const decisionSlot = proposerShufflingDecisionSlot(fork, proposalEpoch);
-  if (state.slot === decisionSlot) {
+  // Return null when the decision block is not in the state's past or the getBlockRootAtSlot() api will throw
+  if (decisionSlot >= state.slot) {
     return null;
   }
   return state.getBlockRootAtSlot(decisionSlot);