@lodestar/beacon-node 1.38.0 → 1.39.0-dev.075956b855

package/src/chain/rewards/attestationsRewards.ts

@@ -1,3 +1,4 @@
+import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {routes} from "@lodestar/api";
 import {BeaconConfig} from "@lodestar/config";
 import {
@@ -25,7 +26,7 @@ import {
   hasMarkers,
   isInInactivityLeak,
 } from "@lodestar/state-transition";
-import {Epoch, ValidatorIndex} from "@lodestar/types";
+import {ValidatorIndex} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 
 export type AttestationsRewards = routes.beacon.AttestationsRewards;
@@ -38,12 +39,12 @@ const defaultAttestationsReward = {head: 0, target: 0, source: 0, inclusionDelay
 const defaultAttestationsPenalty = {target: 0, source: 0};
 
 export async function computeAttestationsRewards(
-  _epoch: Epoch,
+  config: BeaconConfig,
+  pubkey2index: PubkeyIndexMap,
   state: CachedBeaconStateAllForks,
-  _config: BeaconConfig,
   validatorIds?: (ValidatorIndex | string)[]
 ): Promise<AttestationsRewards> {
-  const fork = state.config.getForkName(state.slot);
+  const fork = config.getForkName(state.slot);
   if (fork === ForkName.phase0) {
     throw Error("Unsupported fork. Attestations rewards calculation is not available in phase0");
   }
@@ -51,8 +52,14 @@ export async function computeAttestationsRewards(
   const stateAltair = state as CachedBeaconStateAltair;
   const transitionCache = beforeProcessEpoch(stateAltair);
 
-  const [idealRewards, penalties] = computeIdealAttestationsRewardsAndPenaltiesAltair(stateAltair, transitionCache);
+  const [idealRewards, penalties] = computeIdealAttestationsRewardsAndPenaltiesAltair(
+    config,
+    stateAltair,
+    transitionCache
+  );
   const totalRewards = computeTotalAttestationsRewardsAltair(
+    config,
+    pubkey2index,
     stateAltair,
     transitionCache,
     idealRewards,
@@ -64,12 +71,13 @@ export async function computeAttestationsRewards(
 }
 
 function computeIdealAttestationsRewardsAndPenaltiesAltair(
+  config: BeaconConfig,
   state: CachedBeaconStateAllForks,
   transitionCache: EpochTransitionCache
 ): [IdealAttestationsReward[], AttestationsPenalty[]] {
   const baseRewardPerIncrement = transitionCache.baseRewardPerIncrement;
   const activeBalanceByIncrement = transitionCache.totalActiveStakeByIncrement;
-  const fork = state.config.getForkName(state.slot);
+  const fork = config.getForkName(state.slot);
   const maxEffectiveBalance = isForkPostElectra(fork) ? MAX_EFFECTIVE_BALANCE_ELECTRA : MAX_EFFECTIVE_BALANCE;
   const maxEffectiveBalanceByIncrement = Math.floor(maxEffectiveBalance / EFFECTIVE_BALANCE_INCREMENT);
 
@@ -139,6 +147,8 @@ function computeIdealAttestationsRewardsAndPenaltiesAltair(
 
 // Same calculation as `getRewardsAndPenaltiesAltair` but returns the breakdown of rewards instead of aggregated
 function computeTotalAttestationsRewardsAltair(
+  config: BeaconConfig,
+  pubkey2index: PubkeyIndexMap,
   state: CachedBeaconStateAltair,
   transitionCache: EpochTransitionCache,
   idealRewards: IdealAttestationsReward[],
@@ -147,9 +157,9 @@ function computeTotalAttestationsRewardsAltair(
 ): TotalAttestationsReward[] {
   const rewards = [];
   const {flags} = transitionCache;
-  const {epochCtx, config} = state;
+  const {epochCtx} = state;
   const validatorIndices = validatorIds
-    .map((id) => (typeof id === "number" ? id : epochCtx.pubkey2index.get(fromHex(id))))
+    .map((id) => (typeof id === "number" ? id : pubkey2index.get(fromHex(id))))
     .filter((index) => index !== undefined); // Validator indices to include in the result
 
   const inactivityPenaltyDenominator = config.INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR;

package/src/chain/rewards/blockRewards.ts

@@ -1,4 +1,5 @@
 import {routes} from "@lodestar/api";
+import {BeaconConfig} from "@lodestar/config";
 import {
   ForkName,
   WHISTLEBLOWER_REWARD_QUOTIENT,
@@ -26,11 +27,12 @@ type SubRewardValue = number; // All reward values should be integer
  *  3) Reporting slashable behaviours from proposer and attester
  */
 export async function computeBlockRewards(
+  config: BeaconConfig,
   block: BeaconBlock,
   preState: CachedBeaconStateAllForks,
   postState?: CachedBeaconStateAllForks
 ): Promise<BlockRewards> {
-  const fork = preState.config.getForkName(block.slot);
+  const fork = config.getForkName(block.slot);
   const {attestations: cachedAttestationsReward = 0, syncAggregate: cachedSyncAggregateReward = 0} =
     postState?.proposerRewards ?? {};
   let blockAttestationReward = cachedAttestationsReward;
@@ -40,7 +42,7 @@ export async function computeBlockRewards(
     blockAttestationReward =
       fork === ForkName.phase0
         ? computeBlockAttestationRewardPhase0(block as phase0.BeaconBlock, preState as CachedBeaconStatePhase0)
-        : computeBlockAttestationRewardAltair(block as altair.BeaconBlock, preState as CachedBeaconStateAltair);
+        : computeBlockAttestationRewardAltair(config, block as altair.BeaconBlock, preState as CachedBeaconStateAltair);
   }
 
   if (syncAggregateReward === 0) {
@@ -78,10 +80,11 @@ function computeBlockAttestationRewardPhase0(
  * Reuses `processAttestationsAltair()`. Has dependency on RewardCache
  */
 function computeBlockAttestationRewardAltair(
+  config: BeaconConfig,
   block: altair.BeaconBlock,
   preState: CachedBeaconStateAltair
 ): SubRewardValue {
-  const fork = preState.config.getForkSeq(block.slot);
+  const fork = config.getForkSeq(block.slot);
   const {attestations} = block.body;
 
   processAttestationsAltair(fork, preState, attestations, false);

package/src/chain/rewards/syncCommitteeRewards.ts

@@ -1,24 +1,26 @@
 import {routes} from "@lodestar/api";
+import {BeaconConfig} from "@lodestar/config";
 import {ForkName, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
-import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "@lodestar/state-transition";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair, Index2PubkeyCache} from "@lodestar/state-transition";
 import {BeaconBlock, ValidatorIndex, altair} from "@lodestar/types";
 
 export type SyncCommitteeRewards = routes.beacon.SyncCommitteeRewards;
 type BalanceRecord = {val: number}; // Use val for convenient way to increment/decrement balance
 
 export async function computeSyncCommitteeRewards(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
   block: BeaconBlock,
   preState: CachedBeaconStateAllForks,
   validatorIds: (ValidatorIndex | string)[] = []
 ): Promise<SyncCommitteeRewards> {
-  const fork = preState.config.getForkName(block.slot);
+  const fork = config.getForkName(block.slot);
   if (fork === ForkName.phase0) {
     throw Error("Cannot get sync rewards as phase0 block does not have sync committee");
   }
 
   const altairBlock = block as altair.BeaconBlock;
   const preStateAltair = preState as CachedBeaconStateAltair;
-  const {index2pubkey} = preStateAltair.epochCtx;
 
   // Bound syncCommitteeValidatorIndices in case it goes beyond SYNC_COMMITTEE_SIZE just to be safe
   const syncCommitteeValidatorIndices = preStateAltair.epochCtx.currentSyncCommitteeIndexed.validatorIndices.slice(

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -1,4 +1,5 @@
 import {routes} from "@lodestar/api";
+import {BeaconConfig} from "@lodestar/config";
 import {
   CachedBeaconStateAllForks,
   computeStartSlotAtEpoch,
@@ -24,6 +25,7 @@ export type PersistentCheckpointStateCacheOpts = {
 };
 
 type PersistentCheckpointStateCacheModules = {
+  config: BeaconConfig;
   metrics?: Metrics | null;
   logger: Logger;
   clock?: IClock | null;
@@ -107,6 +109,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   private readonly cache: MapTracker<CacheKey, CacheItem>;
   /** Epoch -> Set<blockRoot> */
   private readonly epochIndex = new MapDef<Epoch, Set<RootHex>>(() => new Set<string>());
+  private readonly config: BeaconConfig;
   private readonly metrics: Metrics | null | undefined;
   private readonly logger: Logger;
   private readonly clock: IClock | null | undefined;
@@ -120,10 +123,20 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   private readonly bufferPool?: BufferPool | null;
 
   constructor(
-    {metrics, logger, clock, signal, datastore, blockStateCache, bufferPool}: PersistentCheckpointStateCacheModules,
+    {
+      config,
+      metrics,
+      logger,
+      clock,
+      signal,
+      datastore,
+      blockStateCache,
+      bufferPool,
+    }: PersistentCheckpointStateCacheModules,
     opts: PersistentCheckpointStateCacheOpts
   ) {
     this.cache = new MapTracker(metrics?.cpStateCache);
+    this.config = config;
     if (metrics) {
       this.metrics = metrics;
       metrics.cpStateCache.size.addCollect(() => {
@@ -484,7 +497,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     }
 
     const blockSlot = state.slot;
-    const processCPStatesTimeMs = state.config.getSlotComponentDurationMs(PROCESS_CHECKPOINT_STATES_BPS);
+    const processCPStatesTimeMs = this.config.getSlotComponentDurationMs(PROCESS_CHECKPOINT_STATES_BPS);
     // we always have clock in production, fallback value is only for test
     const msFromSlot = this.clock?.msFromSlot(blockSlot) ?? processCPStatesTimeMs;
     const msToProcessCPStates = processCPStatesTimeMs - msFromSlot;

package/src/chain/validation/aggregateAndProof.ts

@@ -245,6 +245,18 @@ async function validateAggregateAndProof(
     });
   }
 
+  // Same race-condition check as above for seen aggregators
+  if (
+    !skipValidationKnownAttesters &&
+    chain.seenAggregatedAttestations.isKnown(targetEpoch, attIndex, attDataRootHex, aggregationBits)
+  ) {
+    throw new AttestationError(GossipAction.IGNORE, {
+      code: AttestationErrorCode.ATTESTERS_ALREADY_KNOWN,
+      targetEpoch,
+      aggregateRoot: attDataRootHex,
+    });
+  }
+
   chain.seenAggregators.add(targetEpoch, aggregatorIndex);
   chain.seenAggregatedAttestations.add(
     targetEpoch,

package/src/chain/validation/attesterSlashing.ts

@@ -43,7 +43,7 @@ export async function validateAttesterSlashing(
   // [REJECT] All of the conditions within process_attester_slashing pass validation.
   try {
     // verifySignature = false, verified in batch below
-    assertValidAttesterSlashing(state, attesterSlashing, false);
+    assertValidAttesterSlashing(chain.index2pubkey, state, attesterSlashing, false);
   } catch (e) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID,
@@ -51,7 +51,12 @@ export async function validateAttesterSlashing(
     });
   }
 
-  const signatureSets = getAttesterSlashingSignatureSets(state, attesterSlashing);
+  const signatureSets = getAttesterSlashingSignatureSets(
+    chain.config,
+    chain.index2pubkey,
+    state.slot,
+    attesterSlashing
+  );
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID,

package/src/chain/validation/blobSidecar.ts

@@ -137,7 +137,11 @@ export async function validateGossipBlobSidecar(
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
   const signature = blobSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blobSlot, blockHex, signature)) {
-    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(blockState, blobSidecar.signedBlockHeader);
+    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      chain.index2pubkey,
+      blockState,
+      blobSidecar.signedBlockHeader
+    );
     // Don't batch so verification is not delayed
     if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
       throw new BlobSidecarGossipError(GossipAction.REJECT, {
@@ -240,7 +244,11 @@ export async function validateBlockBlobSidecars(
     const signature = firstSidecarSignedBlockHeader.signature;
     if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRootHex, signature)) {
       const headState = await chain.getHeadState();
-      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+        chain.index2pubkey,
+        headState,
+        firstSidecarSignedBlockHeader
+      );
 
       if (
         !(await chain.bls.verifySignatureSets([signatureSet], {

package/src/chain/validation/block.ts

@@ -154,7 +154,7 @@ export async function validateGossipBlock(
 
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRoot, signedBlock.signature)) {
-    const signatureSet = getBlockProposerSignatureSet(blockState, signedBlock);
+    const signatureSet = getBlockProposerSignatureSet(chain.config, chain.index2pubkey, signedBlock);
     // Don't batch so verification is not delayed
     if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
       throw new BlockGossipError(GossipAction.REJECT, {

package/src/chain/validation/blsToExecutionChange.ts

@@ -41,7 +41,7 @@ async function validateBlsToExecutionChange(
   // NOTE: No need to advance head state since the signature's fork is handled with `broadcastedOnFork`,
   // and chanes relevant to `isValidBlsToExecutionChange()` happen only on processBlock(), not processEpoch()
   const state = chain.getHeadState();
-  const {config} = state;
+  const {config} = chain;
 
   // [REJECT] All of the conditions within process_bls_to_execution_change pass validation.
   // verifySignature = false, verified in batch below

package/src/chain/validation/dataColumnSidecar.ts

@@ -135,6 +135,7 @@ export async function validateGossipDataColumnSidecar(
   const signature = dataColumnSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockHeader.slot, blockRootHex, signature)) {
     const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      chain.index2pubkey,
       blockState,
       dataColumnSidecar.signedBlockHeader
     );
@@ -336,7 +337,11 @@ export async function validateBlockDataColumnSidecars(
     const signature = firstSidecarSignedBlockHeader.signature;
     if (!chain.seenBlockInputCache.isVerifiedProposerSignature(slot, rootHex, signature)) {
       const headState = await chain.getHeadState();
-      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+        chain.index2pubkey,
+        headState,
+        firstSidecarSignedBlockHeader
+      );
 
       if (
         !(await chain.bls.verifySignatureSets([signatureSet], {

package/src/chain/validation/proposerSlashing.ts

@@ -44,7 +44,12 @@ async function validateProposerSlashing(
     });
   }
 
-  const signatureSets = getProposerSlashingSignatureSets(state, proposerSlashing);
+  const signatureSets = getProposerSlashingSignatureSets(
+    chain.config,
+    chain.index2pubkey,
+    state.slot,
+    proposerSlashing
+  );
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
     throw new ProposerSlashingError(GossipAction.REJECT, {
       code: ProposerSlashingErrorCode.INVALID,

package/src/chain/validation/signatureSets/aggregateAndProof.ts

@@ -14,7 +14,7 @@ export function getAggregateAndProofSigningRoot(
   epoch: Epoch,
   aggregateAndProof: SignedAggregateAndProof
 ): Uint8Array {
-  // previously, we call `const aggregatorDomain = state.config.getDomain(state.slot, DOMAIN_AGGREGATE_AND_PROOF, slot);`
+  // previously, we call `const aggregatorDomain = config.getDomain(state.slot, DOMAIN_AGGREGATE_AND_PROOF, slot);`
   // at fork boundary, it's required to dial to target epoch https://github.com/ChainSafe/lodestar/blob/v1.11.3/packages/beacon-node/src/chain/validation/attestation.ts#L573
   // instead of that, just use the fork of slot in the attestation data
   const slot = computeStartSlotAtEpoch(epoch);

package/src/chain/validation/signatureSets/contributionAndProof.ts

@@ -1,18 +1,21 @@
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_CONTRIBUTION_AND_PROOF} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getContributionAndProofSignatureSet(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedContributionAndProof: altair.SignedContributionAndProof
 ): ISignatureSet {
-  const {epochCtx} = state;
-  const domain = state.config.getDomain(
+  const domain = config.getDomain(
     state.slot,
     DOMAIN_CONTRIBUTION_AND_PROOF,
     signedContributionAndProof.message.contribution.slot
@@ -20,7 +23,7 @@ export function getContributionAndProofSignatureSet(
   const signingData = signedContributionAndProof.message;
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedContributionAndProof.message.aggregatorIndex],
+    pubkey: index2pubkey[signedContributionAndProof.message.aggregatorIndex],
     signingRoot: computeSigningRoot(ssz.altair.ContributionAndProof, signingData, domain),
     signature: signedContributionAndProof.signature,
   };

package/src/chain/validation/signatureSets/syncCommittee.ts

@@ -1,21 +1,25 @@
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSignatureSet(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   syncCommittee: altair.SyncCommitteeMessage
 ): ISignatureSet {
-  const domain = state.config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, syncCommittee.slot);
+  const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, syncCommittee.slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: state.epochCtx.index2pubkey[syncCommittee.validatorIndex],
+    pubkey: index2pubkey[syncCommittee.validatorIndex],
     signingRoot: computeSigningRoot(ssz.Root, syncCommittee.beaconBlockRoot, domain),
     signature: syncCommittee.signature,
   };

package/src/chain/validation/signatureSets/syncCommitteeContribution.ts

@@ -1,14 +1,16 @@
 import {PublicKey} from "@chainsafe/blst";
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
 import {CachedBeaconStateAltair, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeContributionSignatureSet(
+  config: BeaconConfig,
   state: CachedBeaconStateAltair,
   contribution: altair.SyncCommitteeContribution,
   pubkeys: PublicKey[]
 ): ISignatureSet {
-  const domain = state.config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, contribution.slot);
+  const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, contribution.slot);
   return {
     type: SignatureSetType.aggregate,
     pubkeys,

package/src/chain/validation/signatureSets/syncCommitteeSelectionProof.ts

@@ -1,17 +1,20 @@
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSelectionProofSignatureSet(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   contributionAndProof: altair.ContributionAndProof
 ): ISignatureSet {
-  const {epochCtx, config} = state;
   const slot = contributionAndProof.contribution.slot;
   const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF, slot);
   const signingData: altair.SyncAggregatorSelectionData = {
@@ -20,7 +23,7 @@ export function getSyncCommitteeSelectionProofSignatureSet(
   };
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[contributionAndProof.aggregatorIndex],
+    pubkey: index2pubkey[contributionAndProof.aggregatorIndex],
     signingRoot: computeSigningRoot(ssz.altair.SyncAggregatorSelectionData, signingData, domain),
     signature: contributionAndProof.selectionProof,
   };

package/src/chain/validation/syncCommittee.ts

@@ -89,7 +89,7 @@ async function validateSyncCommitteeSigOnly(
   syncCommittee: altair.SyncCommitteeMessage,
   prioritizeBls = false
 ): Promise<void> {
-  const signatureSet = getSyncCommitteeSignatureSet(headState, syncCommittee);
+  const signatureSet = getSyncCommitteeSignatureSet(chain.config, chain.index2pubkey, headState, syncCommittee);
   if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
     throw new SyncCommitteeError(GossipAction.REJECT, {
       code: SyncCommitteeErrorCode.INVALID_SIGNATURE,

package/src/chain/validation/syncCommitteeContributionAndProof.ts

@@ -21,6 +21,7 @@ export async function validateSyncCommitteeGossipContributionAndProof(
   const contributionAndProof = signedContributionAndProof.message;
   const {contribution, aggregatorIndex} = contributionAndProof;
   const {subcommitteeIndex, slot} = contribution;
+  const {index2pubkey} = chain;
 
   const headState = chain.getHeadState();
   validateGossipSyncCommitteeExceptSig(chain, headState, subcommitteeIndex, {
@@ -73,20 +74,23 @@ export async function validateSyncCommitteeGossipContributionAndProof(
   // i.e. state.validators[contribution_and_proof.aggregator_index].pubkey in get_sync_subcommittee_pubkeys(state, contribution.subcommittee_index).
   // > Checked in validateGossipSyncCommitteeExceptSig()
 
-  const participantPubkeys = syncCommitteeParticipantIndices.map(
-    (validatorIndex) => headState.epochCtx.index2pubkey[validatorIndex]
-  );
+  const participantPubkeys = syncCommitteeParticipantIndices.map((validatorIndex) => index2pubkey[validatorIndex]);
   const signatureSets = [
     // [REJECT] The contribution_and_proof.selection_proof is a valid signature of the SyncAggregatorSelectionData
     // derived from the contribution by the validator with index contribution_and_proof.aggregator_index.
-    getSyncCommitteeSelectionProofSignatureSet(headState, contributionAndProof),
+    getSyncCommitteeSelectionProofSignatureSet(chain.config, index2pubkey, headState, contributionAndProof),
 
     // [REJECT] The aggregator signature, signed_contribution_and_proof.signature, is valid.
-    getContributionAndProofSignatureSet(headState, signedContributionAndProof),
+    getContributionAndProofSignatureSet(chain.config, index2pubkey, headState, signedContributionAndProof),
 
     // [REJECT] The aggregate signature is valid for the message beacon_block_root and aggregate pubkey derived from
     // the participation info in aggregation_bits for the subcommittee specified by the contribution.subcommittee_index.
-    getSyncCommitteeContributionSignatureSet(headState as CachedBeaconStateAltair, contribution, participantPubkeys),
+    getSyncCommitteeContributionSignatureSet(
+      chain.config,
+      headState as CachedBeaconStateAltair,
+      contribution,
+      participantPubkeys
+    ),
   ];
 
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true}))) {

package/src/chain/validation/voluntaryExit.ts

@@ -59,7 +59,7 @@ async function validateVoluntaryExit(
     });
   }
 
-  const signatureSet = getVoluntaryExitSignatureSet(state, voluntaryExit);
+  const signatureSet = getVoluntaryExitSignatureSet(chain.config, chain.index2pubkey, state.slot, voluntaryExit);
   if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
     throw new VoluntaryExitError(GossipAction.REJECT, {
       code: VoluntaryExitErrorCode.INVALID_SIGNATURE,

package/src/db/beacon.ts

@@ -1,5 +1,6 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {Db, LevelDbControllerMetrics} from "@lodestar/db";
+import {Db, LevelDbControllerMetrics, encodeKey} from "@lodestar/db";
+import {Bucket} from "./buckets.js";
 import {IBeaconDb} from "./interface.js";
 import {CheckpointStateRepository} from "./repositories/checkpointState.js";
 import {
@@ -14,16 +15,12 @@ import {
   CheckpointHeaderRepository,
   DataColumnSidecarArchiveRepository,
   DataColumnSidecarRepository,
-  DepositDataRootRepository,
-  DepositEventRepository,
-  Eth1DataRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
   SyncCommitteeWitnessRepository,
   VoluntaryExitRepository,
 } from "./repositories/index.js";
-import {PreGenesisState, PreGenesisStateLastProcessedBlock} from "./single/index.js";
 
 export type BeaconDbModules = {
   config: ChainForkConfig;
@@ -45,14 +42,8 @@ export class BeaconDb implements IBeaconDb {
   voluntaryExit: VoluntaryExitRepository;
   proposerSlashing: ProposerSlashingRepository;
   attesterSlashing: AttesterSlashingRepository;
-  depositEvent: DepositEventRepository;
   blsToExecutionChange: BLSToExecutionChangeRepository;
 
-  depositDataRoot: DepositDataRootRepository;
-  eth1Data: Eth1DataRepository;
-  preGenesisState: PreGenesisState;
-  preGenesisStateLastProcessedBlock: PreGenesisStateLastProcessedBlock;
-
   // lightclient
   bestLightClientUpdate: BestLightClientUpdateRepository;
   checkpointHeader: CheckpointHeaderRepository;
@@ -80,11 +71,6 @@ export class BeaconDb implements IBeaconDb {
     this.blsToExecutionChange = new BLSToExecutionChangeRepository(config, db);
     this.proposerSlashing = new ProposerSlashingRepository(config, db);
     this.attesterSlashing = new AttesterSlashingRepository(config, db);
-    this.depositEvent = new DepositEventRepository(config, db);
-    this.depositDataRoot = new DepositDataRootRepository(config, db);
-    this.eth1Data = new Eth1DataRepository(config, db);
-    this.preGenesisState = new PreGenesisState(config, db);
-    this.preGenesisStateLastProcessedBlock = new PreGenesisStateLastProcessedBlock(config, db);
 
     // lightclient
     this.bestLightClientUpdate = new BestLightClientUpdateRepository(config, db);
@@ -110,4 +96,40 @@ export class BeaconDb implements IBeaconDb {
     // TODO: Enable once it's deemed safe
     // await this.block.batchDelete(await this.block.keys());
   }
+
+  async deleteDeprecatedEth1Data(): Promise<void> {
+    const deprecatedBuckets = [
+      Bucket.phase0_eth1Data,
+      Bucket.index_depositDataRoot,
+      Bucket.phase0_depositData,
+      Bucket.phase0_depositEvent,
+      Bucket.phase0_preGenesisState,
+      Bucket.phase0_preGenesisStateLastProcessedBlock,
+    ];
+
+    for (const bucket of deprecatedBuckets) {
+      await this.deleteBucketData(bucket);
+    }
+  }
+
+  private async deleteBucketData(bucket: Bucket): Promise<void> {
+    const minKey = encodeKey(bucket, Buffer.alloc(0));
+    const maxKey = encodeKey(bucket + 1, Buffer.alloc(0));
+
+    // Batch delete to avoid loading all keys into memory at once
+    const BATCH_DELETE_SIZE = 1000;
+    let keysBatch: Uint8Array[] = [];
+
+    for await (const key of this.db.keysStream({gte: minKey, lt: maxKey})) {
+      keysBatch.push(key);
+      if (keysBatch.length >= BATCH_DELETE_SIZE) {
+        await this.db.batchDelete(keysBatch);
+        keysBatch = [];
+      }
+    }
+
+    if (keysBatch.length > 0) {
+      await this.db.batchDelete(keysBatch);
+    }
+  }
 }

package/src/db/buckets.ts

@@ -16,14 +16,16 @@ export enum Bucket {
   index_mainChain = 6, // Slot -> Root<BeaconBlock>
   // justified, finalized state and block hashes
   index_chainInfo = 7, // Key -> Number64 | stateHash | blockHash
-  // eth1 processing
-  phase0_eth1Data = 8, // timestamp -> Eth1Data
-  index_depositDataRoot = 9, // depositIndex -> Root<DepositData>
+  /** @deprecated Eth1 deposit tracking is not required since electra, only kept around to delete data from existing databases */
+  phase0_eth1Data = 8,
+  /** @deprecated Eth1 deposit tracking is not required since electra, only kept around to delete data from existing databases */
+  index_depositDataRoot = 9,
 
   // op pool
   // phase0_attestation = 10, // DEPRECATED on v0.25.0
   // phase0_aggregateAndProof = 11, // Root -> AggregateAndProof, DEPRECATED on v.27.0
-  phase0_depositData = 12, // [DEPRECATED] index -> DepositData
+  /** @deprecated Eth1 deposit tracking is not required since electra, only kept around to delete data from existing databases */
+  phase0_depositData = 12,
   phase0_exit = 13, // ValidatorIndex -> VoluntaryExit
   phase0_proposerSlashing = 14, // ValidatorIndex -> ProposerSlashing
   allForks_attesterSlashing = 15, // Root -> AttesterSlashing
@@ -32,15 +34,18 @@ export enum Bucket {
   allForks_checkpointState = 17, // Root -> BeaconState
 
   // allForks_pendingBlock = 25, // Root -> SignedBeaconBlock // DEPRECATED on v0.30.0
-  phase0_depositEvent = 19, // depositIndex -> DepositEvent
+  /** @deprecated Eth1 deposit tracking is not required since electra, only kept around to delete data from existing databases */
+  phase0_depositEvent = 19,
 
   index_stateArchiveRootIndex = 26, // State Root -> slot
 
   deneb_blobSidecars = 27, // DENEB BeaconBlockRoot -> BlobSidecars
   deneb_blobSidecarsArchive = 28, // DENEB BeaconBlockSlot -> BlobSidecars
 
-  phase0_preGenesisState = 30, // Single = phase0.BeaconState
-  phase0_preGenesisStateLastProcessedBlock = 31, // Single = Uint8
+  /** @deprecated Genesis from eth1 is no longer supported, only kept around to delete data from existing databases */
+  phase0_preGenesisState = 30,
+  /** @deprecated Genesis from eth1 is no longer supported, only kept around to delete data from existing databases */
+  phase0_preGenesisStateLastProcessedBlock = 31,
 
   // Lightclient server
   // altair_bestUpdatePerCommitteePeriod = 30, // DEPRECATED on v0.32.0