@lodestar/state-transition 1.40.0-dev.0ae7a89ead → 1.40.0-dev.193b2e2047

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,14 @@ 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;
+  if (priorWithdrawals.length > withdrawalsLimit) {
+    throw Error(`Prior withdrawals exceed limit: ${priorWithdrawals.length} > ${withdrawalsLimit}`);
+  }
   const builderWithdrawals: capella.Withdrawal[] = [];
-  const epoch = state.epochCtx.epoch;
   const allBuilderPendingWithdrawals =
     state.builderPendingWithdrawals.length <= MAX_WITHDRAWALS_PER_PAYLOAD
       ? state.builderPendingWithdrawals.getAllReadonly()
@@ -127,55 +143,103 @@ 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;
+  if (numPriorWithdrawal > withdrawalsLimit) {
+    throw Error(`Prior withdrawals exceed limit: ${numPriorWithdrawal} > ${withdrawalsLimit}`);
+  }
+  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 +267,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 +295,7 @@ function getPendingPartialWithdrawals(
         amount: withdrawableBalance,
       });
       withdrawalIndex++;
-      balanceAfterWithdrawals.set(validatorIndex, balance - Number(withdrawableBalance));
+      validatorBalanceAfterWithdrawals.set(validatorIndex, balance - Number(withdrawableBalance));
     }
     processedCount++;
   }
@@ -244,7 +308,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 +328,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 +354,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 +366,7 @@ function getValidatorsSweepWithdrawals(
         amount: BigInt(partialAmount),
       });
       withdrawalIndex++;
-      balanceAfterWithdrawals.set(validatorIndex, balance - partialAmount);
+      validatorBalanceAfterWithdrawals.set(validatorIndex, balance - partialAmount);
     }
     processedCount++;
   }
@@ -317,7 +379,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 +399,7 @@ export function getExpectedWithdrawals(
   expectedWithdrawals: capella.Withdrawal[];
   processedBuilderWithdrawalsCount: number;
   processedPartialWithdrawalsCount: number;
+  processedBuildersSweepCount: number;
   processedValidatorSweepCount: number;
 } {
   if (fork < ForkSeq.capella) {
@@ -337,20 +409,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 +446,7 @@ export function getExpectedWithdrawals(
       state as CachedBeaconStateElectra,
       withdrawalIndex,
       expectedWithdrawals.length,
-      balanceAfterWithdrawals
+      validatorBalanceAfterWithdrawals
     );
 
     expectedWithdrawals.push(...pendingPartialWithdrawals);
@@ -374,12 +454,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 +485,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/signatureSets/attesterSlashings.ts

@@ -1,38 +1,34 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
 import {AttesterSlashing, IndexedAttestationBigint, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot, computeStartSlotAtEpoch} from "../util/index.js";
 
 /** Get signature sets from all AttesterSlashing objects in a block */
 export function getAttesterSlashingsSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
   // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
   const blockSlot = signedBlock.message.slot;
   return signedBlock.message.body.attesterSlashings.flatMap((attesterSlashing) =>
-    getAttesterSlashingSignatureSets(config, index2pubkey, blockSlot, attesterSlashing)
+    getAttesterSlashingSignatureSets(config, blockSlot, attesterSlashing)
   );
 }
 
 /** Get signature sets from a single AttesterSlashing object */
 export function getAttesterSlashingSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   attesterSlashing: AttesterSlashing
 ): ISignatureSet[] {
   return [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
-    getIndexedAttestationBigintSignatureSet(config, index2pubkey, stateSlot, attestation)
+    getIndexedAttestationBigintSignatureSet(config, stateSlot, attestation)
   );
 }
 
 export function getIndexedAttestationBigintSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   indexedAttestation: IndexedAttestationBigint
 ): ISignatureSet {
@@ -41,7 +37,7 @@ export function getIndexedAttestationBigintSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: indexedAttestation.attestingIndices.map((i) => index2pubkey[i]),
+    indices: indexedAttestation.attestingIndices.map((i) => Number(i)),
     signingRoot: computeSigningRoot(ssz.phase0.AttestationDataBigint, indexedAttestation.data, domain),
     signature: indexedAttestation.signature,
   };

package/src/signatureSets/blsToExecutionChange.ts

@@ -2,7 +2,7 @@ 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 {ISignatureSet, SignatureSetType, computeSigningRoot, verifySignatureSet} from "../util/index.js";
+import {SignatureSetType, SingleSignatureSet, computeSigningRoot, verifySignatureSet} from "../util/index.js";
 
 export function verifyBlsToExecutionChangeSignature(
   config: BeaconConfig,
@@ -17,7 +17,7 @@ export function verifyBlsToExecutionChangeSignature(
 export function getBlsToExecutionChangeSignatureSet(
   config: BeaconConfig,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange
-): ISignatureSet {
+): SingleSignatureSet {
   // signatureFork for signing domain is fixed
   const signatureFork = ForkName.phase0;
   const domain = config.getDomainAtFork(signatureFork, DOMAIN_BLS_TO_EXECUTION_CHANGE);
@@ -35,7 +35,7 @@ export function getBlsToExecutionChangeSignatureSet(
 export function getBlsToExecutionChangeSignatureSets(
   config: BeaconConfig,
   signedBlock: capella.SignedBeaconBlock
-): ISignatureSet[] {
+): SingleSignatureSet[] {
   return signedBlock.message.body.blsToExecutionChanges.map((blsToExecutionChange) =>
     getBlsToExecutionChangeSignatureSet(config, blsToExecutionChange)
   );

package/src/signatureSets/executionPayloadBid.ts

@@ -0,0 +1,14 @@
+import {BeaconConfig} from "@lodestar/config";
+import {DOMAIN_BEACON_BUILDER} from "@lodestar/params";
+import {Slot, gloas, ssz} from "@lodestar/types";
+import {computeSigningRoot} from "../util/index.js";
+
+export function getExecutionPayloadBidSigningRoot(
+  config: BeaconConfig,
+  stateSlot: Slot,
+  bid: gloas.ExecutionPayloadBid
+): Uint8Array {
+  const domain = config.getDomain(stateSlot, DOMAIN_BEACON_BUILDER);
+
+  return computeSigningRoot(ssz.gloas.ExecutionPayloadBid, bid, domain);
+}

package/src/signatureSets/executionPayloadEnvelope.ts

@@ -0,0 +1,13 @@
+import {BeaconConfig} from "@lodestar/config";
+import {DOMAIN_BEACON_BUILDER} from "@lodestar/params";
+import {gloas, ssz} from "@lodestar/types";
+import {computeSigningRoot} from "../util/index.js";
+
+export function getExecutionPayloadEnvelopeSigningRoot(
+  config: BeaconConfig,
+  envelope: gloas.ExecutionPayloadEnvelope
+): Uint8Array {
+  const domain = config.getDomain(envelope.slot, DOMAIN_BEACON_BUILDER);
+
+  return computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, envelope, domain);
+}

package/src/signatureSets/index.ts

@@ -2,7 +2,6 @@ import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, altair, capella} from "@lodestar/types";
 import {getSyncCommitteeSignatureSet} from "../block/processSyncCommittee.js";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
 import {ISignatureSet} from "../util/index.js";
 import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
@@ -15,6 +14,8 @@ import {getVoluntaryExitsSignatureSets} from "./voluntaryExits.js";
 
 export * from "./attesterSlashings.js";
 export * from "./blsToExecutionChange.js";
+export * from "./executionPayloadBid.js";
+export * from "./executionPayloadEnvelope.js";
 export * from "./indexedAttestation.js";
 export * from "./indexedPayloadAttestation.js";
 export * from "./proposer.js";
@@ -28,7 +29,6 @@ export * from "./voluntaryExits.js";
  */
 export function getBlockSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   currentSyncCommitteeIndexed: SyncCommitteeCache,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[],
@@ -41,22 +41,21 @@ export function getBlockSignatureSets(
   const fork = config.getForkSeq(signedBlock.message.slot);
 
   const signatureSets = [
-    getRandaoRevealSignatureSet(config, index2pubkey, signedBlock.message),
-    ...getProposerSlashingsSignatureSets(config, index2pubkey, signedBlock),
-    ...getAttesterSlashingsSignatureSets(config, index2pubkey, signedBlock),
-    ...getAttestationsSignatureSets(config, index2pubkey, signedBlock, indexedAttestations),
-    ...getVoluntaryExitsSignatureSets(config, index2pubkey, signedBlock),
+    getRandaoRevealSignatureSet(config, signedBlock.message),
+    ...getProposerSlashingsSignatureSets(config, signedBlock),
+    ...getAttesterSlashingsSignatureSets(config, signedBlock),
+    ...getAttestationsSignatureSets(config, signedBlock, indexedAttestations),
+    ...getVoluntaryExitsSignatureSets(config, signedBlock),
   ];
 
   if (!opts?.skipProposerSignature) {
-    signatureSets.push(getBlockProposerSignatureSet(config, index2pubkey, signedBlock));
+    signatureSets.push(getBlockProposerSignatureSet(config, signedBlock));
   }
 
   // Only after altair fork, validate tSyncCommitteeSignature
   if (fork >= ForkSeq.altair) {
     const syncCommitteeSignatureSet = getSyncCommitteeSignatureSet(
       config,
-      index2pubkey,
       currentSyncCommitteeIndexed,
       (signedBlock as altair.SignedBeaconBlock).message
     );

package/src/signatureSets/indexedAttestation.ts

@@ -1,7 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {
   ISignatureSet,
   computeSigningRoot,
@@ -22,13 +21,12 @@ export function getAttestationDataSigningRoot(
 
 export function getAttestationWithIndicesSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   attestation: Pick<phase0.Attestation, "data" | "signature">,
   attestingIndices: number[]
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
-    attestingIndices.map((i) => index2pubkey[i]),
+    attestingIndices,
     getAttestationDataSigningRoot(config, stateSlot, attestation.data),
     attestation.signature
   );
@@ -36,13 +34,11 @@ export function getAttestationWithIndicesSignatureSet(
 
 export function getIndexedAttestationSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   indexedAttestation: IndexedAttestation
 ): ISignatureSet {
   return getAttestationWithIndicesSignatureSet(
     config,
-    index2pubkey,
     stateSlot,
     indexedAttestation,
     indexedAttestation.attestingIndices
@@ -51,7 +47,6 @@ export function getIndexedAttestationSignatureSet(
 
 export function getAttestationsSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[]
 ): ISignatureSet[] {
@@ -64,6 +59,6 @@ export function getAttestationsSignatureSets(
   // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
   const blockSlot = signedBlock.message.slot;
   return indexedAttestations.map((indexedAttestation) =>
-    getIndexedAttestationSignatureSet(config, index2pubkey, blockSlot, indexedAttestation)
+    getIndexedAttestationSignatureSet(config, blockSlot, indexedAttestation)
   );
 }