@lodestar/state-transition 1.39.0-dev.86298a43e6 → 1.39.0-dev.90493ebb47

package/src/block/processAttestationPhase0.ts

@@ -54,7 +54,8 @@ export function processAttestationPhase0(
     !isValidIndexedAttestation(
       state.config,
       epochCtx.index2pubkey,
-      state,
+      state.slot,
+      state.validators.length,
       epochCtx.getIndexedAttestation(ForkSeq.phase0, attestation),
       verifySignature
     )

package/src/block/processAttesterSlashing.ts

@@ -1,5 +1,6 @@
+import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq} from "@lodestar/params";
-import {AttesterSlashing} from "@lodestar/types";
+import {AttesterSlashing, Slot} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {getAttesterSlashableIndices, isSlashableAttestationData, isSlashableValidator} from "../util/index.js";
@@ -19,7 +20,14 @@ export function processAttesterSlashing(
   verifySignatures = true
 ): void {
   const {epochCtx} = state;
-  assertValidAttesterSlashing(epochCtx.index2pubkey, state, attesterSlashing, verifySignatures);
+  assertValidAttesterSlashing(
+    state.config,
+    epochCtx.index2pubkey,
+    state.slot,
+    state.validators.length,
+    attesterSlashing,
+    verifySignatures
+  );
 
   const intersectingIndices = getAttesterSlashableIndices(attesterSlashing);
 
@@ -39,8 +47,10 @@ export function processAttesterSlashing(
 }
 
 export function assertValidAttesterSlashing(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
+  validatorsLen: number,
   attesterSlashing: AttesterSlashing,
   verifySignatures = true
 ): void {
@@ -55,7 +65,9 @@ export function assertValidAttesterSlashing(
   // be higher than the clock and the slashing would still be valid. Same applies to attestation data index, which
   // can be any arbitrary value. Must use bigint variants to hash correctly to all possible values
   for (const [i, attestation] of [attestation1, attestation2].entries()) {
-    if (!isValidIndexedAttestationBigint(state.config, index2pubkey, state, attestation, verifySignatures)) {
+    if (
+      !isValidIndexedAttestationBigint(config, index2pubkey, stateSlot, validatorsLen, attestation, verifySignatures)
+    ) {
       throw new Error(`AttesterSlashing attestation${i} is invalid`);
     }
   }

package/src/block/processBlsToExecutionChange.ts

@@ -1,7 +1,9 @@
 import {digest} from "@chainsafe/as-sha256";
 import {byteArrayEquals} from "@chainsafe/ssz";
+import {BeaconConfig} from "@lodestar/config";
 import {BLS_WITHDRAWAL_PREFIX, ETH1_ADDRESS_WITHDRAWAL_PREFIX} from "@lodestar/params";
 import {capella} from "@lodestar/types";
+import {Validator} from "@lodestar/types/phase0";
 import {toHex} from "@lodestar/utils";
 import {verifyBlsToExecutionChangeSignature} from "../signatureSets/index.js";
 import {CachedBeaconStateCapella} from "../types.js";
@@ -12,12 +14,18 @@ export function processBlsToExecutionChange(
 ): void {
   const addressChange = signedBlsToExecutionChange.message;
 
-  const validation = isValidBlsToExecutionChange(state, signedBlsToExecutionChange, true);
+  if (addressChange.validatorIndex >= state.validators.length) {
+    throw Error(
+      `withdrawalValidatorIndex ${addressChange.validatorIndex} >= state.validators len ${state.validators.length}`
+    );
+  }
+
+  const validator = state.validators.get(addressChange.validatorIndex);
+  const validation = isValidBlsToExecutionChange(state.config, validator, signedBlsToExecutionChange, true);
   if (!validation.valid) {
     throw validation.error;
   }
 
-  const validator = state.validators.get(addressChange.validatorIndex);
   const newWithdrawalCredentials = new Uint8Array(32);
   newWithdrawalCredentials[0] = ETH1_ADDRESS_WITHDRAWAL_PREFIX;
   newWithdrawalCredentials.set(addressChange.toExecutionAddress, 12);
@@ -27,22 +35,13 @@ export function processBlsToExecutionChange(
 }
 
 export function isValidBlsToExecutionChange(
-  state: CachedBeaconStateCapella,
+  config: BeaconConfig,
+  validator: Validator,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange,
   verifySignature = true
 ): {valid: true} | {valid: false; error: Error} {
   const addressChange = signedBLSToExecutionChange.message;
 
-  if (addressChange.validatorIndex >= state.validators.length) {
-    return {
-      valid: false,
-      error: Error(
-        `withdrawalValidatorIndex ${addressChange.validatorIndex} > state.validators len ${state.validators.length}`
-      ),
-    };
-  }
-
-  const validator = state.validators.getReadonly(addressChange.validatorIndex);
   const {withdrawalCredentials} = validator;
   if (withdrawalCredentials[0] !== BLS_WITHDRAWAL_PREFIX) {
     return {
@@ -65,7 +64,7 @@ export function isValidBlsToExecutionChange(
     };
   }
 
-  if (verifySignature && !verifyBlsToExecutionChangeSignature(state, signedBLSToExecutionChange)) {
+  if (verifySignature && !verifyBlsToExecutionChangeSignature(config, signedBLSToExecutionChange)) {
     return {
       valid: false,
       error: Error(

package/src/block/processProposerSlashing.ts

@@ -1,5 +1,8 @@
+import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {phase0, ssz} from "@lodestar/types";
+import {Slot, phase0, ssz} from "@lodestar/types";
+import {Validator} from "@lodestar/types/phase0";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot, isSlashableValidator} from "../util/index.js";
@@ -18,7 +21,15 @@ export function processProposerSlashing(
   proposerSlashing: phase0.ProposerSlashing,
   verifySignatures = true
 ): void {
-  assertValidProposerSlashing(state, proposerSlashing, verifySignatures);
+  const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
+  assertValidProposerSlashing(
+    state.config,
+    state.epochCtx.index2pubkey,
+    state.slot,
+    proposerSlashing,
+    proposer,
+    verifySignatures
+  );
 
   if (fork >= ForkSeq.gloas) {
     const slot = Number(proposerSlashing.signedHeader1.message.slot);
@@ -45,8 +56,11 @@ export function processProposerSlashing(
 }
 
 export function assertValidProposerSlashing(
-  state: CachedBeaconStateAllForks,
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
+  stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing,
+  proposer: Validator,
   verifySignatures = true
 ): void {
   const header1 = proposerSlashing.signedHeader1.message;
@@ -70,19 +84,15 @@ export function assertValidProposerSlashing(
   }
 
   // verify the proposer is slashable
-  const proposer = state.validators.getReadonly(header1.proposerIndex);
-  if (!isSlashableValidator(proposer, state.epochCtx.epoch)) {
+  // ideally we would get the proposer from state.validators using proposerIndex but that requires access to state
+  // instead of that we pass in the proposer directly from the consumer side
+  if (!isSlashableValidator(proposer, computeEpochAtSlot(stateSlot))) {
     throw new Error("ProposerSlashing proposer is not slashable");
   }
 
   // verify signatures
   if (verifySignatures) {
-    const signatureSets = getProposerSlashingSignatureSets(
-      state.config,
-      state.epochCtx.index2pubkey,
-      state.slot,
-      proposerSlashing
-    );
+    const signatureSets = getProposerSlashingSignatureSets(config, index2pubkey, stateSlot, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
       if (!verifySignatureSet(signatureSets[i])) {
         throw new Error(`ProposerSlashing header${i + 1} signature invalid`);

package/src/block/processWithdrawals.ts

@@ -9,7 +9,7 @@ import {
   MIN_ACTIVATION_BALANCE,
 } from "@lodestar/params";
 import {ValidatorIndex, capella, ssz} from "@lodestar/types";
-import {MapDef, toRootHex} from "@lodestar/utils";
+import {toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateCapella, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {isBuilderPaymentWithdrawable, isParentBlockFull} from "../util/gloas.ts";
 import {
@@ -30,13 +30,11 @@ export function processWithdrawals(
     return;
   }
 
-  // processedPartialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
   // processedBuilderWithdrawalsCount is withdrawals coming from builder payment since gloas (EIP-7732)
-  const {
-    withdrawals: expectedWithdrawals,
-    processedPartialWithdrawalsCount,
-    processedBuilderWithdrawalsCount,
-  } = getExpectedWithdrawals(fork, state);
+  // processedPartialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
+  // processedValidatorSweepCount is withdrawals coming from validator sweep
+  const {expectedWithdrawals, processedBuilderWithdrawalsCount, processedPartialWithdrawalsCount} =
+    getExpectedWithdrawals(fork, state);
   const numWithdrawals = expectedWithdrawals.length;
 
   // After gloas, withdrawals are verified later in processExecutionPayloadEnvelope
@@ -68,12 +66,10 @@ export function processWithdrawals(
     }
   }
 
-  for (let i = 0; i < numWithdrawals; i++) {
-    const withdrawal = expectedWithdrawals[i];
-    decreaseBalance(state, withdrawal.validatorIndex, Number(withdrawal.amount));
-  }
+  applyWithdrawals(state, expectedWithdrawals);
 
   if (fork >= ForkSeq.electra) {
+    // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.0/specs/electra/beacon-chain.md#new-update_pending_partial_withdrawals
     const stateElectra = state as CachedBeaconStateElectra;
     stateElectra.pendingPartialWithdrawals = stateElectra.pendingPartialWithdrawals.sliceFrom(
       processedPartialWithdrawalsCount
@@ -97,13 +93,14 @@ export function processWithdrawals(
       ...remainingWithdrawals,
     ]);
   }
-
   // 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
   const latestWithdrawal = expectedWithdrawals.at(-1);
   if (latestWithdrawal) {
     state.nextWithdrawalIndex = latestWithdrawal.index + 1;
   }
 
+  // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.0/specs/capella/beacon-chain.md#new-update_next_withdrawal_validator_index
   // Update the nextWithdrawalValidatorIndex
   if (latestWithdrawal && expectedWithdrawals.length === MAX_WITHDRAWALS_PER_PAYLOAD) {
     // All slots filled, nextWithdrawalValidatorIndex should be validatorIndex having next turn
@@ -116,142 +113,163 @@ export function processWithdrawals(
   }
 }
 
-export function getExpectedWithdrawals(
-  fork: ForkSeq,
-  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas
-): {
-  withdrawals: capella.Withdrawal[];
-  sampledValidators: number;
-  processedPartialWithdrawalsCount: number;
-  processedBuilderWithdrawalsCount: number;
-} {
-  if (fork < ForkSeq.capella) {
-    throw new Error(`getExpectedWithdrawals not supported at forkSeq=${fork} < ForkSeq.capella`);
-  }
-
+function getBuilderWithdrawals(
+  state: CachedBeaconStateGloas,
+  withdrawalIndex: number,
+  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+): {builderWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
+  const builderWithdrawals: capella.Withdrawal[] = [];
   const epoch = state.epochCtx.epoch;
-  let withdrawalIndex = state.nextWithdrawalIndex;
-  const {validators, balances, nextWithdrawalValidatorIndex} = state;
-
-  const withdrawals: capella.Withdrawal[] = [];
-  const withdrawnBalances = new MapDef<ValidatorIndex, number>(() => 0);
-  const isPostElectra = fork >= ForkSeq.electra;
-  const isPostGloas = fork >= ForkSeq.gloas;
-  // 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;
-
-  if (isPostGloas) {
-    const stateGloas = state as CachedBeaconStateGloas;
-
-    const allBuilderPendingWithdrawals =
-      stateGloas.builderPendingWithdrawals.length <= MAX_WITHDRAWALS_PER_PAYLOAD
-        ? stateGloas.builderPendingWithdrawals.getAllReadonly()
-        : null;
+  const allBuilderPendingWithdrawals =
+    state.builderPendingWithdrawals.length <= MAX_WITHDRAWALS_PER_PAYLOAD
+      ? state.builderPendingWithdrawals.getAllReadonly()
+      : null;
+
+  let processedCount = 0;
+  for (let i = 0; i < state.builderPendingWithdrawals.length; i++) {
+    const withdrawal = allBuilderPendingWithdrawals
+      ? allBuilderPendingWithdrawals[i]
+      : state.builderPendingWithdrawals.getReadonly(i);
+
+    if (withdrawal.withdrawableEpoch > epoch || builderWithdrawals.length === MAX_WITHDRAWALS_PER_PAYLOAD) {
+      break;
+    }
 
-    for (let i = 0; i < stateGloas.builderPendingWithdrawals.length; i++) {
-      const withdrawal = allBuilderPendingWithdrawals
-        ? allBuilderPendingWithdrawals[i]
-        : stateGloas.builderPendingWithdrawals.getReadonly(i);
+    if (isBuilderPaymentWithdrawable(state, withdrawal)) {
+      const builderIndex = withdrawal.builderIndex;
+      const builder = state.validators.get(withdrawal.builderIndex);
 
-      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length + 1 === MAX_WITHDRAWALS_PER_PAYLOAD) {
-        break;
+      let balance = balanceAfterWithdrawals.get(builderIndex);
+      if (balance === undefined) {
+        balance = state.balances.get(builderIndex);
+        balanceAfterWithdrawals.set(builderIndex, balance);
       }
 
-      if (isBuilderPaymentWithdrawable(stateGloas, withdrawal)) {
-        const totalWithdrawn = withdrawnBalances.getOrDefault(withdrawal.builderIndex);
-        const balance = state.balances.get(withdrawal.builderIndex) - totalWithdrawn;
-        const builder = state.validators.get(withdrawal.builderIndex);
-
-        let withdrawableBalance = 0;
+      let withdrawableBalance = 0;
 
-        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;
-        }
+      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;
+      }
 
-        if (withdrawableBalance > 0) {
-          withdrawals.push({
-            index: withdrawalIndex,
-            validatorIndex: withdrawal.builderIndex,
-            address: withdrawal.feeRecipient,
-            amount: BigInt(withdrawableBalance),
-          });
-          withdrawalIndex++;
-          withdrawnBalances.set(withdrawal.builderIndex, totalWithdrawn + withdrawableBalance);
-        }
+      if (withdrawableBalance > 0) {
+        builderWithdrawals.push({
+          index: withdrawalIndex,
+          validatorIndex: withdrawal.builderIndex,
+          address: withdrawal.feeRecipient,
+          amount: BigInt(withdrawableBalance),
+        });
+        withdrawalIndex++;
+        balanceAfterWithdrawals.set(builderIndex, balance - withdrawableBalance);
       }
-      processedBuilderWithdrawalsCount++;
     }
+    processedCount++;
   }
 
-  if (isPostElectra) {
-    // In pre-gloas, partialWithdrawalBound == MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP
-    const partialWithdrawalBound = Math.min(
-      withdrawals.length + MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
-      MAX_WITHDRAWALS_PER_PAYLOAD - 1
-    );
-    const stateElectra = state as CachedBeaconStateElectra;
+  return {builderWithdrawals, withdrawalIndex, processedCount};
+}
 
-    // MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP = 8, PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728 so we should only call getAllReadonly() if it makes sense
-    // pendingPartialWithdrawals comes from EIP-7002 smart contract where it takes fee so it's more likely than not validator is in correct condition to withdraw
-    // also we may break early if withdrawableEpoch > epoch
-    const allPendingPartialWithdrawals =
-      stateElectra.pendingPartialWithdrawals.length <= partialWithdrawalBound
-        ? stateElectra.pendingPartialWithdrawals.getAllReadonly()
-        : null;
-
-    // EIP-7002: Execution layer triggerable withdrawals
-    for (let i = 0; i < stateElectra.pendingPartialWithdrawals.length; i++) {
-      const withdrawal = allPendingPartialWithdrawals
-        ? allPendingPartialWithdrawals[i]
-        : stateElectra.pendingPartialWithdrawals.getReadonly(i);
-      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length === partialWithdrawalBound) {
-        break;
-      }
+function getPendingPartialWithdrawals(
+  state: CachedBeaconStateElectra,
+  withdrawalIndex: number,
+  numPriorWithdrawal: number,
+  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+): {pendingPartialWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
+  const epoch = state.epochCtx.epoch;
+  const pendingPartialWithdrawals: capella.Withdrawal[] = [];
+  const validators = state.validators;
+
+  // In pre-gloas, partialWithdrawalBound == MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP
+  const partialWithdrawalBound = Math.min(
+    numPriorWithdrawal + MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
+    MAX_WITHDRAWALS_PER_PAYLOAD - 1
+  );
+
+  // MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP = 8, PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728 so we should only call getAllReadonly() if it makes sense
+  // pendingPartialWithdrawals comes from EIP-7002 smart contract where it takes fee so it's more likely than not validator is in correct condition to withdraw
+  // also we may break early if withdrawableEpoch > epoch
+  const allPendingPartialWithdrawals =
+    state.pendingPartialWithdrawals.length <= partialWithdrawalBound
+      ? state.pendingPartialWithdrawals.getAllReadonly()
+      : null;
+
+  // EIP-7002: Execution layer triggerable withdrawals
+  let processedCount = 0;
+  for (let i = 0; i < state.pendingPartialWithdrawals.length; i++) {
+    const withdrawal = allPendingPartialWithdrawals
+      ? allPendingPartialWithdrawals[i]
+      : state.pendingPartialWithdrawals.getReadonly(i);
+    if (
+      withdrawal.withdrawableEpoch > epoch ||
+      pendingPartialWithdrawals.length + numPriorWithdrawal === partialWithdrawalBound
+    ) {
+      break;
+    }
 
-      const validator = validators.getReadonly(withdrawal.validatorIndex);
-      const totalWithdrawn = withdrawnBalances.getOrDefault(withdrawal.validatorIndex);
-      const balance = state.balances.get(withdrawal.validatorIndex) - totalWithdrawn;
-
-      if (
-        validator.exitEpoch === FAR_FUTURE_EPOCH &&
-        validator.effectiveBalance >= MIN_ACTIVATION_BALANCE &&
-        balance > MIN_ACTIVATION_BALANCE
-      ) {
-        const balanceOverMinActivationBalance = BigInt(balance - MIN_ACTIVATION_BALANCE);
-        const withdrawableBalance =
-          balanceOverMinActivationBalance < withdrawal.amount ? balanceOverMinActivationBalance : withdrawal.amount;
-        withdrawals.push({
-          index: withdrawalIndex,
-          validatorIndex: withdrawal.validatorIndex,
-          address: validator.withdrawalCredentials.subarray(12),
-          amount: withdrawableBalance,
-        });
-        withdrawalIndex++;
-        withdrawnBalances.set(withdrawal.validatorIndex, totalWithdrawn + Number(withdrawableBalance));
-      }
-      processedPartialWithdrawalsCount++;
+    const validatorIndex = withdrawal.validatorIndex;
+    const validator = validators.getReadonly(validatorIndex);
+    let balance = balanceAfterWithdrawals.get(validatorIndex);
+    if (balance === undefined) {
+      balance = state.balances.get(validatorIndex);
+      balanceAfterWithdrawals.set(validatorIndex, balance);
     }
+
+    if (
+      validator.exitEpoch === FAR_FUTURE_EPOCH &&
+      validator.effectiveBalance >= MIN_ACTIVATION_BALANCE &&
+      balance > MIN_ACTIVATION_BALANCE
+    ) {
+      const balanceOverMinActivationBalance = BigInt(balance - MIN_ACTIVATION_BALANCE);
+      const withdrawableBalance =
+        balanceOverMinActivationBalance < withdrawal.amount ? balanceOverMinActivationBalance : withdrawal.amount;
+      pendingPartialWithdrawals.push({
+        index: withdrawalIndex,
+        validatorIndex,
+        address: validator.withdrawalCredentials.subarray(12),
+        amount: withdrawableBalance,
+      });
+      withdrawalIndex++;
+      balanceAfterWithdrawals.set(validatorIndex, balance - Number(withdrawableBalance));
+    }
+    processedCount++;
   }
 
-  const withdrawalBound = Math.min(validators.length, MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP);
-  let n = 0;
+  return {pendingPartialWithdrawals, withdrawalIndex, processedCount};
+}
+
+function getValidatorsSweepWithdrawals(
+  fork: ForkSeq,
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas,
+  withdrawalIndex: number,
+  numPriorWithdrawal: number,
+  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+): {sweepWithdrawals: capella.Withdrawal[]; processedCount: number} {
+  const sweepWithdrawals: capella.Withdrawal[] = [];
+  const epoch = state.epochCtx.epoch;
+  const {validators, balances, nextWithdrawalValidatorIndex} = state;
+  const isPostElectra = fork >= ForkSeq.electra;
+
+  const validatorsLimit = Math.min(state.validators.length, MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP);
+  let processedCount = 0;
   // Just run a bounded loop max iterating over all withdrawals
   // however breaks out once we have MAX_WITHDRAWALS_PER_PAYLOAD
-  for (n = 0; n < withdrawalBound; n++) {
+  for (let n = 0; n < validatorsLimit; n++) {
+    if (sweepWithdrawals.length + numPriorWithdrawal === MAX_WITHDRAWALS_PER_PAYLOAD) {
+      break;
+    }
+
     // Get next validator in turn
     const validatorIndex = (nextWithdrawalValidatorIndex + n) % validators.length;
 
     const validator = validators.getReadonly(validatorIndex);
-    const withdrawnBalance = withdrawnBalances.getOrDefault(validatorIndex);
-    const balance = isPostElectra
-      ? // Deduct partially withdrawn balance already queued above
-        balances.get(validatorIndex) - withdrawnBalance
-      : balances.get(validatorIndex);
+    let balance = balanceAfterWithdrawals.get(validatorIndex);
+    if (balance === undefined) {
+      balance = balances.get(validatorIndex);
+      balanceAfterWithdrawals.set(validatorIndex, balance);
+    }
+
     const {withdrawableEpoch, withdrawalCredentials, effectiveBalance} = validator;
     const hasWithdrawableCredentials = isPostElectra
       ? hasExecutionWithdrawalCredential(withdrawalCredentials)
@@ -259,40 +277,117 @@ export function getExpectedWithdrawals(
     // early skip for balance = 0 as its now more likely that validator has exited/slashed with
     // balance zero than not have withdrawal credentials set
     if (balance === 0 || !hasWithdrawableCredentials) {
+      processedCount++;
       continue;
     }
 
     // capella full withdrawal
     if (withdrawableEpoch <= epoch) {
-      withdrawals.push({
+      sweepWithdrawals.push({
         index: withdrawalIndex,
         validatorIndex,
         address: validator.withdrawalCredentials.subarray(12),
         amount: BigInt(balance),
       });
       withdrawalIndex++;
-      withdrawnBalances.set(validatorIndex, withdrawnBalance + balance);
+      balanceAfterWithdrawals.set(validatorIndex, 0);
     } else if (
       effectiveBalance === (isPostElectra ? getMaxEffectiveBalance(withdrawalCredentials) : MAX_EFFECTIVE_BALANCE) &&
       balance > effectiveBalance
     ) {
       // capella partial withdrawal
       const partialAmount = balance - effectiveBalance;
-      withdrawals.push({
+      sweepWithdrawals.push({
         index: withdrawalIndex,
         validatorIndex,
         address: validator.withdrawalCredentials.subarray(12),
         amount: BigInt(partialAmount),
       });
       withdrawalIndex++;
-      withdrawnBalances.set(validatorIndex, withdrawnBalance + partialAmount);
+      balanceAfterWithdrawals.set(validatorIndex, balance - partialAmount);
     }
+    processedCount++;
+  }
 
-    // Break if we have enough to pack the block
-    if (withdrawals.length >= MAX_WITHDRAWALS_PER_PAYLOAD) {
-      break;
-    }
+  return {sweepWithdrawals, processedCount};
+}
+
+function applyWithdrawals(
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas,
+  withdrawals: capella.Withdrawal[]
+): void {
+  for (const withdrawal of withdrawals) {
+    decreaseBalance(state, withdrawal.validatorIndex, Number(withdrawal.amount));
   }
+}
 
-  return {withdrawals, sampledValidators: n, processedPartialWithdrawalsCount, processedBuilderWithdrawalsCount};
+export function getExpectedWithdrawals(
+  fork: ForkSeq,
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas
+): {
+  expectedWithdrawals: capella.Withdrawal[];
+  processedBuilderWithdrawalsCount: number;
+  processedPartialWithdrawalsCount: number;
+  processedValidatorSweepCount: number;
+} {
+  if (fork < ForkSeq.capella) {
+    throw new Error(`getExpectedWithdrawals not supported at forkSeq=${fork} < ForkSeq.capella`);
+  }
+
+  let withdrawalIndex = state.nextWithdrawalIndex;
+
+  const expectedWithdrawals: capella.Withdrawal[] = [];
+  // Map 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>();
+  // 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;
+
+  if (fork >= ForkSeq.gloas) {
+    const {
+      builderWithdrawals,
+      withdrawalIndex: newWithdrawalIndex,
+      processedCount,
+    } = getBuilderWithdrawals(state as CachedBeaconStateGloas, withdrawalIndex, balanceAfterWithdrawals);
+
+    expectedWithdrawals.push(...builderWithdrawals);
+    withdrawalIndex = newWithdrawalIndex;
+    processedBuilderWithdrawalsCount = processedCount;
+  }
+
+  if (fork >= ForkSeq.electra) {
+    const {
+      pendingPartialWithdrawals,
+      withdrawalIndex: newWithdrawalIndex,
+      processedCount,
+    } = getPendingPartialWithdrawals(
+      state as CachedBeaconStateElectra,
+      withdrawalIndex,
+      expectedWithdrawals.length,
+      balanceAfterWithdrawals
+    );
+
+    expectedWithdrawals.push(...pendingPartialWithdrawals);
+    withdrawalIndex = newWithdrawalIndex;
+    processedPartialWithdrawalsCount = processedCount;
+  }
+
+  const {sweepWithdrawals, processedCount: processedValidatorSweepCount} = getValidatorsSweepWithdrawals(
+    fork,
+    state,
+    withdrawalIndex,
+    expectedWithdrawals.length,
+    balanceAfterWithdrawals
+  );
+
+  expectedWithdrawals.push(...sweepWithdrawals);
+
+  return {
+    expectedWithdrawals,
+    processedBuilderWithdrawalsCount,
+    processedPartialWithdrawalsCount,
+    processedValidatorSweepCount,
+  };
 }

package/src/signatureSets/blsToExecutionChange.ts

@@ -2,14 +2,13 @@ import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BLS_TO_EXECUTION_CHANGE, ForkName} from "@lodestar/params";
 import {capella, ssz} from "@lodestar/types";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot, verifySignatureSet} from "../util/index.js";
 
 export function verifyBlsToExecutionChangeSignature(
-  state: CachedBeaconStateAllForks,
+  config: BeaconConfig,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange
 ): boolean {
-  return verifySignatureSet(getBlsToExecutionChangeSignatureSet(state.config, signedBLSToExecutionChange));
+  return verifySignatureSet(getBlsToExecutionChangeSignatureSet(config, signedBLSToExecutionChange));
 }
 
 /**