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

package/src/signatureSets/indexedPayloadAttestation.ts

@@ -1,24 +1,26 @@
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_PTC_ATTESTER} from "@lodestar/params";
-import {gloas, ssz} from "@lodestar/types";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {ISignatureSet, computeSigningRoot, createAggregateSignatureSetFromComponents} from "../util/index.ts";
+import {Slot, gloas, ssz} from "@lodestar/types";
+import {CachedBeaconStateGloas} from "../types.js";
+import {ISignatureSet, computeSigningRoot, createAggregateSignatureSetFromComponents} from "../util/index.js";
 
 export function getIndexedPayloadAttestationSignatureSet(
   state: CachedBeaconStateGloas,
   indexedPayloadAttestation: gloas.IndexedPayloadAttestation
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
-    indexedPayloadAttestation.attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
-    getPayloadAttestationDataSigningRoot(state, indexedPayloadAttestation.data),
+    indexedPayloadAttestation.attestingIndices,
+    getPayloadAttestationDataSigningRoot(state.config, state.slot, indexedPayloadAttestation.data),
     indexedPayloadAttestation.signature
   );
 }
 
 export function getPayloadAttestationDataSigningRoot(
-  state: CachedBeaconStateGloas,
+  config: BeaconConfig,
+  stateSlot: Slot,
   data: gloas.PayloadAttestationData
 ): Uint8Array {
-  const domain = state.config.getDomain(state.slot, DOMAIN_PTC_ATTESTER);
+  const domain = config.getDomain(stateSlot, DOMAIN_PTC_ATTESTER);
 
   return computeSigningRoot(ssz.gloas.PayloadAttestationData, data, domain);
 }

package/src/signatureSets/proposer.ts

@@ -10,13 +10,12 @@ export function verifyProposerSignature(
   index2pubkey: Index2PubkeyCache,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
-  const signatureSet = getBlockProposerSignatureSet(config, index2pubkey, signedBlock);
-  return verifySignatureSet(signatureSet);
+  const signatureSet = getBlockProposerSignatureSet(config, signedBlock);
+  return verifySignatureSet(signatureSet, index2pubkey);
 }
 
 export function getBlockProposerSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): ISignatureSet {
   // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
@@ -29,8 +28,8 @@ export function getBlockProposerSignatureSet(
     : config.getForkTypes(signedBlock.message.slot).BeaconBlock;
 
   return {
-    type: SignatureSetType.single,
-    pubkey: index2pubkey[signedBlock.message.proposerIndex],
+    type: SignatureSetType.indexed,
+    index: signedBlock.message.proposerIndex,
     signingRoot: computeSigningRoot(blockType, signedBlock.message, domain),
     signature: signedBlock.signature,
   };
@@ -38,32 +37,29 @@ export function getBlockProposerSignatureSet(
 
 export function getBlockHeaderProposerSignatureSetByParentStateSlot(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   parentStateSlot: Slot,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, parentStateSlot);
+  return getBlockHeaderProposerSignatureSet(config, signedBlockHeader, parentStateSlot);
 }
 
 export function getBlockHeaderProposerSignatureSetByHeaderSlot(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, signedBlockHeader.message.slot);
+  return getBlockHeaderProposerSignatureSet(config, signedBlockHeader, signedBlockHeader.message.slot);
 }
 
 function getBlockHeaderProposerSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlockHeader: phase0.SignedBeaconBlockHeader,
   domainSlot: Slot
 ): ISignatureSet {
   const domain = config.getDomain(domainSlot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
 
   return {
-    type: SignatureSetType.single,
-    pubkey: index2pubkey[signedBlockHeader.message.proposerIndex],
+    type: SignatureSetType.indexed,
+    index: signedBlockHeader.message.proposerIndex,
     signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeader, signedBlockHeader.message, domain),
     signature: signedBlockHeader.signature,
   };

package/src/signatureSets/proposerSlashings.ts

@@ -1,7 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index.js";
 
 /**
@@ -9,11 +8,10 @@ import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index
  */
 export function getProposerSlashingSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing
 ): ISignatureSet[] {
-  const pubkey = index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
+  const proposerIndex = proposerSlashing.signedHeader1.message.proposerIndex;
 
   // In state transition, ProposerSlashing headers are only partially validated. Their slot could be higher than the
   // clock and the slashing would still be valid. Must use bigint variants to hash correctly to all possible values
@@ -21,8 +19,8 @@ export function getProposerSlashingSignatureSets(
     const domain = config.getDomain(stateSlot, DOMAIN_BEACON_PROPOSER, Number(signedHeader.message.slot as bigint));
 
     return {
-      type: SignatureSetType.single,
-      pubkey,
+      type: SignatureSetType.indexed,
+      index: proposerIndex,
       signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeaderBigint, signedHeader.message, domain),
       signature: signedHeader.signature,
     };
@@ -31,13 +29,12 @@ export function getProposerSlashingSignatureSets(
 
 export function getProposerSlashingsSignatureSets(
   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.proposerSlashings.flatMap((proposerSlashing) =>
-    getProposerSlashingSignatureSets(config, index2pubkey, blockSlot, proposerSlashing)
+    getProposerSlashingSignatureSets(config, blockSlot, proposerSlashing)
   );
 }

package/src/signatureSets/randao.ts

@@ -15,17 +15,13 @@ export function verifyRandaoSignature(
   index2pubkey: Index2PubkeyCache,
   block: BeaconBlock
 ): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(config, index2pubkey, block));
+  return verifySignatureSet(getRandaoRevealSignatureSet(config, block), index2pubkey);
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
-export function getRandaoRevealSignatureSet(
-  config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
-  block: BeaconBlock
-): ISignatureSet {
+export function getRandaoRevealSignatureSet(config: BeaconConfig, block: BeaconBlock): ISignatureSet {
   // should not get epoch from epochCtx
   const epoch = computeEpochAtSlot(block.slot);
   // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
@@ -33,8 +29,8 @@ export function getRandaoRevealSignatureSet(
   const domain = config.getDomain(block.slot, DOMAIN_RANDAO, block.slot);
 
   return {
-    type: SignatureSetType.single,
-    pubkey: index2pubkey[block.proposerIndex],
+    type: SignatureSetType.indexed,
+    index: block.proposerIndex,
     signingRoot: computeSigningRoot(ssz.Epoch, epoch, domain),
     signature: block.body.randaoReveal,
   };

package/src/signatureSets/voluntaryExits.ts

@@ -15,7 +15,7 @@ export function verifyVoluntaryExitSignature(
   stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(config, index2pubkey, stateSlot, signedVoluntaryExit));
+  return verifySignatureSet(getVoluntaryExitSignatureSet(config, stateSlot, signedVoluntaryExit), index2pubkey);
 }
 
 /**
@@ -23,7 +23,6 @@ export function verifyVoluntaryExitSignature(
  */
 export function getVoluntaryExitSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
@@ -31,22 +30,18 @@ export function getVoluntaryExitSignatureSet(
   const domain = config.getDomainForVoluntaryExit(stateSlot, messageSlot);
 
   return {
-    type: SignatureSetType.single,
-    pubkey: index2pubkey[signedVoluntaryExit.message.validatorIndex],
+    type: SignatureSetType.indexed,
+    index: signedVoluntaryExit.message.validatorIndex,
     signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
     signature: signedVoluntaryExit.signature,
   };
 }
 
-export function getVoluntaryExitsSignatureSets(
-  config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
-  signedBlock: SignedBeaconBlock
-): ISignatureSet[] {
+export function getVoluntaryExitsSignatureSets(config: BeaconConfig, 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.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(config, index2pubkey, blockSlot, voluntaryExit)
+    getVoluntaryExitSignatureSet(config, blockSlot, voluntaryExit)
   );
 }

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,22 @@
 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 {BuilderIndex, Epoch, ValidatorIndex, 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";
+import {CachedBeaconStateGloas} from "../types.js";
+import {getBlockRootAtSlot} from "./blockRoot.js";
+import {computeEpochAtSlot} from "./epoch.js";
+import {RootCache} from "./rootCache.js";
 
-export function hasBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
+export function isBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
   return withdrawalCredentials[0] === BUILDER_WITHDRAWAL_PREFIX;
 }
 
@@ -25,14 +28,117 @@ export function getBuilderPaymentQuorumThreshold(state: CachedBeaconStateGloas):
   return Math.floor(quorum / BUILDER_PAYMENT_THRESHOLD_DENOMINATOR);
 }
 
-export function isBuilderPaymentWithdrawable(
+/**
+ * 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: BuilderIndex): ValidatorIndex {
+  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: ValidatorIndex): BuilderIndex {
+  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(builder: gloas.Builder, finalizedEpoch: Epoch): boolean {
+  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,
-  withdrawal: gloas.BuilderPendingWithdrawal
+  builderIndex: BuilderIndex
+): 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: BuilderIndex,
+  bidAmount: number
 ): boolean {
-  const builder = state.validators.getReadonly(withdrawal.builderIndex);
+  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: BuilderIndex): 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): BuilderIndex | 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/index.ts

@@ -15,6 +15,7 @@ export * from "./epochShuffling.js";
 export * from "./execution.js";
 export * from "./finality.js";
 export * from "./genesis.js";
+export * from "./gloas.js";
 export * from "./interop.js";
 export * from "./loadState/index.js";
 export * from "./rootCache.js";

package/src/util/signatureSets.ts

@@ -1,11 +1,21 @@
-import {PublicKey, Signature, fastAggregateVerify, verify} from "@chainsafe/blst";
+import {PublicKey, Signature, aggregatePublicKeys, fastAggregateVerify, verify} from "@chainsafe/blst";
 import {Root} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 
 export enum SignatureSetType {
   single = "single",
   aggregate = "aggregate",
+  /**
+   * Single signature with validator index instead of pubkey.
+   * Pubkey lookup is deferred to verification time.
+   */
+  indexed = "indexed",
 }
 
+/**
+ * Single signature with pubkey directly.
+ * Used when pubkey comes from the message itself (e.g. BLS to execution change).
+ */
 export type SingleSignatureSet = {
   type: SignatureSetType.single;
   pubkey: PublicKey;
@@ -13,16 +23,57 @@ export type SingleSignatureSet = {
   signature: Uint8Array;
 };
 
+/**
+ * Single signature with validator index.
+ * Pubkey is looked up at verification time.
+ */
+export type IndexedSignatureSet = {
+  type: SignatureSetType.indexed;
+  index: number;
+  signingRoot: Root;
+  signature: Uint8Array;
+};
+
+/**
+ * Aggregate signature with validator indices.
+ * Pubkeys are looked up and aggregated at verification time.
+ */
 export type AggregatedSignatureSet = {
   type: SignatureSetType.aggregate;
-  pubkeys: PublicKey[];
+  indices: number[];
   signingRoot: Root;
   signature: Uint8Array;
 };
 
-export type ISignatureSet = SingleSignatureSet | AggregatedSignatureSet;
+export type ISignatureSet = SingleSignatureSet | IndexedSignatureSet | AggregatedSignatureSet;
+
+/**
+ * Get the pubkey for a signature set, performing aggregation if necessary.
+ * Requires index2pubkey cache for indexed and aggregate sets.
+ */
+export function getSignatureSetPubkey(signatureSet: ISignatureSet, index2pubkey: Index2PubkeyCache): PublicKey {
+  switch (signatureSet.type) {
+    case SignatureSetType.single:
+      return signatureSet.pubkey;
+
+    case SignatureSetType.indexed:
+      return index2pubkey[signatureSet.index];
+
+    case SignatureSetType.aggregate: {
+      const pubkeys = signatureSet.indices.map((i) => index2pubkey[i]);
+      return aggregatePublicKeys(pubkeys);
+    }
 
-export function verifySignatureSet(signatureSet: ISignatureSet): boolean {
+    default:
+      throw Error("Unknown signature set type");
+  }
+}
+
+export function verifySignatureSet(signatureSet: SingleSignatureSet, index2pubkey?: Index2PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: IndexedSignatureSet, index2pubkey: Index2PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: AggregatedSignatureSet, index2pubkey: Index2PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: ISignatureSet, index2pubkey: Index2PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: ISignatureSet, index2pubkey?: Index2PubkeyCache): boolean {
   // All signatures are not trusted and must be group checked (p2.subgroup_check)
   const signature = Signature.fromBytes(signatureSet.signature, true);
 
@@ -30,8 +81,20 @@ export function verifySignatureSet(signatureSet: ISignatureSet): boolean {
     case SignatureSetType.single:
       return verify(signatureSet.signingRoot, signatureSet.pubkey, signature);
 
-    case SignatureSetType.aggregate:
-      return fastAggregateVerify(signatureSet.signingRoot, signatureSet.pubkeys, signature);
+    case SignatureSetType.indexed: {
+      if (!index2pubkey) {
+        throw Error("index2pubkey required for indexed signature set");
+      }
+      return verify(signatureSet.signingRoot, index2pubkey[signatureSet.index], signature);
+    }
+
+    case SignatureSetType.aggregate: {
+      if (!index2pubkey) {
+        throw Error("index2pubkey required for aggregate signature set");
+      }
+      const pubkeys = signatureSet.indices.map((i) => index2pubkey[i]);
+      return fastAggregateVerify(signatureSet.signingRoot, pubkeys, signature);
+    }
 
     default:
       throw Error("Unknown signature set type");
@@ -51,14 +114,27 @@ export function createSingleSignatureSetFromComponents(
   };
 }
 
+export function createIndexedSignatureSetFromComponents(
+  index: number,
+  signingRoot: Root,
+  signature: Uint8Array
+): IndexedSignatureSet {
+  return {
+    type: SignatureSetType.indexed,
+    index,
+    signingRoot,
+    signature,
+  };
+}
+
 export function createAggregateSignatureSetFromComponents(
-  pubkeys: PublicKey[],
+  indices: number[],
   signingRoot: Root,
   signature: Uint8Array
 ): AggregatedSignatureSet {
   return {
     type: SignatureSetType.aggregate,
-    pubkeys,
+    indices,
     signingRoot,
     signature,
   };

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,8 +96,35 @@ 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,
   validatorIndex: ValidatorIndex
 ): number {
@@ -106,19 +135,5 @@ export function getPendingBalanceToWithdraw(
     }
   }
 
-  if (fork >= ForkSeq.gloas) {
-    const stateGloas = state as CachedBeaconStateGloas;
-    for (const item of stateGloas.builderPendingWithdrawals.getAllReadonly()) {
-      if (item.builderIndex === validatorIndex) {
-        total += item.amount;
-      }
-    }
-    for (const item of stateGloas.builderPendingPayments.getAllReadonly()) {
-      if (item.withdrawal.builderIndex === validatorIndex) {
-        total += item.withdrawal.amount;
-      }
-    }
-  }
-
   return total;
 }