@lodestar/state-transition 1.39.0-dev.882891d89c → 1.39.0-dev.90334173dc

package/src/signatureSets/proposer.ts

@@ -2,27 +2,27 @@ import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, SignedBlindedBeaconBlock, Slot, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {computeSigningRoot} from "../util/index.js";
 import {ISignatureSet, SignatureSetType, verifySignatureSet} from "../util/signatureSets.js";
 
 export function verifyProposerSignature(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
-  const signatureSet = getBlockProposerSignatureSet(config, index2pubkey, state, signedBlock);
+  const signatureSet = getBlockProposerSignatureSet(config, index2pubkey, signedBlock);
   return verifySignatureSet(signatureSet);
 }
 
 export function getBlockProposerSignatureSet(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): ISignatureSet {
-  const domain = config.getDomain(state.slot, DOMAIN_BEACON_PROPOSER, signedBlock.message.slot);
+  // 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;
+  const domain = config.getDomain(blockSlot, DOMAIN_BEACON_PROPOSER, blockSlot);
 
   const blockType = isBlindedBeaconBlock(signedBlock.message)
     ? config.getPostBellatrixForkTypes(signedBlock.message.slot).BlindedBeaconBlock
@@ -37,28 +37,28 @@ export function getBlockProposerSignatureSet(
 }
 
 export function getBlockHeaderProposerSignatureSetByParentStateSlot(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  parentState: CachedBeaconStateAllForks,
+  parentStateSlot: Slot,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(index2pubkey, parentState, signedBlockHeader, parentState.slot);
+  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, parentStateSlot);
 }
 
 export function getBlockHeaderProposerSignatureSetByHeaderSlot(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  headState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(index2pubkey, headState, signedBlockHeader, signedBlockHeader.message.slot);
+  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, signedBlockHeader.message.slot);
 }
 
 function getBlockHeaderProposerSignatureSet(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader,
   domainSlot: Slot
 ): ISignatureSet {
-  const {config} = state;
   const domain = config.getDomain(domainSlot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
 
   return {

package/src/signatureSets/proposerSlashings.ts

@@ -1,8 +1,7 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
-import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index.js";
 
 /**
@@ -11,7 +10,7 @@ import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index
 export function getProposerSlashingSignatureSets(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing
 ): ISignatureSet[] {
   const pubkey = index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
@@ -19,7 +18,7 @@ export function getProposerSlashingSignatureSets(
   // 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
   return [proposerSlashing.signedHeader1, proposerSlashing.signedHeader2].map((signedHeader): ISignatureSet => {
-    const domain = config.getDomain(state.slot, DOMAIN_BEACON_PROPOSER, Number(signedHeader.message.slot as bigint));
+    const domain = config.getDomain(stateSlot, DOMAIN_BEACON_PROPOSER, Number(signedHeader.message.slot as bigint));
 
     return {
       type: SignatureSetType.single,
@@ -33,10 +32,12 @@ export function getProposerSlashingSignatureSets(
 export function getProposerSlashingsSignatureSets(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   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, state, proposerSlashing)
+    getProposerSlashingSignatureSets(config, index2pubkey, blockSlot, proposerSlashing)
   );
 }

package/src/signatureSets/randao.ts

@@ -2,7 +2,6 @@ import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_RANDAO} from "@lodestar/params";
 import {BeaconBlock, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
   SignatureSetType,
@@ -14,10 +13,9 @@ import {
 export function verifyRandaoSignature(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   block: BeaconBlock
 ): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(config, index2pubkey, state, block));
+  return verifySignatureSet(getRandaoRevealSignatureSet(config, index2pubkey, block));
 }
 
 /**
@@ -26,12 +24,13 @@ export function verifyRandaoSignature(
 export function getRandaoRevealSignatureSet(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   block: BeaconBlock
 ): ISignatureSet {
   // should not get epoch from epochCtx
   const epoch = computeEpochAtSlot(block.slot);
-  const domain = config.getDomain(state.slot, DOMAIN_RANDAO, block.slot);
+  // 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 domain = config.getDomain(block.slot, DOMAIN_RANDAO, block.slot);
 
   return {
     type: SignatureSetType.single,

package/src/signatureSets/voluntaryExits.ts

@@ -1,7 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
-import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
   SignatureSetType,
@@ -13,10 +12,10 @@ import {
 export function verifyVoluntaryExitSignature(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(config, index2pubkey, state, signedVoluntaryExit));
+  return verifySignatureSet(getVoluntaryExitSignatureSet(config, index2pubkey, stateSlot, signedVoluntaryExit));
 }
 
 /**
@@ -25,11 +24,11 @@ export function verifyVoluntaryExitSignature(
 export function getVoluntaryExitSignatureSet(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
-  const slot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
-  const domain = config.getDomainForVoluntaryExit(state.slot, slot);
+  const messageSlot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
+  const domain = config.getDomainForVoluntaryExit(stateSlot, messageSlot);
 
   return {
     type: SignatureSetType.single,
@@ -42,10 +41,12 @@ export function getVoluntaryExitSignatureSet(
 export function getVoluntaryExitsSignatureSets(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   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, state, voluntaryExit)
+    getVoluntaryExitSignatureSet(config, index2pubkey, blockSlot, voluntaryExit)
   );
 }

package/src/stateTransition.ts

@@ -111,10 +111,7 @@ export function stateTransition(
   postState = processSlotsWithTransientCache(postState, blockSlot, options, {metrics, validatorMonitor});
 
   // Verify proposer signature only
-  if (
-    verifyProposer &&
-    !verifyProposerSignature(postState.config, postState.epochCtx.index2pubkey, postState, signedBlock)
-  ) {
+  if (verifyProposer && !verifyProposerSignature(postState.config, postState.epochCtx.index2pubkey, signedBlock)) {
     throw new Error("Invalid block signature");
   }
 

package/src/types.ts

@@ -23,4 +23,5 @@ export type {
   BeaconStateFulu,
   BeaconStateGloas,
   BeaconStatePhase0,
+  ShufflingGetter,
 } from "./cache/types.js";

package/src/util/epochShuffling.ts

@@ -9,54 +9,13 @@ import {
   TARGET_COMMITTEE_SIZE,
 } from "@lodestar/params";
 import {Epoch, RootHex, ValidatorIndex, ssz} from "@lodestar/types";
-import {GaugeExtra, Logger, NoLabels, intDiv, toRootHex} from "@lodestar/utils";
+import {intDiv, toRootHex} from "@lodestar/utils";
 import {BeaconStateAllForks} from "../types.js";
 import {getBlockRootAtSlot} from "./blockRoot.js";
 import {computeAnchorCheckpoint} from "./computeAnchorCheckpoint.js";
 import {computeStartSlotAtEpoch} from "./epoch.js";
 import {getSeed} from "./seed.js";
 
-export interface ShufflingBuildProps {
-  state: BeaconStateAllForks;
-  activeIndices: Uint32Array;
-}
-
-export interface PublicShufflingCacheMetrics {
-  shufflingCache: {
-    nextShufflingNotOnEpochCache: GaugeExtra<NoLabels>;
-  };
-}
-export interface IShufflingCache {
-  metrics: PublicShufflingCacheMetrics | null;
-  logger: Logger | null;
-  /**
-   * Gets a cached shuffling via the epoch and decision root. If the state and
-   * activeIndices are passed and a shuffling is not available it will be built
-   * synchronously. If the state is not passed and the shuffling is not available
-   * nothing will be returned.
-   *
-   * NOTE: If a shuffling is already queued and not calculated it will build and resolve
-   * the promise but the already queued build will happen at some later time
-   */
-  getSync<T extends ShufflingBuildProps | undefined>(
-    epoch: Epoch,
-    decisionRoot: RootHex,
-    buildProps?: T
-  ): T extends ShufflingBuildProps ? EpochShuffling : EpochShuffling | null;
-
-  /**
-   * Gets a cached shuffling via the epoch and decision root.  Returns a promise
-   * for the shuffling if it hs not calculated yet.  Returns null if a build has
-   * not been queued nor a shuffling was calculated.
-   */
-  get(epoch: Epoch, decisionRoot: RootHex): Promise<EpochShuffling | null>;
-
-  /**
-   * Queue asynchronous build for an EpochShuffling
-   */
-  build(epoch: Epoch, decisionRoot: RootHex, state: BeaconStateAllForks, activeIndices: Uint32Array): void;
-}
-
 /**
  * Readonly interface for EpochShuffling.
  */
@@ -164,7 +123,7 @@ export async function computeEpochShufflingAsync(
   };
 }
 
-function calculateDecisionRoot(state: BeaconStateAllForks, epoch: Epoch): RootHex {
+export function calculateDecisionRoot(state: BeaconStateAllForks, epoch: Epoch): RootHex {
   const pivotSlot = computeStartSlotAtEpoch(epoch - 1) - 1;
   return toRootHex(getBlockRootAtSlot(state, pivotSlot));
 }

package/src/util/execution.ts

@@ -2,6 +2,7 @@ import {ForkName, ForkPostBellatrix, ForkPreGloas, ForkSeq} from "@lodestar/para
 import {
   BeaconBlock,
   BeaconBlockBody,
+  BlindedBeaconBlock,
   BlindedBeaconBlockBody,
   ExecutionPayload,
   ExecutionPayloadHeader,
@@ -9,16 +10,54 @@ import {
   capella,
   deneb,
   isBlindedBeaconBlockBody,
+  isExecutionPayload,
   ssz,
 } from "@lodestar/types";
 import {
   BeaconStateAllForks,
+  BeaconStateBellatrix,
   BeaconStateCapella,
   BeaconStateExecutions,
   CachedBeaconStateAllForks,
   CachedBeaconStateExecutions,
 } from "../types.js";
 
+/**
+ * Execution enabled = merge is done.
+ * When (A) state has execution data OR (B) block has execution data
+ */
+export function isExecutionEnabled(state: BeaconStateExecutions, block: BeaconBlock | BlindedBeaconBlock): boolean {
+  if (isMergeTransitionComplete(state)) {
+    return true;
+  }
+
+  // Throws if not post-bellatrix block. A fork-guard before isExecutionEnabled() prevents this from happening
+  const payload = getFullOrBlindedPayload(block);
+
+  return isExecutionPayload(payload)
+    ? !ssz.bellatrix.ExecutionPayload.equals(payload, ssz.bellatrix.ExecutionPayload.defaultValue())
+    : !ssz.bellatrix.ExecutionPayloadHeader.equals(
+        state.latestExecutionPayloadHeader,
+        ssz.bellatrix.ExecutionPayloadHeader.defaultValue()
+      );
+}
+
+/**
+ * Merge is complete when the state includes execution layer data:
+ * state.latestExecutionPayloadHeader NOT EMPTY or state is post-capella
+ */
+export function isMergeTransitionComplete(state: BeaconStateExecutions): boolean {
+  if (isCapellaStateType(state)) {
+    // All networks have completed the merge transition before capella
+    return true;
+  }
+
+  return !ssz.bellatrix.ExecutionPayloadHeader.equals(
+    (state as BeaconStateBellatrix).latestExecutionPayloadHeader,
+    ssz.bellatrix.ExecutionPayloadHeader.defaultValue()
+  );
+}
+
 /** Type guard for bellatrix.BeaconState */
 export function isExecutionStateType(state: BeaconStateAllForks): state is BeaconStateExecutions {
   return (state as BeaconStateExecutions).latestExecutionPayloadHeader !== undefined;

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";
@@ -20,7 +19,7 @@ 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/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

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

@@ -1 +0,0 @@
-{"version":3,"file":"shufflingDecisionRoot.d.ts","sourceRoot":"","sources":["../../src/util/shufflingDecisionRoot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAiB,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAC,KAAK,EAAE,IAAI,EAAO,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAC,yBAAyB,EAAC,MAAM,aAAa,CAAC;AAItD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,yBAAyB,GAAG,IAAI,GAAG,IAAI,CAM3G;AAaD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,yBAAyB,EAAE,cAAc,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI,CAMlH"}