@lodestar/beacon-node 1.42.0-dev.f6213da56d → 1.42.0-dev.fb8f8a700e

package/src/chain/validation/executionPayloadBid.ts

@@ -1,10 +1,9 @@
 import {PublicKey} from "@chainsafe/blst";
 import {
-  CachedBeaconStateGloas,
-  canBuilderCoverBid,
   createSingleSignatureSetFromComponents,
   getExecutionPayloadBidSigningRoot,
   isActiveBuilder,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {gloas} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
@@ -33,9 +32,10 @@ async function validateExecutionPayloadBid(
   const bid = signedExecutionPayloadBid.message;
   const parentBlockRootHex = toRootHex(bid.parentBlockRoot);
   const parentBlockHashHex = toRootHex(bid.parentBlockHash);
-  const state = (await chain.getHeadStateAtCurrentEpoch(
-    RegenCaller.validateGossipExecutionPayloadBid
-  )) as CachedBeaconStateGloas;
+  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipExecutionPayloadBid);
+  if (!isStatePostGloas(state)) {
+    throw new Error(`Expected gloas+ state for execution payload bid validation, got fork=${state.forkName}`);
+  }
 
   // [IGNORE] `bid.slot` is the current slot or the next slot.
   const currentSlot = chain.clock.currentSlot;
@@ -53,7 +53,7 @@ async function validateExecutionPayloadBid(
 
   // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
   // `is_active_builder(state, bid.builder_index)` returns `True`.
-  const builder = state.builders.getReadonly(bid.builderIndex);
+  const builder = state.getBuilder(bid.builderIndex);
   if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
     throw new ExecutionPayloadBidError(GossipAction.REJECT, {
       code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE,
@@ -87,9 +87,9 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [IGNORE] this bid is the highest value bid seen for the corresponding slot
-  // and the given parent block hash.
-  const bestBid = chain.executionPayloadBidPool.getBestBid(parentBlockRootHex, parentBlockHashHex, bid.slot);
+  // [IGNORE] this bid is the highest value bid seen for the tuple
+  // `(bid.slot, bid.parent_block_hash, bid.parent_block_root)`.
+  const bestBid = chain.executionPayloadBidPool.getBestBid(bid.slot, parentBlockHashHex, parentBlockRootHex);
   if (bestBid !== null && bestBid.value >= bid.value) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.BID_TOO_LOW,
@@ -99,7 +99,7 @@ async function validateExecutionPayloadBid(
   }
   // [IGNORE] `bid.value` is less or equal than the builder's excess balance --
   // i.e. `can_builder_cover_bid(state, builder_index, amount)` returns `True`.
-  if (!canBuilderCoverBid(state, bid.builderIndex, bid.value)) {
+  if (!state.canBuilderCoverBid(bid.builderIndex, bid.value)) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.BID_TOO_HIGH,
       bidValue: bid.value,

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -1,9 +1,8 @@
 import {PayloadStatus} from "@lodestar/fork-choice";
 import {
-  BeaconStateView,
-  CachedBeaconStateGloas,
   computeStartSlotAtEpoch,
   getExecutionPayloadEnvelopeSignatureSet,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {gloas} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
@@ -118,12 +117,14 @@ async function validateExecutionPayloadEnvelope(
         slot: envelope.slot,
       });
     });
+  if (!isStatePostGloas(blockState)) {
+    throw new Error(`Expected gloas+ state for execution payload envelope validation, got fork=${blockState.forkName}`);
+  }
 
-  const state = blockState as CachedBeaconStateGloas;
   const signatureSet = getExecutionPayloadEnvelopeSignatureSet(
     chain.config,
     chain.pubkeyCache,
-    new BeaconStateView(state),
+    blockState,
     executionPayloadEnvelope,
     payloadInput.proposerIndex
   );

package/src/chain/validation/payloadAttestationMessage.ts

@@ -1,8 +1,8 @@
 import {
-  CachedBeaconStateGloas,
   computeEpochAtSlot,
   createSingleSignatureSetFromComponents,
   getPayloadAttestationDataSigningRoot,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {RootHex, gloas, ssz} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
@@ -66,7 +66,10 @@ async function validatePayloadAttestationMessage(
     });
   }
 
-  const state = chain.getHeadState() as CachedBeaconStateGloas;
+  const state = chain.getHeadState();
+  if (!isStatePostGloas(state)) {
+    throw new Error(`Expected gloas+ state for payload attestation validation, got fork=${state.forkName}`);
+  }
 
   // [REJECT] The message's block `data.beacon_block_root` passes validation.
   // TODO GLOAS: implement this. Technically if we cannot get proto block from fork choice,
@@ -75,8 +78,7 @@ async function validatePayloadAttestationMessage(
   // [REJECT] The message's validator index is within the payload committee in
   // `get_ptc(state, data.slot)`. The `state` is the head state corresponding to
   // processing the block up to the current slot as determined by the fork choice.
-  const ptc = state.epochCtx.getPayloadTimelinessCommittee(data.slot);
-  const validatorCommitteeIndex = ptc.indexOf(validatorIndex);
+  const validatorCommitteeIndex = state.getIndexInPayloadTimelinessCommittee(validatorIndex, data.slot);
 
   if (validatorCommitteeIndex === -1) {
     throw new PayloadAttestationError(GossipAction.REJECT, {

package/src/chain/validation/proposerSlashing.ts

@@ -35,7 +35,7 @@ async function validateProposerSlashing(
 
   // [REJECT] All of the conditions within process_proposer_slashing pass validation.
   try {
-    const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
+    const proposer = state.getValidator(proposerSlashing.signedHeader1.message.proposerIndex);
     // verifySignature = false, verified in batch below
     assertValidProposerSlashing(chain.config, chain.pubkeyCache, state.slot, proposerSlashing, proposer, false);
   } catch (e) {

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

@@ -1,16 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_CONTRIBUTION_AND_PROOF} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  ISignatureSet,
-  SignatureSetType,
-  computeSigningRoot,
-} from "@lodestar/state-transition";
+import {IBeaconStateView, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getContributionAndProofSignatureSet(
   config: BeaconConfig,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   signedContributionAndProof: altair.SignedContributionAndProof
 ): ISignatureSet {
   const domain = config.getDomain(

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

@@ -1,16 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  ISignatureSet,
-  SignatureSetType,
-  computeSigningRoot,
-} from "@lodestar/state-transition";
+import {IBeaconStateView, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSignatureSet(
   config: BeaconConfig,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   syncCommittee: altair.SyncCommitteeMessage
 ): ISignatureSet {
   const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, syncCommittee.slot);

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

@@ -1,11 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
-import {CachedBeaconStateAltair, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
+import {IBeaconStateView, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeContributionSignatureSet(
   config: BeaconConfig,
-  state: CachedBeaconStateAltair,
+  state: IBeaconStateView,
   contribution: altair.SyncCommitteeContribution,
   participantIndices: number[]
 ): ISignatureSet {

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

@@ -1,16 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  ISignatureSet,
-  SignatureSetType,
-  computeSigningRoot,
-} from "@lodestar/state-transition";
+import {IBeaconStateView, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSelectionProofSignatureSet(
   config: BeaconConfig,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   contributionAndProof: altair.ContributionAndProof
 ): ISignatureSet {
   const slot = contributionAndProof.contribution.slot;

package/src/chain/validation/syncCommittee.ts

@@ -1,5 +1,5 @@
 import {SYNC_COMMITTEE_SUBNET_COUNT, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
+import {IBeaconStateView, isStatePostAltair} from "@lodestar/state-transition";
 import {SubnetID, altair} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {GossipAction, SyncCommitteeError, SyncCommitteeErrorCode} from "../errors/index.js";
@@ -15,12 +15,12 @@ export async function validateGossipSyncCommittee(
   chain: IBeaconChain,
   syncCommittee: altair.SyncCommitteeMessage,
   subnet: SubnetID
-): Promise<{indexInSubcommittee: IndexInSubcommittee}> {
+): Promise<{indicesInSubcommittee: IndexInSubcommittee[]}> {
   const {slot, validatorIndex, beaconBlockRoot} = syncCommittee;
   const messageRoot = toRootHex(beaconBlockRoot);
 
   const headState = chain.getHeadState();
-  const indexInSubcommittee = validateGossipSyncCommitteeExceptSig(chain, headState, subnet, syncCommittee);
+  const indicesInSubcommittee = validateGossipSyncCommitteeExceptSig(chain, headState, subnet, syncCommittee);
 
   // [IGNORE] The signature's slot is for the current slot, i.e. sync_committee_signature.slot == current_slot.
   // > Checked in validateGossipSyncCommitteeExceptSig()
@@ -68,12 +68,12 @@ export async function validateGossipSyncCommittee(
   // Register this valid item as seen
   chain.seenSyncCommitteeMessages.add(slot, subnet, validatorIndex, messageRoot);
 
-  return {indexInSubcommittee};
+  return {indicesInSubcommittee};
 }
 
 export async function validateApiSyncCommittee(
   chain: IBeaconChain,
-  headState: CachedBeaconStateAllForks,
+  headState: IBeaconStateView,
   syncCommittee: altair.SyncCommitteeMessage
 ): Promise<void> {
   const prioritizeBls = true;
@@ -85,7 +85,7 @@ export async function validateApiSyncCommittee(
  */
 async function validateSyncCommitteeSigOnly(
   chain: IBeaconChain,
-  headState: CachedBeaconStateAllForks,
+  headState: IBeaconStateView,
   syncCommittee: altair.SyncCommitteeMessage,
   prioritizeBls = false
 ): Promise<void> {
@@ -102,10 +102,10 @@ async function validateSyncCommitteeSigOnly(
  */
 export function validateGossipSyncCommitteeExceptSig(
   chain: IBeaconChain,
-  headState: CachedBeaconStateAllForks,
+  headState: IBeaconStateView,
   subnet: SubnetID,
   data: Pick<altair.SyncCommitteeMessage, "slot" | "validatorIndex">
-): IndexInSubcommittee {
+): IndexInSubcommittee[] {
   const {slot, validatorIndex} = data;
   // [IGNORE] The signature's slot is for the current slot, i.e. sync_committee_signature.slot == current_slot.
   // (with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
@@ -127,39 +127,44 @@ export function validateGossipSyncCommitteeExceptSig(
 
   // [REJECT] The subnet_id is valid for the given validator, i.e. subnet_id in compute_subnets_for_sync_committee(state, sync_committee_signature.validator_index).
   // Note this validation implies the validator is part of the broader current sync committee along with the correct subcommittee.
-  const indexInSubcommittee = getIndexInSubcommittee(headState, subnet, data);
-  if (indexInSubcommittee === null) {
+  const indicesInSubcommittee = getIndicesInSubcommittee(headState, subnet, data);
+  if (indicesInSubcommittee === null) {
     throw new SyncCommitteeError(GossipAction.REJECT, {
       code: SyncCommitteeErrorCode.VALIDATOR_NOT_IN_SYNC_COMMITTEE,
       validatorIndex,
     });
   }
 
-  return indexInSubcommittee;
+  return indicesInSubcommittee;
 }
 
 /**
- * Returns the IndexInSubcommittee of the given `subnet`.
- * Returns `null` if not part of the sync committee or not part of the given `subnet`
+ * Returns all IndexInSubcommittee positions of the given `subnet`.
+ * Returns `null` if not part of the sync committee or not part of the given `subnet`.
+ * A validator may appear multiple times in the same subcommittee.
  */
-function getIndexInSubcommittee(
-  headState: CachedBeaconStateAllForks,
+function getIndicesInSubcommittee(
+  headState: IBeaconStateView,
   subnet: SubnetID,
   data: Pick<altair.SyncCommitteeMessage, "slot" | "validatorIndex">
-): IndexInSubcommittee | null {
-  const syncCommittee = headState.epochCtx.getIndexedSyncCommittee(data.slot);
+): IndexInSubcommittee[] | null {
+  if (!isStatePostAltair(headState)) {
+    return null;
+  }
+
+  const syncCommittee = headState.getIndexedSyncCommittee(data.slot);
   const indexesInCommittee = syncCommittee.validatorIndexMap.get(data.validatorIndex);
   if (indexesInCommittee === undefined) {
     // Not part of the sync committee
     return null;
   }
 
+  const indices: IndexInSubcommittee[] = [];
   for (const indexInCommittee of indexesInCommittee) {
     if (Math.floor(indexInCommittee / SYNC_COMMITTEE_SUBNET_SIZE) === subnet) {
-      return indexInCommittee % SYNC_COMMITTEE_SUBNET_SIZE;
+      indices.push(indexInCommittee % SYNC_COMMITTEE_SUBNET_SIZE);
     }
   }
 
-  // Not part of this specific subnet
-  return null;
+  return indices.length > 0 ? indices : null;
 }

package/src/chain/validation/syncCommitteeContributionAndProof.ts

@@ -1,5 +1,5 @@
 import {SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
-import {CachedBeaconStateAltair, isSyncCommitteeAggregator} from "@lodestar/state-transition";
+import {IBeaconStateView, isStatePostAltair, isSyncCommitteeAggregator} from "@lodestar/state-transition";
 import {ValidatorIndex, altair} from "@lodestar/types";
 import {GossipAction, SyncCommitteeError, SyncCommitteeErrorCode} from "../errors/index.js";
 import {IBeaconChain} from "../interface.js";
@@ -53,7 +53,7 @@ export async function validateSyncCommitteeGossipContributionAndProof(
   }
 
   // [REJECT] The contribution has participants -- that is, any(contribution.aggregation_bits)
-  const syncCommitteeParticipantIndices = getContributionIndices(headState as CachedBeaconStateAltair, contribution);
+  const syncCommitteeParticipantIndices = getContributionIndices(headState, contribution);
   if (syncCommitteeParticipantIndices.length === 0) {
     throw new SyncCommitteeError(GossipAction.REJECT, {
       code: SyncCommitteeErrorCode.NO_PARTICIPANT,
@@ -83,12 +83,7 @@ export async function validateSyncCommitteeGossipContributionAndProof(
 
     // [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(
-      chain.config,
-      headState as CachedBeaconStateAltair,
-      contribution,
-      syncCommitteeParticipantIndices
-    ),
+    getSyncCommitteeContributionSignatureSet(chain.config, headState, contribution, syncCommitteeParticipantIndices),
   ];
 
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true}))) {
@@ -109,12 +104,16 @@ export async function validateSyncCommitteeGossipContributionAndProof(
  * - pubkeyCache
  */
 function getContributionIndices(
-  state: CachedBeaconStateAltair,
+  state: IBeaconStateView,
   contribution: altair.SyncCommitteeContribution
 ): ValidatorIndex[] {
+  if (!isStatePostAltair(state)) {
+    throw new Error("Expected Altair state for sync committee contribution");
+  }
+
   const startIndex = contribution.subcommitteeIndex * SYNC_COMMITTEE_SUBNET_SIZE;
 
-  const syncCommittee = state.epochCtx.getIndexedSyncCommittee(contribution.slot);
+  const syncCommittee = state.getIndexedSyncCommittee(contribution.slot);
   // The bits in contribution.aggregationBits select validatorIndexes in the subcommittee starting at startIndex
   const subcommitteeValidatorIndices = syncCommittee.validatorIndices.slice(
     startIndex,

package/src/chain/validation/voluntaryExit.ts

@@ -1,9 +1,4 @@
-import {
-  BeaconStateView,
-  VoluntaryExitValidity,
-  getVoluntaryExitSignatureSet,
-  getVoluntaryExitValidity,
-} from "@lodestar/state-transition";
+import {VoluntaryExitValidity, getVoluntaryExitSignatureSet} from "@lodestar/state-transition";
 import {phase0} from "@lodestar/types";
 import {
   GossipAction,
@@ -53,14 +48,14 @@ async function validateVoluntaryExit(
 
   // [REJECT] All of the conditions within process_voluntary_exit pass validation.
   // verifySignature = false, verified in batch below
-  const validity = getVoluntaryExitValidity(chain.config.getForkSeq(state.slot), state, voluntaryExit, false);
+  const validity = state.getVoluntaryExitValidity(voluntaryExit, false);
   if (validity !== VoluntaryExitValidity.valid) {
     throw new VoluntaryExitError(GossipAction.REJECT, {
       code: voluntaryExitValidityToErrorCode(validity),
     });
   }
 
-  const signatureSet = getVoluntaryExitSignatureSet(chain.config, new BeaconStateView(state), voluntaryExit);
+  const signatureSet = getVoluntaryExitSignatureSet(chain.config, state, voluntaryExit);
   if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
     throw new VoluntaryExitError(GossipAction.REJECT, {
       code: VoluntaryExitErrorCode.INVALID_SIGNATURE,

package/src/chain/validatorMonitor.ts

@@ -1,14 +1,13 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkSeq, MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
-  CachedBeaconStateAllForks,
-  CachedBeaconStateAltair,
+  IBeaconStateView,
   ParticipationFlags,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   computeTimeAtSlot,
-  getBlockRootAtSlot,
   getCurrentSlot,
+  isStatePostAltair,
   parseAttesterFlags,
   parseParticipationFlags,
 } from "@lodestar/state-transition";
@@ -102,7 +101,7 @@ export type ValidatorMonitor = {
     syncAggregate: altair.SyncAggregate,
     syncCommitteeIndices: Uint32Array
   ): void;
-  onceEveryEndOfEpoch(state: CachedBeaconStateAllForks): void;
+  onceEveryEndOfEpoch(state: IBeaconStateView): void;
   scrapeMetrics(slotClock: Slot): void;
   /** Returns the list of validator indices currently being monitored */
   getMonitoredValidatorIndices(): ValidatorIndex[];
@@ -736,16 +735,19 @@ export function createValidatorMonitor(
         return;
       }
 
+      if (validators.size === 0) {
+        return;
+      }
+
       const rootCache = new RootHexCache(headState);
 
-      if (config.getForkSeq(headState.slot) >= ForkSeq.altair) {
-        const {previousEpochParticipation} = headState as CachedBeaconStateAltair;
+      if (isStatePostAltair(headState)) {
         const prevEpochStartSlot = computeStartSlotAtEpoch(prevEpoch);
-        const prevEpochTargetRoot = toRootHex(getBlockRootAtSlot(headState, prevEpochStartSlot));
+        const prevEpochTargetRoot = toRootHex(headState.getBlockRootAtSlot(prevEpochStartSlot));
 
         // Check attestation performance
         for (const [index, validator] of validators.entries()) {
-          const flags = parseParticipationFlags(previousEpochParticipation.get(index));
+          const flags = parseParticipationFlags(headState.getPreviousEpochParticipation(index));
           const attestationSummary = validator.attestations.get(prevEpoch)?.get(prevEpochTargetRoot);
           const summary = renderAttestationSummary(config, rootCache, attestationSummary, flags);
           validatorMonitorMetrics?.prevEpochAttestationSummary.inc({summary});
@@ -757,9 +759,9 @@ export function createValidatorMonitor(
         }
       }
 
-      if (headState.epochCtx.proposersPrevEpoch !== null) {
+      if (headState.previousProposers !== null) {
         // proposersPrevEpoch is null on the first epoch of `headState` being generated
-        for (const [slotIndex, validatorIndex] of headState.epochCtx.proposersPrevEpoch.entries()) {
+        for (const [slotIndex, validatorIndex] of headState.previousProposers.entries()) {
           const validator = validators.get(validatorIndex);
           if (validator) {
             // If expected proposer is a tracked validator
@@ -1139,12 +1141,12 @@ function renderBlockProposalSummary(
 export class RootHexCache {
   private readonly blockRootSlotCache = new Map<Slot, RootHex>();
 
-  constructor(private readonly state: CachedBeaconStateAllForks) {}
+  constructor(private readonly state: IBeaconStateView) {}
 
   getBlockRootAtSlot(slot: Slot): RootHex {
     let root = this.blockRootSlotCache.get(slot);
     if (!root) {
-      root = toRootHex(getBlockRootAtSlot(this.state, slot));
+      root = toRootHex(this.state.getBlockRootAtSlot(slot));
       this.blockRootSlotCache.set(slot, root);
     }
     return root;

package/src/db/buckets.ts

@@ -67,8 +67,8 @@ export enum Bucket {
   // lightClient_bestLightClientUpdate = 55, // SyncPeriod -> LightClientUpdate // DEPRECATED on v1.5.0
   lightClient_bestLightClientUpdate = 56, // SyncPeriod -> [Slot, LightClientUpdate]
 
-  fulu_dataColumnSidecars = 57, // FULU BeaconBlockRoot -> DataColumnSidecars
-  fulu_dataColumnSidecarsArchive = 58, // FULU BeaconBlockSlot -> DataColumnSidecars
+  allForks_dataColumnSidecars = 57, // BeaconBlockRoot -> DataColumnSidecars
+  allForks_dataColumnSidecarsArchive = 58, // BeaconBlockSlot -> DataColumnSidecars
 
   gloas_executionPayloadEnvelope = 59, // GLOAS BeaconBlockRoot -> SignedExecutionPayloadEnvelope
   gloas_executionPayloadEnvelopeArchive = 60, // GLOAS Slot -> SignedExecutionPayloadEnvelope

package/src/db/repositories/dataColumnSidecar.ts

@@ -18,8 +18,10 @@ type BlockRoot = Root;
  */
 export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, ColumnIndex, DataColumnSidecar> {
   constructor(config: ChainForkConfig, db: Db) {
-    const bucket = Bucket.fulu_dataColumnSidecars;
-    super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
+    const bucket = Bucket.allForks_dataColumnSidecars;
+    // Type won't be used since we select it dynamically based on fork
+    const type = ssz.fulu.DataColumnSidecar;
+    super(config, db, bucket, type, getBucketNameByValue(bucket));
   }
 
   /**

package/src/db/repositories/dataColumnSidecarArchive.ts

@@ -16,8 +16,10 @@ const SLOT_BYTE_SIZE = 8;
  */
 export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot, ColumnIndex, DataColumnSidecar> {
   constructor(config: ChainForkConfig, db: Db) {
-    const bucket = Bucket.fulu_dataColumnSidecarsArchive;
-    super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
+    const bucket = Bucket.allForks_dataColumnSidecarsArchive;
+    // Type won't be used since we select it dynamically based on fork
+    const type = ssz.fulu.DataColumnSidecar;
+    super(config, db, bucket, type, getBucketNameByValue(bucket));
   }
 
   /**

package/src/metrics/metrics/lodestar.ts

@@ -1712,33 +1712,71 @@ export function createLodestarMetrics(
       }),
     },
 
-    // reprocess gossip attestations
-    reprocessGossipAttestations: {
-      total: register.gauge({
-        name: "lodestar_reprocess_gossip_attestations_total",
-        help: "Total number of gossip attestations waiting to reprocess",
+    // some gossip messages need to wait for block to be processed before they can be processed
+    awaitingBlockGossipMessages: {
+      queue: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_block_gossip_messages_total",
+        help: "Total number of gossip messages waiting for block to be processed",
+        labelNames: ["topic"],
       }),
       countPerSlot: register.gauge({
-        name: "lodestar_reprocess_gossip_attestations_per_slot_total",
-        help: "Total number of gossip attestations waiting to reprocess pet slot",
+        name: "lodestar_awaiting_block_gossip_messages_per_slot_total",
+        help: "Total number of gossip messages waiting for block to be processed per slot",
       }),
-      resolve: register.gauge({
-        name: "lodestar_reprocess_gossip_attestations_resolve_total",
-        help: "Total number of gossip attestations are reprocessed",
+      resolve: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_block_gossip_messages_resolve_total",
+        help: "Total number of gossip messages are reprocessed",
+        labelNames: ["topic"],
       }),
-      waitSecBeforeResolve: register.gauge({
-        name: "lodestar_reprocess_gossip_attestations_wait_time_resolve_seconds",
+      waitSecBeforeResolve: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_block_gossip_messages_wait_time_resolve_seconds",
         help: "Time to wait for unknown block in seconds",
+        labelNames: ["topic"],
       }),
-      reject: register.gauge<{reason: ReprocessRejectReason}>({
-        name: "lodestar_reprocess_gossip_attestations_reject_total",
-        help: "Total number of attestations are rejected to reprocess",
-        labelNames: ["reason"],
+      // having 2 labels here is not great for performance, however it's rarely happening and having the reason label is important for debugging
+      reject: register.gauge<{reason: ReprocessRejectReason; topic: GossipType}>({
+        name: "lodestar_awaiting_block_gossip_messages_reject_total",
+        help: "Total number of gossip messages are rejected to reprocess",
+        labelNames: ["reason", "topic"],
       }),
-      waitSecBeforeReject: register.gauge<{reason: ReprocessRejectReason}>({
-        name: "lodestar_reprocess_gossip_attestations_wait_time_reject_seconds",
+      waitSecBeforeReject: register.gauge<{reason: ReprocessRejectReason; topic: GossipType}>({
+        name: "lodestar_awaiting_block_gossip_messages_wait_time_reject_seconds",
         help: "Time to wait for unknown block before being rejected",
-        labelNames: ["reason"],
+        labelNames: ["reason", "topic"],
+      }),
+    },
+
+    // some gossip messages need to wait for payload to be processed before they can be processed
+    awaitingPayloadGossipMessages: {
+      queue: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_total",
+        help: "Total number of gossip messages waiting for payload to be processed",
+        labelNames: ["topic"],
+      }),
+      countPerSlot: register.gauge({
+        name: "lodestar_awaiting_payload_gossip_messages_per_slot_total",
+        help: "Total number of gossip messages waiting for payload to be processed per slot",
+      }),
+      resolve: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_resolve_total",
+        help: "Total number of gossip messages are reprocessed",
+        labelNames: ["topic"],
+      }),
+      waitSecBeforeResolve: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_wait_time_resolve_seconds",
+        help: "Time to wait for unknown payload in seconds",
+        labelNames: ["topic"],
+      }),
+      // having 2 labels here is not great for performance, however it's rarely happening and having the reason label is important for debugging
+      reject: register.gauge<{reason: ReprocessRejectReason; topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_reject_total",
+        help: "Total number of gossip messages are rejected to reprocess",
+        labelNames: ["reason", "topic"],
+      }),
+      waitSecBeforeReject: register.gauge<{reason: ReprocessRejectReason; topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_wait_time_reject_seconds",
+        help: "Time to wait for unknown payload before being rejected",
+        labelNames: ["reason", "topic"],
       }),
     },
 

package/src/network/gossip/encoding.ts

@@ -24,12 +24,28 @@ const decoder = new snappyWasm.Decoder();
 // Shared buffer to convert msgId to string
 const sharedMsgIdBuf = Buffer.alloc(20);
 
+// Cache topic -> seed to avoid per-message allocations on the hot path.
+// Topics are a fixed set per fork (changes only at fork boundaries).
+const topicSeedCache = new Map<string, bigint>();
+
 /**
  * The function used to generate a gossipsub message id
  * We use the first 8 bytes of SHA256(data) for content addressing
  */
 export function fastMsgIdFn(rpcMsg: RPC.Message): string {
   if (rpcMsg.data) {
+    if (rpcMsg.topic) {
+      // Use topic-derived seed to prevent cross-topic deduplication of identical messages.
+      // SyncCommitteeMessages are published to multiple sync_committee_{subnet} topics with
+      // identical data, so hashing only the data incorrectly deduplicates across subnets.
+      // See https://github.com/ChainSafe/lodestar/issues/8294
+      let topicSeed = topicSeedCache.get(rpcMsg.topic);
+      if (topicSeed === undefined) {
+        topicSeed = xxhash.h64Raw(Buffer.from(rpcMsg.topic), h64Seed);
+        topicSeedCache.set(rpcMsg.topic, topicSeed);
+      }
+      return xxhash.h64Raw(rpcMsg.data, topicSeed).toString(16);
+    }
     return xxhash.h64Raw(rpcMsg.data, h64Seed).toString(16);
   }
   return "0000000000000000";