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

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

@@ -5,7 +5,6 @@ export * from "./attesterStatus.js";
 export * from "./balance.js";
 export * from "./blindedBlock.js";
 export * from "./blockRoot.js";
-export * from "./calculateCommitteeAssignments.js";
 export * from "./capella.js";
 export * from "./computeAnchorCheckpoint.js";
 export * from "./deposit.js";
@@ -16,11 +15,12 @@ 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";
 export * from "./seed.js";
-export * from "./shufflingDecisionRoot.js";
+export * from "./shuffling.js";
 export * from "./signatureSets.js";
 export * from "./signingRoot.js";
 export * from "./slot.js";

package/src/util/shuffling.ts

@@ -0,0 +1,234 @@
+import {ForkName, ForkSeq, SLOTS_PER_EPOCH, isForkPostFulu} from "@lodestar/params";
+import {
+  Attestation,
+  CommitteeIndex,
+  Epoch,
+  IndexedAttestation,
+  Root,
+  Slot,
+  ValidatorIndex,
+  electra,
+} from "@lodestar/types";
+import {LodestarError} from "@lodestar/utils";
+import {CachedBeaconStateAllForks} from "../cache/stateCache.js";
+import {getBlockRootAtSlot} from "./blockRoot.js";
+import {computeStartSlotAtEpoch} from "./epoch.js";
+import {EpochShuffling} from "./epochShuffling.js";
+
+/**
+ * Returns the block root which decided the proposer shuffling for the current epoch. This root
+ * can be used to key this proposer shuffling.
+ *
+ * Returns `null` on the one-off scenario where the genesis block decides its own shuffling.
+ * It should be set to the latest block applied to this `state` or the genesis block root.
+ */
+export function proposerShufflingDecisionRoot(fork: ForkName, state: CachedBeaconStateAllForks): Root | null {
+  const decisionSlot = proposerShufflingDecisionSlot(fork, state);
+  if (state.slot === decisionSlot) {
+    return null;
+  }
+  return getBlockRootAtSlot(state, decisionSlot);
+}
+
+/**
+ * Returns the slot at which the proposer shuffling was decided. The block root at this slot
+ * can be used to key the proposer shuffling for the current epoch.
+ */
+function proposerShufflingDecisionSlot(fork: ForkName, state: CachedBeaconStateAllForks): Slot {
+  // After fulu, the decision slot is in previous epoch due to deterministic proposer lookahead
+  const epoch = isForkPostFulu(fork) ? state.epochCtx.epoch - 1 : state.epochCtx.epoch;
+  const startSlot = computeStartSlotAtEpoch(epoch);
+  return Math.max(startSlot - 1, 0);
+}
+
+/**
+ * Returns the block root which decided the attester shuffling for the given `requestedEpoch`.
+ * This root can be used to key that attester shuffling.
+ *
+ * Returns `null` on the one-off scenario where the genesis block decides its own shuffling.
+ * It should be set to the latest block applied to this `state` or the genesis block root.
+ */
+export function attesterShufflingDecisionRoot(state: CachedBeaconStateAllForks, requestedEpoch: Epoch): Root | null {
+  const decisionSlot = attesterShufflingDecisionSlot(state, requestedEpoch);
+  if (state.slot === decisionSlot) {
+    return null;
+  }
+  return getBlockRootAtSlot(state, decisionSlot);
+}
+
+/**
+ * Returns the slot at which the proposer shuffling was decided. The block root at this slot
+ * can be used to key the proposer shuffling for the current epoch.
+ */
+function attesterShufflingDecisionSlot(state: CachedBeaconStateAllForks, requestedEpoch: Epoch): Slot {
+  const epoch = attesterShufflingDecisionEpoch(state, requestedEpoch);
+  const slot = computeStartSlotAtEpoch(epoch);
+  return Math.max(slot - 1, 0);
+}
+
+/**
+ * Returns the epoch at which the attester shuffling was decided.
+ *
+ * Spec ref: https://github.com/ethereum/beacon-APIs/blob/v2.1.0/apis/validator/duties/attester.yaml#L15
+ *
+ * Throws an error when:
+ * - `EpochTooLow` when `requestedEpoch` is more than 1 prior to `currentEpoch`.
+ * - `EpochTooHigh` when `requestedEpoch` is more than 1 after `currentEpoch`.
+ */
+function attesterShufflingDecisionEpoch(state: CachedBeaconStateAllForks, requestedEpoch: Epoch): Epoch {
+  const currentEpoch = state.epochCtx.epoch;
+
+  // Next
+  if (requestedEpoch === currentEpoch + 1) return currentEpoch;
+  // Current
+  if (requestedEpoch === currentEpoch) return Math.max(currentEpoch - 1, 0);
+  // Previous
+  if (requestedEpoch === currentEpoch - 1) return Math.max(currentEpoch - 2, 0);
+
+  if (requestedEpoch < currentEpoch) {
+    throw Error(`EpochTooLow: current ${currentEpoch} requested ${requestedEpoch}`);
+  }
+  throw Error(`EpochTooHigh: current ${currentEpoch} requested ${requestedEpoch}`);
+}
+
+// Copied from lodestar-api package to avoid depending on the package
+export interface AttesterDuty {
+  validatorIndex: ValidatorIndex;
+  committeeIndex: CommitteeIndex;
+  committeeLength: number;
+  committeesAtSlot: number;
+  validatorCommitteeIndex: number;
+  slot: Slot;
+}
+
+export function calculateCommitteeAssignments(
+  epochShuffling: EpochShuffling,
+  requestedValidatorIndices: ValidatorIndex[]
+): Map<ValidatorIndex, AttesterDuty> {
+  const requestedValidatorIndicesSet = new Set(requestedValidatorIndices);
+  const duties = new Map<ValidatorIndex, AttesterDuty>();
+
+  const epochCommittees = epochShuffling.committees;
+  for (let epochSlot = 0; epochSlot < SLOTS_PER_EPOCH; epochSlot++) {
+    const slotCommittees = epochCommittees[epochSlot];
+    for (let i = 0, committeesAtSlot = slotCommittees.length; i < committeesAtSlot; i++) {
+      for (let j = 0, committeeLength = slotCommittees[i].length; j < committeeLength; j++) {
+        const validatorIndex = slotCommittees[i][j];
+        if (requestedValidatorIndicesSet.has(validatorIndex)) {
+          duties.set(validatorIndex, {
+            validatorIndex,
+            committeeLength,
+            committeesAtSlot,
+            validatorCommitteeIndex: j,
+            committeeIndex: i,
+            slot: epochShuffling.epoch * SLOTS_PER_EPOCH + epochSlot,
+          });
+        }
+      }
+    }
+  }
+
+  return duties;
+}
+
+/**
+ * Return the indexed attestation corresponding to ``attestation``.
+ */
+export function getIndexedAttestation(
+  epochShuffling: EpochShuffling,
+  fork: ForkSeq,
+  attestation: Attestation
+): IndexedAttestation {
+  const {data} = attestation;
+  const attestingIndices = getAttestingIndices(epochShuffling, fork, attestation);
+
+  // sort in-place
+  attestingIndices.sort((a, b) => a - b);
+  return {
+    attestingIndices: attestingIndices,
+    data: data,
+    signature: attestation.signature,
+  };
+}
+
+/**
+ * Return indices of validators who attestested in `attestation`
+ */
+export function getAttestingIndices(epochShuffling: EpochShuffling, fork: ForkSeq, attestation: Attestation): number[] {
+  if (fork < ForkSeq.electra) {
+    const {aggregationBits, data} = attestation;
+    const validatorIndices = getBeaconCommittee(epochShuffling, data.slot, data.index);
+
+    return aggregationBits.intersectValues(validatorIndices);
+  }
+  const {aggregationBits, committeeBits, data} = attestation as electra.Attestation;
+
+  // There is a naming conflict on the term `committeeIndices`
+  // In Lodestar it usually means a list of validator indices of participants in a committee
+  // In the spec it means a list of committee indices according to committeeBits
+  // This `committeeIndices` refers to the latter
+  // TODO Electra: resolve the naming conflicts
+  const committeeIndices = committeeBits.getTrueBitIndexes();
+
+  const validatorsByCommittee = getBeaconCommittees(epochShuffling, data.slot, committeeIndices);
+
+  // Create a new Uint32Array to flatten `validatorsByCommittee`
+  const totalLength = validatorsByCommittee.reduce((acc, curr) => acc + curr.length, 0);
+  const committeeValidators = new Uint32Array(totalLength);
+
+  let offset = 0;
+  for (const committee of validatorsByCommittee) {
+    committeeValidators.set(committee, offset);
+    offset += committee.length;
+  }
+
+  return aggregationBits.intersectValues(committeeValidators);
+}
+
+/**
+ * Return the beacon committee at slot for index.
+ */
+export function getBeaconCommittee(epochShuffling: EpochShuffling, slot: Slot, index: CommitteeIndex): Uint32Array {
+  return getBeaconCommittees(epochShuffling, slot, [index])[0];
+}
+
+/**
+ * Return a Uint32Array[] representing committees validator indices
+ */
+export function getBeaconCommittees(
+  epochShuffling: EpochShuffling,
+  slot: Slot,
+  indices: CommitteeIndex[]
+): Uint32Array[] {
+  if (indices.length === 0) {
+    throw new Error("Attempt to get committees without providing CommitteeIndex");
+  }
+
+  const slotCommittees = epochShuffling.committees[slot % SLOTS_PER_EPOCH];
+  const committees = [];
+
+  for (const index of indices) {
+    if (index >= slotCommittees.length) {
+      throw new ShufflingError({
+        code: ShufflingErrorCode.COMMITTEE_INDEX_OUT_OF_RANGE,
+        index,
+        maxIndex: slotCommittees.length,
+      });
+    }
+    committees.push(slotCommittees[index]);
+  }
+
+  return committees;
+}
+
+export enum ShufflingErrorCode {
+  COMMITTEE_INDEX_OUT_OF_RANGE = "SHUFFLING_ERROR_COMMITTEE_INDEX_OUT_OF_RANGE",
+}
+
+type ShufflingErrorType = {
+  code: ShufflingErrorCode.COMMITTEE_INDEX_OUT_OF_RANGE;
+  index: number;
+  maxIndex: number;
+};
+
+export class ShufflingError extends LodestarError<ShufflingErrorType> {}

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;
 }

package/lib/util/calculateCommitteeAssignments.d.ts

@@ -1,12 +0,0 @@
-import { CommitteeIndex, Slot, ValidatorIndex } from "@lodestar/types";
-import { EpochShuffling } from "./epochShuffling.js";
-export interface AttesterDuty {
-    validatorIndex: ValidatorIndex;
-    committeeIndex: CommitteeIndex;
-    committeeLength: number;
-    committeesAtSlot: number;
-    validatorCommitteeIndex: number;
-    slot: Slot;
-}
-export declare function calculateCommitteeAssignments(epochShuffling: EpochShuffling, requestedValidatorIndices: ValidatorIndex[]): Map<ValidatorIndex, AttesterDuty>;
-//# sourceMappingURL=calculateCommitteeAssignments.d.ts.map

package/lib/util/calculateCommitteeAssignments.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"calculateCommitteeAssignments.d.ts","sourceRoot":"","sources":["../../src/util/calculateCommitteeAssignments.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,cAAc,EAAE,IAAI,EAAE,cAAc,EAAC,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAGnD,MAAM,WAAW,YAAY;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,uBAAuB,EAAE,MAAM,CAAC;IAChC,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,wBAAgB,6BAA6B,CAC3C,cAAc,EAAE,cAAc,EAC9B,yBAAyB,EAAE,cAAc,EAAE,GAC1C,GAAG,CAAC,cAAc,EAAE,YAAY,CAAC,CAyBnC"}

package/lib/util/calculateCommitteeAssignments.js

@@ -1,26 +0,0 @@
-import { SLOTS_PER_EPOCH } from "@lodestar/params";
-export function calculateCommitteeAssignments(epochShuffling, requestedValidatorIndices) {
-    const requestedValidatorIndicesSet = new Set(requestedValidatorIndices);
-    const duties = new Map();
-    const epochCommittees = epochShuffling.committees;
-    for (let epochSlot = 0; epochSlot < SLOTS_PER_EPOCH; epochSlot++) {
-        const slotCommittees = epochCommittees[epochSlot];
-        for (let i = 0, committeesAtSlot = slotCommittees.length; i < committeesAtSlot; i++) {
-            for (let j = 0, committeeLength = slotCommittees[i].length; j < committeeLength; j++) {
-                const validatorIndex = slotCommittees[i][j];
-                if (requestedValidatorIndicesSet.has(validatorIndex)) {
-                    duties.set(validatorIndex, {
-                        validatorIndex,
-                        committeeLength,
-                        committeesAtSlot,
-                        validatorCommitteeIndex: j,
-                        committeeIndex: i,
-                        slot: epochShuffling.epoch * SLOTS_PER_EPOCH + epochSlot,
-                    });
-                }
-            }
-        }
-    }
-    return duties;
-}
-//# sourceMappingURL=calculateCommitteeAssignments.js.map

package/lib/util/calculateCommitteeAssignments.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"calculateCommitteeAssignments.js","sourceRoot":"","sources":["../../src/util/calculateCommitteeAssignments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAcjD,MAAM,UAAU,6BAA6B,CAC3C,cAA8B,EAC9B,yBAA2C;IAE3C,MAAM,4BAA4B,GAAG,IAAI,GAAG,CAAC,yBAAyB,CAAC,CAAC;IACxE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAgC,CAAC;IAEvD,MAAM,eAAe,GAAG,cAAc,CAAC,UAAU,CAAC;IAClD,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,eAAe,EAAE,SAAS,EAAE,EAAE,CAAC;QACjE,MAAM,cAAc,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;QAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC,GAAG,gBAAgB,EAAE,CAAC,EAAE,EAAE,CAAC;YACpF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,eAAe,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC;gBACrF,MAAM,cAAc,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5C,IAAI,4BAA4B,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC;oBACrD,MAAM,CAAC,GAAG,CAAC,cAAc,EAAE;wBACzB,cAAc;wBACd,eAAe;wBACf,gBAAgB;wBAChB,uBAAuB,EAAE,CAAC;wBAC1B,cAAc,EAAE,CAAC;wBACjB,IAAI,EAAE,cAAc,CAAC,KAAK,GAAG,eAAe,GAAG,SAAS;qBACzD,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/lib/util/shufflingDecisionRoot.d.ts

@@ -1,20 +0,0 @@
-import { ForkName } from "@lodestar/params";
-import { Epoch, Root } from "@lodestar/types";
-import { CachedBeaconStateAllForks } from "../types.js";
-/**
- * Returns the block root which decided the proposer shuffling for the current epoch. This root
- * can be used to key this proposer shuffling.
- *
- * Returns `null` on the one-off scenario where the genesis block decides its own shuffling.
- * It should be set to the latest block applied to this `state` or the genesis block root.
- */
-export declare function proposerShufflingDecisionRoot(fork: ForkName, state: CachedBeaconStateAllForks): Root | null;
-/**
- * Returns the block root which decided the attester shuffling for the given `requestedEpoch`.
- * This root can be used to key that attester shuffling.
- *
- * Returns `null` on the one-off scenario where the genesis block decides its own shuffling.
- * It should be set to the latest block applied to this `state` or the genesis block root.
- */
-export declare function attesterShufflingDecisionRoot(state: CachedBeaconStateAllForks, requestedEpoch: Epoch): Root | null;
-//# sourceMappingURL=shufflingDecisionRoot.d.ts.map