@lodestar/beacon-node 1.29.0-dev.87d367d9f7 → 1.29.0-dev.8aa1ad8d30

package/lib/chain/opPools/aggregatedAttestationPool.js

@@ -1,11 +1,11 @@
 import { aggregateSignatures } from "@chainsafe/blst";
 import { BitArray } from "@chainsafe/ssz";
-import { EpochDifference } from "@lodestar/fork-choice";
 import { ForkName, ForkSeq, MAX_ATTESTATIONS, MAX_ATTESTATIONS_ELECTRA, MAX_COMMITTEES_PER_SLOT, MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH, isForkPostDeneb, isForkPostElectra, } from "@lodestar/params";
 import { computeEpochAtSlot, computeSlotsSinceEpochStart, computeStartSlotAtEpoch, getBlockRootAtSlot, } from "@lodestar/state-transition";
 import { isElectraAttestation, ssz, } from "@lodestar/types";
 import { assert, MapDef, toRootHex } from "@lodestar/utils";
 import { IntersectResult, intersectUint8Arrays } from "../../util/bitArray.js";
+import { getShufflingDependentRoot } from "../../util/dependentRoot.js";
 import { InsertOutcome } from "./types.js";
 import { pruneBySlot, signatureFromBytesNoCheck } from "./utils.js";
 /**
@@ -15,6 +15,14 @@ import { pruneBySlot, signatureFromBytesNoCheck } from "./utils.js";
  * how does participation looks like in attestations.
  */
 const MAX_RETAINED_ATTESTATIONS_PER_GROUP = 4;
+/**
+ * This is the same to MAX_RETAINED_ATTESTATIONS_PER_GROUP but for electra.
+ * As monitored in hoodi, max attestations per group could be up to > 10. But since electra we can
+ * consolidate attestations across committees, so we can just pick up to 8 attestations per group.
+ * Also the MatchingDataAttestationGroup.getAttestationsForBlock() is improved not to have to scan each
+ * committee member for previous slot.
+ */
+const MAX_RETAINED_ATTESTATIONS_PER_GROUP_ELECTRA = 8;
 /**
  * Pre-electra, each slot has 64 committees, and each block has 128 attestations max so in average
  * we get 2 attestation per groups.
@@ -24,20 +32,30 @@ const MAX_RETAINED_ATTESTATIONS_PER_GROUP = 4;
  */
 const MAX_ATTESTATIONS_PER_GROUP = 3;
 /**
- * For electra, each block has up to 8 aggregated attestations, assuming there are 3 for the "best"
- * attestation data, there are still 5 for other attestation data so this constant is still good.
- * We should separate to 2 constant based on conditions of different networks
+ * For electra, there is on chain aggregation of attestations across committees, so we can just pick up to 8
+ * attestations per group, sort by scores to get first 8.
+ * The new algorithm helps not to include useless attestations so we usually cannot get up to 8.
+ * The more consolidations we have per block, the less likely we have to scan all slots in the pool.
+ * This is max attestations returned per group, it does not make sense to have this number greater
+ * than MAX_RETAINED_ATTESTATIONS_PER_GROUP_ELECTRA or MAX_ATTESTATIONS_ELECTRA.
  */
-const MAX_ATTESTATIONS_PER_GROUP_ELECTRA = 3;
+const MAX_ATTESTATIONS_PER_GROUP_ELECTRA = Math.min(MAX_RETAINED_ATTESTATIONS_PER_GROUP_ELECTRA, MAX_ATTESTATIONS_ELECTRA);
+export var ScannedSlotsTerminationReason;
+(function (ScannedSlotsTerminationReason) {
+    ScannedSlotsTerminationReason["MaxConsolidationReached"] = "max_consolidation_reached";
+    ScannedSlotsTerminationReason["ScannedAllSlots"] = "scanned_all_slots";
+    ScannedSlotsTerminationReason["SlotBeforePreviousEpoch"] = "slot_before_previous_epoch";
+})(ScannedSlotsTerminationReason || (ScannedSlotsTerminationReason = {}));
 /**
  * Maintain a pool of aggregated attestations. Attestations can be retrieved for inclusion in a block
- * or api. The returned attestations are aggregated to maximise the number of validators that can be
+ * or api. The returned attestations are aggregated to maximize the number of validators that can be
  * included.
  * Note that we want to remove attestations with attesters that were included in the chain.
  */
 export class AggregatedAttestationPool {
-    constructor(config) {
+    constructor(config, metrics = null) {
         this.config = config;
+        this.metrics = metrics;
         /**
          * post electra, different committees could have the same AttData and we have to consolidate attestations of the same
          * data to be included in block, so we should group by data before index
@@ -45,20 +63,7 @@ export class AggregatedAttestationPool {
          */
         this.attestationGroupByIndexByDataHexBySlot = new MapDef(() => new Map());
         this.lowestPermissibleSlot = 0;
-    }
-    /** For metrics to track size of the pool */
-    getAttestationCount() {
-        let attestationCount = 0;
-        let attestationDataCount = 0;
-        for (const attestationGroupByIndexByDataHex of this.attestationGroupByIndexByDataHexBySlot.values()) {
-            for (const attestationGroupByIndex of attestationGroupByIndexByDataHex.values()) {
-                attestationDataCount += attestationGroupByIndex.size;
-                for (const attestationGroup of attestationGroupByIndex.values()) {
-                    attestationCount += attestationGroup.getAttestationCount();
-                }
-            }
-        }
-        return { attestationCount, attestationDataCount };
+        metrics?.opPool.aggregatedAttestationPool.attDataPerSlot.addCollect(() => this.onScrapeMetrics(metrics));
     }
     add(attestation, dataRootHex, attestingIndicesCount, committee) {
         const slot = attestation.data.slot;
@@ -90,7 +95,7 @@ export class AggregatedAttestationPool {
         assert.notNull(committeeIndex, "Committee index should not be null in aggregated attestation pool");
         let attestationGroup = attestationGroupByIndex.get(committeeIndex);
         if (!attestationGroup) {
-            attestationGroup = new MatchingDataAttestationGroup(committee, attestation.data);
+            attestationGroup = new MatchingDataAttestationGroup(this.config, committee, attestation.data);
             attestationGroupByIndex.set(committeeIndex, attestationGroup);
         }
         return attestationGroup.add({
@@ -146,16 +151,16 @@ export class AggregatedAttestationPool {
                 (ForkSeq[fork] >= ForkSeq.deneb || stateSlot <= slot + SLOTS_PER_EPOCH))) {
                 continue; // Invalid attestations
             }
-            const slotDelta = stateSlot - slot;
+            const inclusionDistance = stateSlot - slot;
             for (const attestationGroupByIndex of attestationGroupByIndexByDataHash.values()) {
                 for (const [committeeIndex, attestationGroup] of attestationGroupByIndex.entries()) {
-                    const notSeenAttestingIndices = notSeenValidatorsFn(epoch, slot, committeeIndex);
-                    if (notSeenAttestingIndices === null || notSeenAttestingIndices.size === 0) {
+                    const notSeenCommitteeMembers = notSeenValidatorsFn(epoch, slot, committeeIndex);
+                    if (notSeenCommitteeMembers === null || notSeenCommitteeMembers.size === 0) {
                         continue;
                     }
                     if (slotCount > 2 &&
                         attestationsByScore.length >= MAX_ATTESTATIONS &&
-                        notSeenAttestingIndices.size / slotDelta < minScore) {
+                        notSeenCommitteeMembers.size / inclusionDistance < minScore) {
                         // after 2 slots, there are a good chance that we have 2 * MAX_ATTESTATIONS attestations and break the for loop early
                         // if not, we may have to scan all slots in the pool
                         // if we have enough attestations and the max possible score is lower than scores of `attestationsByScore`, we should skip
@@ -172,8 +177,9 @@ export class AggregatedAttestationPool {
                     // These properties should not change after being validate in gossip
                     // IF they have to be validated, do it only with one attestation per group since same data
                     // The committeeCountPerSlot can be precomputed once per slot
-                    for (const { attestation, notSeenAttesterCount } of attestationGroup.getAttestationsForBlock(fork, notSeenAttestingIndices)) {
-                        const score = notSeenAttesterCount / slotDelta;
+                    const getAttestationsResult = attestationGroup.getAttestationsForBlock(fork, state.epochCtx.effectiveBalanceIncrements, notSeenCommitteeMembers, MAX_ATTESTATIONS_PER_GROUP);
+                    for (const { attestation, newSeenEffectiveBalance } of getAttestationsResult.result) {
+                        const score = newSeenEffectiveBalance / inclusionDistance;
                         if (score < minScore) {
                             minScore = score;
                         }
@@ -212,49 +218,56 @@ export class AggregatedAttestationPool {
         const slots = Array.from(this.attestationGroupByIndexByDataHexBySlot.keys()).sort((a, b) => b - a);
         // Track score of each `AttestationsConsolidation`
         const consolidations = new Map();
-        let minScore = Number.MAX_SAFE_INTEGER;
-        let slotCount = 0;
+        let scannedSlots = 0;
+        let stopReason = null;
         slot: for (const slot of slots) {
-            slotCount++;
             const attestationGroupByIndexByDataHash = this.attestationGroupByIndexByDataHexBySlot.get(slot);
             // should not happen
             if (!attestationGroupByIndexByDataHash) {
                 throw Error(`No aggregated attestation pool for slot=${slot}`);
             }
             const epoch = computeEpochAtSlot(slot);
+            if (epoch < statePrevEpoch) {
+                // we process slot in desc order, this means next slot is not eligible, we should stop
+                stopReason = ScannedSlotsTerminationReason.SlotBeforePreviousEpoch;
+                break;
+            }
             // validateAttestation condition: Attestation target epoch not in previous or current epoch
             if (!(epoch === stateEpoch || epoch === statePrevEpoch)) {
                 continue; // Invalid attestations
             }
             // validateAttestation condition: Attestation slot not within inclusion window
             if (!(slot + MIN_ATTESTATION_INCLUSION_DELAY <= stateSlot)) {
+                // this should not happen as slot is decreased so no need to track in metric
                 continue; // Invalid attestations
             }
-            const slotDelta = stateSlot - slot;
-            // CommitteeIndex    0           1            2    ...   Consolidation
+            const inclusionDistance = stateSlot - slot;
+            let returnedAttestationsPerSlot = 0;
+            let totalAttestationsPerSlot = 0;
+            // CommitteeIndex    0           1            2    ...   Consolidation (sameAttDataCons)
             // Attestations    att00  ---   att10  ---  att20  ---   0 (att 00 10 20)
             //                 att01  ---     -    ---  att21  ---   1 (att 01 __ 21)
             //                   -    ---     -    ---  att22  ---   2 (att __ __ 22)
             for (const attestationGroupByIndex of attestationGroupByIndexByDataHash.values()) {
                 // sameAttDataCons could be up to MAX_ATTESTATIONS_PER_GROUP_ELECTRA
                 const sameAttDataCons = [];
+                const allAttestationGroups = Array.from(attestationGroupByIndex.values());
+                if (allAttestationGroups.length === 0) {
+                    this.metrics?.opPool.aggregatedAttestationPool.packedAttestations.emptyAttestationData.inc();
+                    continue;
+                }
+                if (!validateAttestationDataFn(allAttestationGroups[0].data)) {
+                    this.metrics?.opPool.aggregatedAttestationPool.packedAttestations.invalidAttestationData.inc();
+                    continue;
+                }
                 for (const [committeeIndex, attestationGroup] of attestationGroupByIndex.entries()) {
-                    const notSeenAttestingIndices = notSeenValidatorsFn(epoch, slot, committeeIndex);
-                    if (notSeenAttestingIndices === null || notSeenAttestingIndices.size === 0) {
-                        continue;
-                    }
-                    if (slotCount > 2 &&
-                        consolidations.size >= MAX_ATTESTATIONS_ELECTRA &&
-                        notSeenAttestingIndices.size / slotDelta < minScore) {
-                        // after 2 slots, there are a good chance that we have 2 * MAX_ATTESTATIONS_ELECTRA attestations and break the for loop early
-                        // if not, we may have to scan all slots in the pool
-                        // if we have enough attestations and the max possible score is lower than scores of `attestationsByScore`, we should skip
-                        // otherwise it takes time to check attestation, add it and remove it later after the sort by score
-                        continue;
-                    }
-                    if (!validateAttestationDataFn(attestationGroup.data)) {
+                    const notSeenCommitteeMembers = notSeenValidatorsFn(epoch, slot, committeeIndex);
+                    if (notSeenCommitteeMembers === null || notSeenCommitteeMembers.size === 0) {
+                        this.metrics?.opPool.aggregatedAttestationPool.packedAttestations.seenCommittees.inc();
                         continue;
                     }
+                    // cannot apply this optimization like pre-electra because consolidation needs to be done across committees:
+                    // "after 2 slots, there are a good chance that we have 2 * MAX_ATTESTATIONS_ELECTRA attestations and break the for loop early"
                     // TODO: Is it necessary to validateAttestation for:
                     // - Attestation committee index not within current committee count
                     // - Attestation aggregation bits length does not match committee length
@@ -262,39 +275,73 @@ export class AggregatedAttestationPool {
                     // These properties should not change after being validate in gossip
                     // IF they have to be validated, do it only with one attestation per group since same data
                     // The committeeCountPerSlot can be precomputed once per slot
-                    for (const [i, attestationNonParticipation] of attestationGroup
-                        .getAttestationsForBlock(fork, notSeenAttestingIndices)
-                        .entries()) {
+                    const getAttestationGroupResult = attestationGroup.getAttestationsForBlock(fork, state.epochCtx.effectiveBalanceIncrements, notSeenCommitteeMembers, MAX_ATTESTATIONS_PER_GROUP_ELECTRA);
+                    const attestationsSameGroup = getAttestationGroupResult.result;
+                    returnedAttestationsPerSlot += attestationsSameGroup.length;
+                    totalAttestationsPerSlot += getAttestationGroupResult.totalAttestations;
+                    for (const [i, attestationNonParticipation] of attestationsSameGroup.entries()) {
+                        // sameAttDataCons shares the same index for different committees so we use index `i` here
                         if (sameAttDataCons[i] === undefined) {
                             sameAttDataCons[i] = {
                                 byCommittee: new Map(),
                                 attData: attestationNonParticipation.attestation.data,
-                                totalNotSeenCount: 0,
+                                totalNewSeenEffectiveBalance: 0,
+                                newSeenAttesters: 0,
+                                notSeenAttesters: 0,
+                                totalAttesters: 0,
                             };
                         }
-                        sameAttDataCons[i].byCommittee.set(committeeIndex, attestationNonParticipation);
-                        sameAttDataCons[i].totalNotSeenCount += attestationNonParticipation.notSeenAttesterCount;
-                    }
-                    for (const consolidation of sameAttDataCons) {
-                        const score = consolidation.totalNotSeenCount / slotDelta;
-                        if (score < minScore) {
-                            minScore = score;
-                        }
-                        consolidations.set(consolidation, score);
-                        // Stop accumulating attestations there are enough that may have good scoring
-                        if (consolidations.size >= MAX_ATTESTATIONS_ELECTRA * 2) {
-                            break slot;
+                        const sameAttDataCon = sameAttDataCons[i];
+                        // committeeIndex was from a map so it should be unique, but just in case
+                        if (!sameAttDataCon.byCommittee.has(committeeIndex)) {
+                            sameAttDataCon.byCommittee.set(committeeIndex, attestationNonParticipation);
+                            sameAttDataCon.totalNewSeenEffectiveBalance += attestationNonParticipation.newSeenEffectiveBalance;
+                            sameAttDataCon.newSeenAttesters += attestationNonParticipation.newSeenAttesters;
+                            sameAttDataCon.notSeenAttesters += attestationNonParticipation.notSeenCommitteeMembers.size;
+                            sameAttDataCon.totalAttesters += attestationGroup.committee.length;
                         }
                     }
+                } // all committees are processed
+                this.metrics?.opPool.aggregatedAttestationPool.packedAttestations.returnedAttestations.set({ inclusionDistance }, returnedAttestationsPerSlot);
+                this.metrics?.opPool.aggregatedAttestationPool.packedAttestations.scannedAttestations.set({ inclusionDistance }, totalAttestationsPerSlot);
+                // after all committees are processed, we have a list of sameAttDataCons
+                for (const consolidation of sameAttDataCons) {
+                    const score = consolidation.totalNewSeenEffectiveBalance / inclusionDistance;
+                    consolidations.set(consolidation, score);
+                    // Stop accumulating attestations there are enough that may have good scoring
+                    if (consolidations.size >= MAX_ATTESTATIONS_ELECTRA * 2) {
+                        stopReason = ScannedSlotsTerminationReason.MaxConsolidationReached;
+                        break slot;
+                    }
                 }
             }
+            // finished processing a slot
+            scannedSlots++;
         }
+        this.metrics?.opPool.aggregatedAttestationPool.packedAttestations.totalConsolidations.set(consolidations.size);
         const sortedConsolidationsByScore = Array.from(consolidations.entries())
             .sort((a, b) => b[1] - a[1])
             .map(([consolidation, _]) => consolidation)
             .slice(0, MAX_ATTESTATIONS_ELECTRA);
         // on chain aggregation is expensive, only do it after all
-        return sortedConsolidationsByScore.map(aggregateConsolidation);
+        const packedAttestationsMetrics = this.metrics?.opPool.aggregatedAttestationPool.packedAttestations;
+        const packedAttestations = new Array(sortedConsolidationsByScore.length);
+        for (const [i, consolidation] of sortedConsolidationsByScore.entries()) {
+            packedAttestations[i] = aggregateConsolidation(consolidation);
+            // record metrics of packed attestations
+            packedAttestationsMetrics?.committeeCount.set({ index: i }, consolidation.byCommittee.size);
+            packedAttestationsMetrics?.totalAttesters.set({ index: i }, consolidation.totalAttesters);
+            packedAttestationsMetrics?.nonParticipation.set({ index: i }, consolidation.notSeenAttesters);
+            packedAttestationsMetrics?.inclusionDistance.set({ index: i }, stateSlot - packedAttestations[i].data.slot);
+            packedAttestationsMetrics?.newSeenAttesters.set({ index: i }, consolidation.newSeenAttesters);
+            packedAttestationsMetrics?.totalEffectiveBalance.set({ index: i }, consolidation.totalNewSeenEffectiveBalance);
+        }
+        if (stopReason === null) {
+            stopReason = ScannedSlotsTerminationReason.ScannedAllSlots;
+        }
+        packedAttestationsMetrics?.scannedSlots.set({ reason: stopReason }, scannedSlots);
+        packedAttestationsMetrics?.poolSlots.set(slots.length);
+        return packedAttestations;
     }
     /**
      * Get all attestations optionally filtered by `attestation.data.slot`
@@ -323,6 +370,49 @@ export class AggregatedAttestationPool {
         }
         return attestations;
     }
+    onScrapeMetrics(metrics) {
+        const poolMetrics = metrics.opPool.aggregatedAttestationPool;
+        const allSlots = Array.from(this.attestationGroupByIndexByDataHexBySlot.keys());
+        // last item is current slot, we want the previous one, if available.
+        const previousSlot = allSlots.length > 1 ? (allSlots.at(-2) ?? null) : null;
+        let attestationCount = 0;
+        let attestationDataCount = 0;
+        // always record the previous slot because the current slot may not be finished yet, we may receive more attestations
+        if (previousSlot !== null) {
+            const groupByIndexByDataHex = this.attestationGroupByIndexByDataHexBySlot.get(previousSlot);
+            if (groupByIndexByDataHex != null) {
+                poolMetrics.attDataPerSlot.set(groupByIndexByDataHex.size);
+                let maxAttestations = 0;
+                let committeeCount = 0;
+                for (const groupByIndex of groupByIndexByDataHex.values()) {
+                    attestationDataCount += groupByIndex.size;
+                    for (const group of groupByIndex.values()) {
+                        const attestationCountInGroup = group.getAttestationCount();
+                        maxAttestations = Math.max(maxAttestations, attestationCountInGroup);
+                        poolMetrics.attestationsPerCommittee.observe(attestationCountInGroup);
+                        committeeCount += 1;
+                        attestationCount += attestationCountInGroup;
+                    }
+                }
+                poolMetrics.maxAttestationsPerCommittee.set(maxAttestations);
+                poolMetrics.committeesPerSlot.set(committeeCount);
+            }
+        }
+        for (const [slot, attestationGroupByIndexByDataHex] of this.attestationGroupByIndexByDataHexBySlot) {
+            // We have already updated attestationDataCount and attestationCount when looping over `previousSlot`
+            if (slot === previousSlot) {
+                continue;
+            }
+            for (const attestationGroupByIndex of attestationGroupByIndexByDataHex.values()) {
+                attestationDataCount += attestationGroupByIndex.size;
+                for (const attestationGroup of attestationGroupByIndex.values()) {
+                    attestationCount += attestationGroup.getAttestationCount();
+                }
+            }
+        }
+        poolMetrics.size.set(attestationCount);
+        poolMetrics.uniqueData.set(attestationDataCount);
+    }
 }
 /**
  * Maintain a pool of AggregatedAttestation which all share the same AttestationData.
@@ -331,9 +421,8 @@ export class AggregatedAttestationPool {
  * Use committee instead of aggregationBits to improve performance.
  */
 export class MatchingDataAttestationGroup {
-    constructor(
-    // TODO: no need committee here
-    committee, data) {
+    constructor(config, committee, data) {
+        this.config = config;
         this.committee = committee;
         this.data = data;
         this.attestations = [];
@@ -373,42 +462,86 @@ export class MatchingDataAttestationGroup {
             this.attestations.splice(index, 1);
         }
         this.attestations.push(attestation);
+        const maxRetained = isForkPostElectra(this.config.getForkName(this.data.slot))
+            ? MAX_RETAINED_ATTESTATIONS_PER_GROUP_ELECTRA
+            : MAX_RETAINED_ATTESTATIONS_PER_GROUP;
         // Remove the attestations with less participation
-        if (this.attestations.length > MAX_RETAINED_ATTESTATIONS_PER_GROUP) {
+        if (this.attestations.length > maxRetained) {
+            // ideally we should sort by effective balance but there is no state/effectiveBalance here
+            // it's rare to see > 8 attestations per group in electra anyway
             this.attestations.sort((a, b) => b.trueBitsCount - a.trueBitsCount);
-            this.attestations.splice(MAX_RETAINED_ATTESTATIONS_PER_GROUP, this.attestations.length - MAX_RETAINED_ATTESTATIONS_PER_GROUP);
+            this.attestations.splice(maxRetained, this.attestations.length - maxRetained);
         }
         return InsertOutcome.NewData;
     }
     /**
      * Get AttestationNonParticipant for this groups of same attestation data.
-     * @param notSeenAttestingIndices not seen attestting indices, i.e. indices in the same committee
+     * @param notSeenCommitteeMembers not seen committee members, i.e. indices in the same committee (starting from 0 till (committee.size - 1))
      * @returns an array of AttestationNonParticipant
      */
-    getAttestationsForBlock(fork, notSeenAttestingIndices) {
+    getAttestationsForBlock(fork, effectiveBalanceIncrements, notSeenCommitteeMembers, maxAttestation) {
         const attestations = [];
+        const excluded = new Set();
+        for (let i = 0; i < maxAttestation; i++) {
+            const mostValuableAttestation = this.getMostValuableAttestation(fork, effectiveBalanceIncrements, notSeenCommitteeMembers, excluded);
+            if (mostValuableAttestation === null) {
+                // stop looking for attestation because all attesters are seen or no attestation has missing attesters
+                break;
+            }
+            attestations.push(mostValuableAttestation);
+            excluded.add(mostValuableAttestation.attestation);
+            // this will narrow down the notSeenCommitteeMembers for the next iteration
+            // so usually it will not take much time, however it could take more time during
+            // non-finality of the network when there is low participation, but in this case
+            // we pre-aggregate aggregated attestations and bound the total attestations per group
+            notSeenCommitteeMembers = mostValuableAttestation.notSeenCommitteeMembers;
+        }
+        return { result: attestations, totalAttestations: this.attestations.length };
+    }
+    /**
+     * Select the attestation with the highest total effective balance of not seen validators.
+     */
+    getMostValuableAttestation(fork, effectiveBalanceIncrements, notSeenCommitteeMembers, excluded) {
+        if (notSeenCommitteeMembers.size === 0) {
+            // no more attesters to consider
+            return null;
+        }
         const isPostElectra = isForkPostElectra(fork);
+        let maxNewSeenEffectiveBalance = 0;
+        let mostValuableAttestation = null;
         for (const { attestation } of this.attestations) {
             if ((isPostElectra && !isElectraAttestation(attestation)) ||
                 (!isPostElectra && isElectraAttestation(attestation))) {
                 continue;
             }
-            let notSeenAttesterCount = 0;
+            if (excluded.has(attestation)) {
+                continue;
+            }
+            const notSeen = new Set();
+            // we prioritize total effective balance over attester count
+            let newSeenEffectiveBalance = 0;
+            let newSeenAttesters = 0;
             const { aggregationBits } = attestation;
-            for (const notSeenIndex of notSeenAttestingIndices) {
+            for (const notSeenIndex of notSeenCommitteeMembers) {
                 if (aggregationBits.get(notSeenIndex)) {
-                    notSeenAttesterCount++;
+                    newSeenEffectiveBalance += effectiveBalanceIncrements[this.committee[notSeenIndex]];
+                    newSeenAttesters++;
+                }
+                else {
+                    notSeen.add(notSeenIndex);
                 }
             }
-            if (notSeenAttesterCount > 0) {
-                attestations.push({ attestation, notSeenAttesterCount });
+            if (newSeenEffectiveBalance > maxNewSeenEffectiveBalance) {
+                maxNewSeenEffectiveBalance = newSeenEffectiveBalance;
+                mostValuableAttestation = {
+                    attestation,
+                    newSeenEffectiveBalance,
+                    newSeenAttesters,
+                    notSeenCommitteeMembers: notSeen,
+                };
             }
         }
-        const maxAttestation = isPostElectra ? MAX_ATTESTATIONS_PER_GROUP_ELECTRA : MAX_ATTESTATIONS_PER_GROUP;
-        if (attestations.length <= maxAttestation) {
-            return attestations;
-        }
-        return attestations.sort((a, b) => b.notSeenAttesterCount - a.notSeenAttesterCount).slice(0, maxAttestation);
+        return mostValuableAttestation;
     }
     /** Get attestations for API. */
     getAttestations() {
@@ -454,13 +587,14 @@ export function aggregateConsolidation({ byCommittee, attData }) {
  * has already attested or not.
  */
 export function getNotSeenValidatorsFn(state) {
-    if (state.config.getForkName(state.slot) === ForkName.phase0) {
+    const stateSlot = state.slot;
+    if (state.config.getForkName(stateSlot) === ForkName.phase0) {
         // Get attestations to be included in a phase0 block.
         // As we are close to altair, this is not really important, it's mainly for e2e.
         // The performance is not great due to the different BeaconState data structure to altair.
         // check for phase0 block already
         const phase0State = state;
-        const stateEpoch = computeEpochAtSlot(state.slot);
+        const stateEpoch = computeEpochAtSlot(stateSlot);
         const previousEpochParticipants = extractParticipationPhase0(phase0State.previousEpochAttestations.getAllReadonly(), state);
         const currentEpochParticipants = extractParticipationPhase0(phase0State.currentEpochAttestations.getAllReadonly(), state);
         return (epoch, slot, committeeIndex) => {
@@ -469,13 +603,13 @@ export function getNotSeenValidatorsFn(state) {
                 return null;
             }
             const committee = state.epochCtx.getBeaconCommittee(slot, committeeIndex);
-            const notSeenAttestingIndices = new Set();
+            const notSeenCommitteeMembers = new Set();
             for (const [i, validatorIndex] of committee.entries()) {
                 if (!participants.has(validatorIndex)) {
-                    notSeenAttestingIndices.add(i);
+                    notSeenCommitteeMembers.add(i);
                 }
             }
-            return notSeenAttestingIndices.size === 0 ? null : notSeenAttestingIndices;
+            return notSeenCommitteeMembers.size === 0 ? null : notSeenCommitteeMembers;
         };
     }
     // altair and future forks
@@ -486,7 +620,7 @@ export function getNotSeenValidatorsFn(state) {
     const altairState = state;
     const previousParticipation = altairState.previousEpochParticipation.getAll();
     const currentParticipation = altairState.currentEpochParticipation.getAll();
-    const stateEpoch = computeEpochAtSlot(state.slot);
+    const stateEpoch = computeEpochAtSlot(stateSlot);
     // this function could be called multiple times with same slot + committeeIndex
     const cachedNotSeenValidators = new Map();
     return (epoch, slot, committeeIndex) => {
@@ -495,22 +629,23 @@ export function getNotSeenValidatorsFn(state) {
             return null;
         }
         const cacheKey = slot + "_" + committeeIndex;
-        let notSeenAttestingIndices = cachedNotSeenValidators.get(cacheKey);
-        if (notSeenAttestingIndices != null) {
+        let notSeenCommitteeMembers = cachedNotSeenValidators.get(cacheKey);
+        if (notSeenCommitteeMembers != null) {
             // if all validators are seen then return null, we don't need to check for any attestations of same committee again
-            return notSeenAttestingIndices.size === 0 ? null : notSeenAttestingIndices;
+            return notSeenCommitteeMembers.size === 0 ? null : notSeenCommitteeMembers;
         }
         const committee = state.epochCtx.getBeaconCommittee(slot, committeeIndex);
-        notSeenAttestingIndices = new Set();
+        notSeenCommitteeMembers = new Set();
         for (const [i, validatorIndex] of committee.entries()) {
             // no need to check flagIsTimelySource as if validator is not seen, it's participation status is 0
-            if (participationStatus[validatorIndex] === 0) {
-                notSeenAttestingIndices.add(i);
+            // attestations for the previous slot are not included in the state, so we don't need to check for them
+            if (slot === stateSlot - 1 || participationStatus[validatorIndex] === 0) {
+                notSeenCommitteeMembers.add(i);
             }
         }
-        cachedNotSeenValidators.set(cacheKey, notSeenAttestingIndices);
+        cachedNotSeenValidators.set(cacheKey, notSeenCommitteeMembers);
         // if all validators are seen then return null, we don't need to check for any attestations of same committee again
-        return notSeenAttestingIndices.size === 0 ? null : notSeenAttestingIndices;
+        return notSeenCommitteeMembers.size === 0 ? null : notSeenCommitteeMembers;
     };
 }
 export function extractParticipationPhase0(attestations, state) {
@@ -556,8 +691,9 @@ export function getValidateAttestationDataFn(forkChoice, state) {
         else {
             return false;
         }
-        if (!ssz.phase0.Checkpoint.equals(attData.source, justifiedCheckpoint))
+        if (!ssz.phase0.Checkpoint.equals(attData.source, justifiedCheckpoint)) {
             return false;
+        }
         // Shuffling can't have changed if we're in the first few epochs
         // Also we can't look back 2 epochs if target epoch is 1 or less
         if (stateEpoch < 2 || targetEpoch < 2) {
@@ -623,7 +759,9 @@ function isValidShuffling(forkChoice, state, blockRootHex, targetEpoch) {
     }
     let attestationDependentRoot;
     try {
-        attestationDependentRoot = forkChoice.getDependentRoot(beaconBlock, EpochDifference.previous);
+        // should not use forkChoice.getDependentRoot directly, see https://github.com/ChainSafe/lodestar/issues/7651
+        // attestationDependentRoot = forkChoice.getDependentRoot(beaconBlock, EpochDifference.previous);
+        attestationDependentRoot = getShufflingDependentRoot(forkChoice, targetEpoch, computeEpochAtSlot(beaconBlock.slot), beaconBlock);
     }
     catch (_) {
         // getDependent root may throw error if the dependent root of attestation data is prior to finalized slot