@lodestar/state-transition 1.40.0-dev.0ae7a89ead → 1.40.0-dev.4acd3ce568

package/src/block/processWithdrawals.ts

@@ -2,22 +2,29 @@ import {byteArrayEquals} from "@chainsafe/ssz";
 import {
   FAR_FUTURE_EPOCH,
   ForkSeq,
+  MAX_BUILDERS_PER_WITHDRAWALS_SWEEP,
   MAX_EFFECTIVE_BALANCE,
   MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
   MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP,
   MAX_WITHDRAWALS_PER_PAYLOAD,
   MIN_ACTIVATION_BALANCE,
 } from "@lodestar/params";
-import {ValidatorIndex, capella, ssz} from "@lodestar/types";
+import {BuilderIndex, ValidatorIndex, capella, ssz} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateCapella, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
-import {isBuilderPaymentWithdrawable, isParentBlockFull} from "../util/gloas.ts";
+import {
+  convertBuilderIndexToValidatorIndex,
+  convertValidatorIndexToBuilderIndex,
+  isBuilderIndex,
+  isParentBlockFull,
+} from "../util/gloas.ts";
 import {
   decreaseBalance,
   getMaxEffectiveBalance,
   hasEth1WithdrawalCredential,
   hasExecutionWithdrawalCredential,
   isCapellaPayloadHeader,
+  isPartiallyWithdrawableValidator,
 } from "../util/index.js";
 
 export function processWithdrawals(
@@ -32,9 +39,14 @@ export function processWithdrawals(
 
   // processedBuilderWithdrawalsCount is withdrawals coming from builder payment since gloas (EIP-7732)
   // processedPartialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
+  // processedBuildersSweepCount is withdrawals from builder sweep since gloas (EIP-7732)
   // processedValidatorSweepCount is withdrawals coming from validator sweep
-  const {expectedWithdrawals, processedBuilderWithdrawalsCount, processedPartialWithdrawalsCount} =
-    getExpectedWithdrawals(fork, state);
+  const {
+    expectedWithdrawals,
+    processedBuilderWithdrawalsCount,
+    processedPartialWithdrawalsCount,
+    processedBuildersSweepCount,
+  } = getExpectedWithdrawals(fork, state);
   const numWithdrawals = expectedWithdrawals.length;
 
   // After gloas, withdrawals are verified later in processExecutionPayloadEnvelope
@@ -78,20 +90,20 @@ export function processWithdrawals(
 
   if (fork >= ForkSeq.gloas) {
     const stateGloas = state as CachedBeaconStateGloas;
-    stateGloas.latestWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(expectedWithdrawals);
-
-    const unprocessedWithdrawals = stateGloas.builderPendingWithdrawals
-      .getAllReadonly()
-      .slice(0, processedBuilderWithdrawalsCount)
-      .filter((w) => !isBuilderPaymentWithdrawable(stateGloas, w));
-    const remainingWithdrawals = stateGloas.builderPendingWithdrawals
-      .sliceFrom(processedBuilderWithdrawalsCount)
-      .getAllReadonly();
-
-    stateGloas.builderPendingWithdrawals = ssz.gloas.BeaconState.fields.builderPendingWithdrawals.toViewDU([
-      ...unprocessedWithdrawals,
-      ...remainingWithdrawals,
-    ]);
+
+    // Store expected withdrawals for verification
+    stateGloas.payloadExpectedWithdrawals = ssz.capella.Withdrawals.toViewDU(expectedWithdrawals);
+
+    // Update builder pending withdrawals queue
+    stateGloas.builderPendingWithdrawals = stateGloas.builderPendingWithdrawals.sliceFrom(
+      processedBuilderWithdrawalsCount
+    );
+
+    // Update next builder index for sweep
+    if (stateGloas.builders.length > 0) {
+      const nextIndex = stateGloas.nextWithdrawalBuilderIndex + processedBuildersSweepCount;
+      stateGloas.nextWithdrawalBuilderIndex = nextIndex % stateGloas.builders.length;
+    }
   }
   // Update the nextWithdrawalIndex
   // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.0/specs/capella/beacon-chain.md#new-update_next_withdrawal_index
@@ -116,10 +128,11 @@ export function processWithdrawals(
 function getBuilderWithdrawals(
   state: CachedBeaconStateGloas,
   withdrawalIndex: number,
-  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+  priorWithdrawals: capella.Withdrawal[],
+  builderBalanceAfterWithdrawals: Map<number, number>
 ): {builderWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
+  const withdrawalsLimit = MAX_WITHDRAWALS_PER_PAYLOAD - 1;
   const builderWithdrawals: capella.Withdrawal[] = [];
-  const epoch = state.epochCtx.epoch;
   const allBuilderPendingWithdrawals =
     state.builderPendingWithdrawals.length <= MAX_WITHDRAWALS_PER_PAYLOAD
       ? state.builderPendingWithdrawals.getAllReadonly()
@@ -127,55 +140,100 @@ function getBuilderWithdrawals(
 
   let processedCount = 0;
   for (let i = 0; i < state.builderPendingWithdrawals.length; i++) {
+    // Check combined length against limit
+    const allWithdrawals = priorWithdrawals.length + builderWithdrawals.length;
+    if (allWithdrawals >= withdrawalsLimit) {
+      break;
+    }
+
     const withdrawal = allBuilderPendingWithdrawals
       ? allBuilderPendingWithdrawals[i]
       : state.builderPendingWithdrawals.getReadonly(i);
 
-    if (withdrawal.withdrawableEpoch > epoch || builderWithdrawals.length === MAX_WITHDRAWALS_PER_PAYLOAD) {
-      break;
+    const builderIndex = withdrawal.builderIndex;
+
+    // Get builder balance (from builder.balance, not state.balances)
+    let balance = builderBalanceAfterWithdrawals.get(builderIndex);
+    if (balance === undefined) {
+      balance = state.builders.getReadonly(builderIndex).balance;
+      builderBalanceAfterWithdrawals.set(builderIndex, balance);
     }
 
-    if (isBuilderPaymentWithdrawable(state, withdrawal)) {
-      const builderIndex = withdrawal.builderIndex;
-      const builder = state.validators.get(withdrawal.builderIndex);
+    // Use the withdrawal amount directly as specified in the spec
+    builderWithdrawals.push({
+      index: withdrawalIndex,
+      validatorIndex: convertBuilderIndexToValidatorIndex(builderIndex),
+      address: withdrawal.feeRecipient,
+      amount: BigInt(withdrawal.amount),
+    });
+    withdrawalIndex++;
+    builderBalanceAfterWithdrawals.set(builderIndex, balance - withdrawal.amount);
 
-      let balance = balanceAfterWithdrawals.get(builderIndex);
-      if (balance === undefined) {
-        balance = state.balances.get(builderIndex);
-        balanceAfterWithdrawals.set(builderIndex, balance);
-      }
+    processedCount++;
+  }
 
-      let withdrawableBalance = 0;
+  return {builderWithdrawals, withdrawalIndex, processedCount};
+}
 
-      if (builder.slashed) {
-        withdrawableBalance = balance < withdrawal.amount ? balance : withdrawal.amount;
-      } else if (balance > MIN_ACTIVATION_BALANCE) {
-        withdrawableBalance =
-          balance - MIN_ACTIVATION_BALANCE < withdrawal.amount ? balance - MIN_ACTIVATION_BALANCE : withdrawal.amount;
-      }
+function getBuildersSweepWithdrawals(
+  state: CachedBeaconStateGloas,
+  withdrawalIndex: number,
+  numPriorWithdrawal: number,
+  builderBalanceAfterWithdrawals: Map<number, number>
+): {buildersSweepWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
+  const withdrawalsLimit = MAX_WITHDRAWALS_PER_PAYLOAD - 1;
+  const buildersSweepWithdrawals: capella.Withdrawal[] = [];
+  const epoch = state.epochCtx.epoch;
+  const builders = state.builders;
 
-      if (withdrawableBalance > 0) {
-        builderWithdrawals.push({
-          index: withdrawalIndex,
-          validatorIndex: withdrawal.builderIndex,
-          address: withdrawal.feeRecipient,
-          amount: BigInt(withdrawableBalance),
-        });
-        withdrawalIndex++;
-        balanceAfterWithdrawals.set(builderIndex, balance - withdrawableBalance);
-      }
+  // Return early if no builders
+  if (builders.length === 0) {
+    return {buildersSweepWithdrawals, withdrawalIndex, processedCount: 0};
+  }
+
+  const buildersLimit = Math.min(builders.length, MAX_BUILDERS_PER_WITHDRAWALS_SWEEP);
+  let processedCount = 0;
+
+  for (let n = 0; n < buildersLimit; n++) {
+    if (buildersSweepWithdrawals.length + numPriorWithdrawal >= withdrawalsLimit) {
+      break;
+    }
+
+    // Get next builder in turn
+    const builderIndex = (state.nextWithdrawalBuilderIndex + n) % builders.length;
+    const builder = builders.getReadonly(builderIndex);
+
+    // Get builder balance
+    let balance = builderBalanceAfterWithdrawals.get(builderIndex);
+    if (balance === undefined) {
+      balance = builder.balance;
+      builderBalanceAfterWithdrawals.set(builderIndex, balance);
     }
+
+    // Check if builder is withdrawable and has balance
+    if (builder.withdrawableEpoch <= epoch && balance > 0) {
+      // Withdraw full balance to builder's execution address
+      buildersSweepWithdrawals.push({
+        index: withdrawalIndex,
+        validatorIndex: convertBuilderIndexToValidatorIndex(builderIndex),
+        address: builder.executionAddress,
+        amount: BigInt(balance),
+      });
+      withdrawalIndex++;
+      builderBalanceAfterWithdrawals.set(builderIndex, 0);
+    }
+
     processedCount++;
   }
 
-  return {builderWithdrawals, withdrawalIndex, processedCount};
+  return {buildersSweepWithdrawals, withdrawalIndex, processedCount};
 }
 
 function getPendingPartialWithdrawals(
   state: CachedBeaconStateElectra,
   withdrawalIndex: number,
   numPriorWithdrawal: number,
-  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+  validatorBalanceAfterWithdrawals: Map<ValidatorIndex, number>
 ): {pendingPartialWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
   const epoch = state.epochCtx.epoch;
   const pendingPartialWithdrawals: capella.Withdrawal[] = [];
@@ -203,17 +261,17 @@ function getPendingPartialWithdrawals(
       : state.pendingPartialWithdrawals.getReadonly(i);
     if (
       withdrawal.withdrawableEpoch > epoch ||
-      pendingPartialWithdrawals.length + numPriorWithdrawal === partialWithdrawalBound
+      pendingPartialWithdrawals.length + numPriorWithdrawal >= partialWithdrawalBound
     ) {
       break;
     }
 
     const validatorIndex = withdrawal.validatorIndex;
     const validator = validators.getReadonly(validatorIndex);
-    let balance = balanceAfterWithdrawals.get(validatorIndex);
+    let balance = validatorBalanceAfterWithdrawals.get(validatorIndex);
     if (balance === undefined) {
       balance = state.balances.get(validatorIndex);
-      balanceAfterWithdrawals.set(validatorIndex, balance);
+      validatorBalanceAfterWithdrawals.set(validatorIndex, balance);
     }
 
     if (
@@ -231,7 +289,7 @@ function getPendingPartialWithdrawals(
         amount: withdrawableBalance,
       });
       withdrawalIndex++;
-      balanceAfterWithdrawals.set(validatorIndex, balance - Number(withdrawableBalance));
+      validatorBalanceAfterWithdrawals.set(validatorIndex, balance - Number(withdrawableBalance));
     }
     processedCount++;
   }
@@ -244,7 +302,7 @@ function getValidatorsSweepWithdrawals(
   state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas,
   withdrawalIndex: number,
   numPriorWithdrawal: number,
-  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+  validatorBalanceAfterWithdrawals: Map<ValidatorIndex, number>
 ): {sweepWithdrawals: capella.Withdrawal[]; processedCount: number} {
   const sweepWithdrawals: capella.Withdrawal[] = [];
   const epoch = state.epochCtx.epoch;
@@ -264,13 +322,13 @@ function getValidatorsSweepWithdrawals(
     const validatorIndex = (nextWithdrawalValidatorIndex + n) % validators.length;
 
     const validator = validators.getReadonly(validatorIndex);
-    let balance = balanceAfterWithdrawals.get(validatorIndex);
+    let balance = validatorBalanceAfterWithdrawals.get(validatorIndex);
     if (balance === undefined) {
       balance = balances.get(validatorIndex);
-      balanceAfterWithdrawals.set(validatorIndex, balance);
+      validatorBalanceAfterWithdrawals.set(validatorIndex, balance);
     }
 
-    const {withdrawableEpoch, withdrawalCredentials, effectiveBalance} = validator;
+    const {withdrawableEpoch, withdrawalCredentials} = validator;
     const hasWithdrawableCredentials = isPostElectra
       ? hasExecutionWithdrawalCredential(withdrawalCredentials)
       : hasEth1WithdrawalCredential(withdrawalCredentials);
@@ -290,13 +348,11 @@ function getValidatorsSweepWithdrawals(
         amount: BigInt(balance),
       });
       withdrawalIndex++;
-      balanceAfterWithdrawals.set(validatorIndex, 0);
-    } else if (
-      effectiveBalance === (isPostElectra ? getMaxEffectiveBalance(withdrawalCredentials) : MAX_EFFECTIVE_BALANCE) &&
-      balance > effectiveBalance
-    ) {
+      validatorBalanceAfterWithdrawals.set(validatorIndex, 0);
+    } else if (isPartiallyWithdrawableValidator(fork, validator, balance)) {
       // capella partial withdrawal
-      const partialAmount = balance - effectiveBalance;
+      const maxEffectiveBalance = isPostElectra ? getMaxEffectiveBalance(withdrawalCredentials) : MAX_EFFECTIVE_BALANCE;
+      const partialAmount = balance - maxEffectiveBalance;
       sweepWithdrawals.push({
         index: withdrawalIndex,
         validatorIndex,
@@ -304,7 +360,7 @@ function getValidatorsSweepWithdrawals(
         amount: BigInt(partialAmount),
       });
       withdrawalIndex++;
-      balanceAfterWithdrawals.set(validatorIndex, balance - partialAmount);
+      validatorBalanceAfterWithdrawals.set(validatorIndex, balance - partialAmount);
     }
     processedCount++;
   }
@@ -317,7 +373,16 @@ function applyWithdrawals(
   withdrawals: capella.Withdrawal[]
 ): void {
   for (const withdrawal of withdrawals) {
-    decreaseBalance(state, withdrawal.validatorIndex, Number(withdrawal.amount));
+    if (isBuilderIndex(withdrawal.validatorIndex)) {
+      // Handle builder withdrawal
+      const builderIndex = convertValidatorIndexToBuilderIndex(withdrawal.validatorIndex);
+      const builder = (state as CachedBeaconStateGloas).builders.get(builderIndex);
+      const withdrawalAmount = Number(withdrawal.amount);
+      builder.balance -= Math.min(withdrawalAmount, builder.balance);
+    } else {
+      // Handle validator withdrawal
+      decreaseBalance(state, withdrawal.validatorIndex, Number(withdrawal.amount));
+    }
   }
 }
 
@@ -328,6 +393,7 @@ export function getExpectedWithdrawals(
   expectedWithdrawals: capella.Withdrawal[];
   processedBuilderWithdrawalsCount: number;
   processedPartialWithdrawalsCount: number;
+  processedBuildersSweepCount: number;
   processedValidatorSweepCount: number;
 } {
   if (fork < ForkSeq.capella) {
@@ -337,20 +403,28 @@ export function getExpectedWithdrawals(
   let withdrawalIndex = state.nextWithdrawalIndex;
 
   const expectedWithdrawals: capella.Withdrawal[] = [];
-  // Map to track balances after applying withdrawals
+  // Separate maps to track balances after applying withdrawals
   // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.0/specs/capella/beacon-chain.md#new-get_balance_after_withdrawals
-  const balanceAfterWithdrawals = new Map<ValidatorIndex, number>();
+  const builderBalanceAfterWithdrawals = new Map<BuilderIndex, number>();
+  const validatorBalanceAfterWithdrawals = new Map<ValidatorIndex, number>();
   // partialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
   let processedPartialWithdrawalsCount = 0;
   // builderWithdrawalsCount is withdrawals coming from builder payments since Gloas (EIP-7732)
   let processedBuilderWithdrawalsCount = 0;
+  // buildersSweepCount is withdrawals from builder sweep since Gloas (EIP-7732)
+  let processedBuildersSweepCount = 0;
 
   if (fork >= ForkSeq.gloas) {
     const {
       builderWithdrawals,
       withdrawalIndex: newWithdrawalIndex,
       processedCount,
-    } = getBuilderWithdrawals(state as CachedBeaconStateGloas, withdrawalIndex, balanceAfterWithdrawals);
+    } = getBuilderWithdrawals(
+      state as CachedBeaconStateGloas,
+      withdrawalIndex,
+      expectedWithdrawals,
+      builderBalanceAfterWithdrawals
+    );
 
     expectedWithdrawals.push(...builderWithdrawals);
     withdrawalIndex = newWithdrawalIndex;
@@ -366,7 +440,7 @@ export function getExpectedWithdrawals(
       state as CachedBeaconStateElectra,
       withdrawalIndex,
       expectedWithdrawals.length,
-      balanceAfterWithdrawals
+      validatorBalanceAfterWithdrawals
     );
 
     expectedWithdrawals.push(...pendingPartialWithdrawals);
@@ -374,12 +448,29 @@ export function getExpectedWithdrawals(
     processedPartialWithdrawalsCount = processedCount;
   }
 
+  if (fork >= ForkSeq.gloas) {
+    const {
+      buildersSweepWithdrawals,
+      withdrawalIndex: newWithdrawalIndex,
+      processedCount,
+    } = getBuildersSweepWithdrawals(
+      state as CachedBeaconStateGloas,
+      withdrawalIndex,
+      expectedWithdrawals.length,
+      builderBalanceAfterWithdrawals
+    );
+
+    expectedWithdrawals.push(...buildersSweepWithdrawals);
+    withdrawalIndex = newWithdrawalIndex;
+    processedBuildersSweepCount = processedCount;
+  }
+
   const {sweepWithdrawals, processedCount: processedValidatorSweepCount} = getValidatorsSweepWithdrawals(
     fork,
     state,
     withdrawalIndex,
     expectedWithdrawals.length,
-    balanceAfterWithdrawals
+    validatorBalanceAfterWithdrawals
   );
 
   expectedWithdrawals.push(...sweepWithdrawals);
@@ -388,6 +479,7 @@ export function getExpectedWithdrawals(
     expectedWithdrawals,
     processedBuilderWithdrawalsCount,
     processedPartialWithdrawalsCount,
+    processedBuildersSweepCount,
     processedValidatorSweepCount,
   };
 }

package/src/epoch/processBuilderPendingPayments.ts

@@ -1,7 +1,6 @@
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {CachedBeaconStateGloas} from "../types.ts";
-import {computeExitEpochAndUpdateChurn} from "../util/epoch.ts";
 import {getBuilderPaymentQuorumThreshold} from "../util/gloas.ts";
 
 /**
@@ -12,10 +11,7 @@ export function processBuilderPendingPayments(state: CachedBeaconStateGloas): vo
 
   for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
     const payment = state.builderPendingPayments.get(i);
-    if (payment.weight > quorum) {
-      const exitQueueEpoch = computeExitEpochAndUpdateChurn(state, BigInt(payment.withdrawal.amount));
-      payment.withdrawal.withdrawableEpoch = exitQueueEpoch + state.config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY;
-
+    if (payment.weight >= quorum) {
       state.builderPendingWithdrawals.push(payment.withdrawal);
     }
   }

package/src/util/electra.ts

@@ -3,12 +3,9 @@ import {ValidatorIndex, ssz} from "@lodestar/types";
 import {G2_POINT_AT_INFINITY} from "../constants/constants.js";
 import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasEth1WithdrawalCredential} from "./capella.js";
-import {hasBuilderWithdrawalCredential} from "./gloas.ts";
 
 export function hasCompoundingWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
-  return (
-    withdrawalCredentials[0] === COMPOUNDING_WITHDRAWAL_PREFIX || hasBuilderWithdrawalCredential(withdrawalCredentials)
-  );
+  return withdrawalCredentials[0] === COMPOUNDING_WITHDRAWAL_PREFIX;
 }
 
 export function hasExecutionWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {

package/src/util/gloas.ts

@@ -1,19 +1,21 @@
 import {byteArrayEquals} from "@chainsafe/ssz";
 import {
+  BUILDER_INDEX_FLAG,
   BUILDER_PAYMENT_THRESHOLD_DENOMINATOR,
   BUILDER_PAYMENT_THRESHOLD_NUMERATOR,
   BUILDER_WITHDRAWAL_PREFIX,
   EFFECTIVE_BALANCE_INCREMENT,
+  FAR_FUTURE_EPOCH,
+  MIN_DEPOSIT_AMOUNT,
   SLOTS_PER_EPOCH,
 } from "@lodestar/params";
-import {gloas} from "@lodestar/types";
 import {AttestationData} from "@lodestar/types/phase0";
 import {CachedBeaconStateGloas} from "../types.ts";
 import {getBlockRootAtSlot} from "./blockRoot.ts";
 import {computeEpochAtSlot} from "./epoch.ts";
 import {RootCache} from "./rootCache.ts";
 
-export function hasBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
+export function isBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
   return withdrawalCredentials[0] === BUILDER_WITHDRAWAL_PREFIX;
 }
 
@@ -25,14 +27,113 @@ export function getBuilderPaymentQuorumThreshold(state: CachedBeaconStateGloas):
   return Math.floor(quorum / BUILDER_PAYMENT_THRESHOLD_DENOMINATOR);
 }
 
-export function isBuilderPaymentWithdrawable(
-  state: CachedBeaconStateGloas,
-  withdrawal: gloas.BuilderPendingWithdrawal
-): boolean {
-  const builder = state.validators.getReadonly(withdrawal.builderIndex);
+/**
+ * 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;
+}
+
+/**
+ * Convert a builder index to a flagged validator index for use in Withdrawal containers.
+ * 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: number): number {
+  return builderIndex | BUILDER_INDEX_FLAG;
+}
+
+/**
+ * Convert a flagged validator index back to a builder index.
+ * 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: number): number {
+  return validatorIndex & ~BUILDER_INDEX_FLAG;
+}
+
+/**
+ * Check if a builder is active (deposited and not yet withdrawable).
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#isactivebuilder
+ */
+export function isActiveBuilder(state: CachedBeaconStateGloas, builderIndex: number): boolean {
+  const builder = state.builders.getReadonly(builderIndex);
+  const finalizedEpoch = state.finalizedCheckpoint.epoch;
+
+  return builder.depositEpoch < finalizedEpoch && builder.withdrawableEpoch === FAR_FUTURE_EPOCH;
+}
+
+/**
+ * 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
+ */
+export function getPendingBalanceToWithdrawForBuilder(state: CachedBeaconStateGloas, builderIndex: number): number {
+  let pendingBalance = 0;
+
+  // Sum pending withdrawals
+  for (let i = 0; i < state.builderPendingWithdrawals.length; i++) {
+    const withdrawal = state.builderPendingWithdrawals.getReadonly(i);
+    if (withdrawal.builderIndex === builderIndex) {
+      pendingBalance += withdrawal.amount;
+    }
+  }
+
+  // Sum pending payments
+  for (let i = 0; i < state.builderPendingPayments.length; i++) {
+    const payment = state.builderPendingPayments.getReadonly(i);
+    if (payment.withdrawal.builderIndex === builderIndex) {
+      pendingBalance += payment.withdrawal.amount;
+    }
+  }
+
+  return pendingBalance;
+}
+
+/**
+ * Check if a builder has sufficient balance to cover a bid amount.
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-can_builder_cover_bid
+ */
+export function canBuilderCoverBid(state: CachedBeaconStateGloas, builderIndex: number, bidAmount: number): boolean {
+  const builder = state.builders.getReadonly(builderIndex);
+  const pendingBalance = getPendingBalanceToWithdrawForBuilder(state, builderIndex);
+  const minBalance = MIN_DEPOSIT_AMOUNT + pendingBalance;
+
+  if (builder.balance < minBalance) {
+    return false;
+  }
+
+  return builder.balance - minBalance >= bidAmount;
+}
+
+/**
+ * Initiate a builder exit by setting their withdrawable epoch.
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-initiate_builder_exit
+ */
+export function initiateBuilderExit(state: CachedBeaconStateGloas, builderIndex: number): void {
+  const builder = state.builders.get(builderIndex);
+
+  // Return if builder already initiated exit
+  if (builder.withdrawableEpoch !== FAR_FUTURE_EPOCH) {
+    return;
+  }
+
+  // Set builder exit epoch
   const currentEpoch = computeEpochAtSlot(state.slot);
+  builder.withdrawableEpoch = currentEpoch + state.config.MIN_BUILDER_WITHDRAWABILITY_DELAY;
+}
 
-  return builder.withdrawableEpoch >= currentEpoch || !builder.slashed;
+/**
+ * Find the index of a builder by their public key.
+ * Returns null if not found.
+ *
+ * May consider builder pubkey cache if performance becomes an issue.
+ */
+export function findBuilderIndexByPubkey(state: CachedBeaconStateGloas, pubkey: Uint8Array): number | null {
+  for (let i = 0; i < state.builders.length; i++) {
+    if (byteArrayEquals(state.builders.getReadonly(i).pubkey, pubkey)) {
+      return i;
+    }
+  }
+  return null;
 }
 
 export function isAttestationSameSlot(state: CachedBeaconStateGloas, data: AttestationData): boolean {

package/src/util/validator.ts

@@ -2,13 +2,15 @@ import {ChainForkConfig} from "@lodestar/config";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
   ForkSeq,
+  MAX_EFFECTIVE_BALANCE,
   MAX_EFFECTIVE_BALANCE_ELECTRA,
   MIN_ACTIVATION_BALANCE,
 } from "@lodestar/params";
 import {Epoch, ValidatorIndex, phase0} from "@lodestar/types";
 import {intDiv} from "@lodestar/utils";
 import {BeaconStateAllForks, CachedBeaconStateElectra, CachedBeaconStateGloas, EpochCache} from "../types.js";
-import {hasCompoundingWithdrawalCredential} from "./electra.js";
+import {hasEth1WithdrawalCredential} from "./capella.js";
+import {hasCompoundingWithdrawalCredential, hasExecutionWithdrawalCredential} from "./electra.js";
 
 /**
  * Check if [[validator]] is active
@@ -94,6 +96,34 @@ export function getMaxEffectiveBalance(withdrawalCredentials: Uint8Array): numbe
   return MIN_ACTIVATION_BALANCE;
 }
 
+/**
+ * Check if validator is partially withdrawable.
+ * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/electra/beacon-chain.md#modified-is_partially_withdrawable_validator
+ */
+export function isPartiallyWithdrawableValidator(fork: ForkSeq, validator: phase0.Validator, balance: number): boolean {
+  const isPostElectra = fork >= ForkSeq.electra;
+
+  // Check withdrawal credentials
+  const hasWithdrawableCredentials = isPostElectra
+    ? hasExecutionWithdrawalCredential(validator.withdrawalCredentials)
+    : hasEth1WithdrawalCredential(validator.withdrawalCredentials);
+
+  if (!hasWithdrawableCredentials) {
+    return false;
+  }
+
+  // Get max effective balance based on fork
+  const maxEffectiveBalance = isPostElectra
+    ? getMaxEffectiveBalance(validator.withdrawalCredentials)
+    : MAX_EFFECTIVE_BALANCE;
+
+  // Check if at max effective balance and has excess balance
+  const hasMaxEffectiveBalance = validator.effectiveBalance === maxEffectiveBalance;
+  const hasExcessBalance = balance > maxEffectiveBalance;
+
+  return hasMaxEffectiveBalance && hasExcessBalance;
+}
+
 export function getPendingBalanceToWithdraw(
   fork: ForkSeq,
   state: CachedBeaconStateElectra | CachedBeaconStateGloas,