@lodestar/beacon-node 1.51.0-dev.17f78227c7 → 1.51.0-dev.1b22218e60

package/src/chain/opPools/inclusionListStore.ts

@@ -0,0 +1,208 @@
+import {BitArray, SerializedList} from "@chainsafe/ssz";
+import {BeaconConfig} from "@lodestar/config";
+import {INCLUSION_LIST_COMMITTEE_SIZE} from "@lodestar/params";
+import {RootHex, Slot, ValidatorIndex, bellatrix, heze, ssz} from "@lodestar/types";
+import {MapDef, toHex, toRootHex} from "@lodestar/utils";
+
+export enum InclusionListInsertOutcome {
+  /** Stored as a new entry. */
+  New = "New",
+  /** Slot is older than the prune horizon. */
+  Old = "Old",
+  /** Identical inclusion list already stored. */
+  Seen = "Seen",
+  /** New equivocation evidence: this validator already has a different inclusion list stored. */
+  Equivocating = "Equivocating",
+  /** Validator was already marked as an equivocator for this `(slot, dependent_root)`. */
+  SubsequentEquivocation = "SubsequentEquivocation",
+}
+
+type InclusionListEntry = {
+  signedInclusionList: heze.SignedInclusionList;
+  /** Positions of the validator in `get_inclusion_list_committee(state, slot)`, several when the committee cycles */
+  committeeIndices: number[];
+  /** Received before the inclusion list deadline of its slot. */
+  timely: boolean;
+};
+
+/**
+ * Spec `InclusionListStore`: inclusion lists keyed by `(slot, dependent_root)`, one per validator index.
+ * The committee position is recorded at insert time (gossip validation resolves it) so the bit-oriented
+ * reads need no shuffling lookup. Signed lists are kept so InclusionListsByIndices can serve them.
+ * A validator's first list stays stored and an equivocation marks the validator so reads skip it.
+ */
+export class InclusionListStore {
+  /** slot -> dependent_root -> validator index -> entry */
+  private readonly inclusionLists = new MapDef<Slot, MapDef<RootHex, Map<ValidatorIndex, InclusionListEntry>>>(
+    () => new MapDef<RootHex, Map<ValidatorIndex, InclusionListEntry>>(() => new Map())
+  );
+  /** slot -> dependent_root -> equivocating validator indices */
+  private readonly equivocators = new MapDef<Slot, MapDef<RootHex, Set<ValidatorIndex>>>(
+    () => new MapDef<RootHex, Set<ValidatorIndex>>(() => new Set())
+  );
+  /** slot -> dependent_root -> validator index -> count, for the p2p "first or second message" rule */
+  private readonly seenCounts = new MapDef<Slot, MapDef<RootHex, Map<ValidatorIndex, number>>>(
+    () => new MapDef<RootHex, Map<ValidatorIndex, number>>(() => new Map())
+  );
+
+  private lowestPermissibleSlot = 0;
+
+  constructor(private readonly config: BeaconConfig) {}
+
+  get size(): number {
+    let count = 0;
+    for (const byDependentRoot of this.inclusionLists.values()) {
+      for (const entries of byDependentRoot.values()) {
+        count += entries.size;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Late lists are stored with `timely=false` rather than dropped: they still count toward the
+   * non-timely view used to validate another node's `inclusion_list_bits`.
+   */
+  process(
+    signedInclusionList: heze.SignedInclusionList,
+    committeeIndices: number[],
+    timely: boolean
+  ): InclusionListInsertOutcome {
+    const inclusionList = signedInclusionList.message;
+    const {slot, validatorIndex} = inclusionList;
+
+    if (slot < this.lowestPermissibleSlot) {
+      return InclusionListInsertOutcome.Old;
+    }
+
+    const dependentRoot = toRootHex(inclusionList.dependentRoot);
+    const stored = this.inclusionLists.getOrDefault(slot).getOrDefault(dependentRoot);
+
+    const entry = stored.get(validatorIndex);
+    if (entry !== undefined) {
+      if (ssz.heze.InclusionList.equals(entry.signedInclusionList.message, inclusionList)) {
+        return InclusionListInsertOutcome.Seen;
+      }
+      const equivocators = this.equivocators.getOrDefault(slot).getOrDefault(dependentRoot);
+      if (equivocators.has(validatorIndex)) {
+        return InclusionListInsertOutcome.SubsequentEquivocation;
+      }
+      equivocators.add(validatorIndex);
+      return InclusionListInsertOutcome.Equivocating;
+    }
+
+    stored.set(validatorIndex, {signedInclusionList, committeeIndices, timely});
+    return InclusionListInsertOutcome.New;
+  }
+
+  /** Count a valid message of `validatorIndex` for the first-or-second message gossip rule */
+  markSeen(slot: Slot, dependentRoot: RootHex, validatorIndex: ValidatorIndex): void {
+    const counts = this.seenCounts.getOrDefault(slot).getOrDefault(dependentRoot);
+    counts.set(validatorIndex, (counts.get(validatorIndex) ?? 0) + 1);
+  }
+
+  /** Gossip rule: at most two valid messages per validator for a `(slot, dependent_root)` */
+  seenTwice(slot: Slot, dependentRoot: RootHex, validatorIndex: ValidatorIndex): boolean {
+    return (this.seenCounts.get(slot)?.get(dependentRoot)?.get(validatorIndex) ?? 0) >= 2;
+  }
+
+  /** Deduplicated transactions from valid, non-equivocating inclusion lists at `(slot, dependentRoot)`. */
+  getInclusionListTransactions(slot: Slot, dependentRoot: RootHex, onlyTimely = true): bellatrix.Transactions {
+    const transactions: Uint8Array[] = [];
+    const seen = new Set<string>();
+
+    for (const {signedInclusionList} of this.getEligible(slot, dependentRoot, onlyTimely)) {
+      for (const transaction of signedInclusionList.message.transactions) {
+        const key = toHex(transaction);
+        if (!seen.has(key)) {
+          seen.add(key);
+          transactions.push(transaction);
+        }
+      }
+    }
+
+    return SerializedList.fromArray(transactions);
+  }
+
+  /** Bit `i` is set when committee member `i` submitted a valid, non-equivocating inclusion list */
+  getInclusionListBits(slot: Slot, dependentRoot: RootHex, onlyTimely = true): BitArray {
+    const bits = BitArray.fromBitLen(INCLUSION_LIST_COMMITTEE_SIZE);
+    for (const {committeeIndices} of this.getEligible(slot, dependentRoot, onlyTimely)) {
+      for (const committeeIndex of committeeIndices) {
+        bits.set(committeeIndex, true);
+      }
+    }
+    return bits;
+  }
+
+  /**
+   * True if `bits` has a bit set for every bit set in the local inclusion list bits.
+   *
+   * Intentionally deviates from the spec by only checking against timely lists, where the proposer would check
+   * against every list it observed (only_timely=False in
+   * https://github.com/ethereum/consensus-specs/blob/v1.7.0-beta.4/specs/heze/validator.md#signed-execution-payload-bid).
+   * A bid that passed gossip must stay eligible, otherwise a list released after the deadline voids every bid and
+   * a high early bid with empty bits crowds out the rest without ever paying.
+   */
+  isInclusionListBitsInclusive(slot: Slot, dependentRoot: RootHex, bits: BitArray): boolean {
+    for (const {committeeIndices} of this.getEligible(slot, dependentRoot, true)) {
+      if (committeeIndices.some((committeeIndex) => !bits.get(committeeIndex))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /** Inclusion lists for the given committee positions, to serve InclusionListsByIndices. */
+  getByIndices(slot: Slot, dependentRoot: RootHex, indices: BitArray): heze.SignedInclusionList[] {
+    const out: heze.SignedInclusionList[] = [];
+    for (const {signedInclusionList, committeeIndices} of this.getEligible(slot, dependentRoot, false)) {
+      if (committeeIndices.some((committeeIndex) => indices.get(committeeIndex))) {
+        out.push(signedInclusionList);
+      }
+    }
+    return out;
+  }
+
+  /** Lists are retained for MIN_SLOTS_FOR_INCLUSION_LISTS_REQUESTS slots so InclusionListsByIndices can serve them */
+  prune(clockSlot: Slot): void {
+    const horizon = clockSlot - this.config.MIN_SLOTS_FOR_INCLUSION_LISTS_REQUESTS;
+
+    for (const slot of this.inclusionLists.keys()) {
+      if (slot < horizon) {
+        this.inclusionLists.delete(slot);
+      }
+    }
+    for (const slot of this.equivocators.keys()) {
+      if (slot < horizon) {
+        this.equivocators.delete(slot);
+      }
+    }
+    for (const slot of this.seenCounts.keys()) {
+      if (slot < horizon) {
+        this.seenCounts.delete(slot);
+      }
+    }
+
+    this.lowestPermissibleSlot = Math.max(horizon, 0);
+  }
+
+  /** Entries at `(slot, dependentRoot)` from non-equivocating validators, timely when required. */
+  private *getEligible(slot: Slot, dependentRoot: RootHex, onlyTimely: boolean): Generator<InclusionListEntry> {
+    const stored = this.inclusionLists.get(slot)?.get(dependentRoot);
+    if (!stored || stored.size === 0) {
+      return;
+    }
+    const equivocators = this.equivocators.get(slot)?.get(dependentRoot);
+
+    for (const [validatorIndex, entry] of stored) {
+      if (equivocators?.has(validatorIndex)) {
+        continue;
+      }
+      if (onlyTimely && !entry.timely) {
+        continue;
+      }
+      yield entry;
+    }
+  }
+}

package/src/chain/opPools/index.ts

@@ -2,8 +2,10 @@ export {AggregatedAttestationPool} from "./aggregatedAttestationPool.js";
 export {AttestationPool} from "./attestationPool.js";
 export {DeferredVoluntaryExitPool} from "./deferredVoluntaryExitPool.js";
 export {ExecutionPayloadBidPool, type PooledExecutionPayloadBid} from "./executionPayloadBidPool.js";
+export {InclusionListInsertOutcome, InclusionListStore} from "./inclusionListStore.js";
 export {OpPool} from "./opPool.js";
 export {PayloadAttestationPool} from "./payloadAttestationPool.js";
 export {ProposerPreferencesPool} from "./proposerPreferencesPool.js";
+export {SingleAttestationPool} from "./singleAttestationPool.js";
 export {SyncCommitteeMessagePool} from "./syncCommitteeMessagePool.js";
 export {SyncContributionAndProofPool} from "./syncContributionAndProofPool.js";

package/src/chain/opPools/payloadAttestationPool.ts

@@ -1,9 +1,10 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {MAX_COMMITTEES_PER_SLOT, MAX_PAYLOAD_ATTESTATIONS, PTC_SIZE} from "@lodestar/params";
+import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {RootHex, Slot, gloas} from "@lodestar/types";
-import {MapDef, toRootHex} from "@lodestar/utils";
+import {MapDef, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
@@ -112,11 +113,19 @@ export class PayloadAttestationPool {
       return [];
     }
 
-    return Array.from(aggregateByDataRoot.values())
-      .slice()
+    const payloadAttestations: gloas.PayloadAttestation[] = [];
+    for (const aggregate of aggregateByDataRoot.values()) {
+      const payloadAttestation = fastToPayloadAttestation(aggregate);
+      // The point at infinity is not a valid aggregate signature, exclude it from the block
+      if (byteArrayEquals(payloadAttestation.signature, G2_POINT_AT_INFINITY)) {
+        continue;
+      }
+      payloadAttestations.push(payloadAttestation);
+    }
+
+    return payloadAttestations
       .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
-      .slice(0, MAX_PAYLOAD_ATTESTATIONS)
-      .map(fastToPayloadAttestation);
+      .slice(0, MAX_PAYLOAD_ATTESTATIONS);
   }
 
   getAll(slot?: Slot): gloas.PayloadAttestation[] {
@@ -139,9 +148,11 @@ export class PayloadAttestationPool {
       }
     }
 
+    // The point at infinity is not a valid aggregate signature, do not serve such an aggregate
     return aggregates
       .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
-      .map(fastToPayloadAttestation);
+      .map(fastToPayloadAttestation)
+      .filter((attestation) => !byteArrayEquals(attestation.signature, G2_POINT_AT_INFINITY));
   }
 
   prune(clockSlot: Slot): void {

package/src/chain/opPools/singleAttestationPool.ts

@@ -0,0 +1,287 @@
+import {ATTESTATION_SUBNET_COUNT, ForkPostElectra} from "@lodestar/params";
+import {EffectiveBalanceIncrements} from "@lodestar/state-transition";
+import {BLSSignature, CommitteeIndex, RootHex, SingleAttestation, Slot, ValidatorIndex, phase0} from "@lodestar/types";
+import {Metrics} from "../../metrics/metrics.js";
+import {ProposerTracker} from "../proposerTracker.js";
+import {InsertOutcome} from "./types.js";
+
+type DataRootHex = string;
+
+/** Position of a validator in its committee, i.e. its bit in `aggregationBits` */
+type ValidatorCommitteeIndex = number;
+
+/** `data` and `committeeIndex` are shared per data root and committee, only keep what packing reads */
+type StoredSingle = {attesterIndex: ValidatorIndex; signature: BLSSignature};
+
+type CommitteeSingles = {
+  /** Bit length of this committee's `aggregationBits` */
+  committeeSize: number;
+  singles: Map<ValidatorCommitteeIndex, StoredSingle>;
+};
+
+type DataRootSingles = {
+  /** Same for every single attestation under this data root */
+  data: phase0.AttestationData;
+  byCommittee: Map<CommitteeIndex, CommitteeSingles>;
+};
+
+/** Single attestations of not yet included committee members, signatures are not aggregated yet */
+export type SinglesForCommittee = {
+  committeeSize: number;
+  singles: {validatorCommitteeIndex: ValidatorCommitteeIndex; single: StoredSingle}[];
+  newSeenEffectiveBalance: number;
+  newSeenAttesters: number;
+};
+
+/** Attesters of an attestation included in a block, `attestingIndices` is not sorted */
+export type IncludedAttesters = {slot: Slot; attDataRootHex: DataRootHex; attestingIndices: ValidatorIndex[]};
+
+/**
+ * Backstop only, single attestations included in a canonical block are deleted (see `onHead`) so the real retention is
+ * far lower. Sized for all subnets during the default 8 slots before a proposal (`slotsToSubscribeBeforeProposalDuty`)
+ * with no block at all and up to 1024 attesters per committee, i.e. ~2M active validators. Earlier slots of the
+ * collected window only add the few subnets the node subscribes to anyway. Beyond it, newer singles are dropped
+ */
+const MAX_SINGLE_ATTESTATIONS_RETAINED = 8 * ATTESTATION_SUBNET_COUNT * 1024;
+
+/**
+ * Single attestations to be packed into a block produced by this node, for votes that no aggregate covers.
+ * Callers only add to it for vote slots of an upcoming local proposal, see `ProposerTracker.shouldCollect()`.
+ * They are kept even if an aggregate covers them since proposers may not include that aggregate, until a canonical
+ * block includes them.
+ */
+export class SingleAttestationPool {
+  private readonly singlesByCommitteeByDataRootBySlot = new Map<Slot, Map<DataRootHex, DataRootSingles>>();
+  private size = 0;
+  /** Attesters included by the head block, deleted once a child of it becomes head */
+  private pendingPrune: {blockRoot: RootHex; included: IncludedAttesters[]} | null = null;
+
+  constructor(metrics: Metrics | null = null) {
+    metrics?.opPool.singleAttestationPool.size.addCollect(() =>
+      metrics.opPool.singleAttestationPool.size.set(this.size)
+    );
+  }
+
+  /**
+   * @param validatorCommitteeIndex position of the attester in its committee, computed by gossip validation
+   */
+  add(
+    attestation: SingleAttestation<ForkPostElectra>,
+    attDataRootHex: DataRootHex,
+    validatorCommitteeIndex: ValidatorCommitteeIndex,
+    committeeSize: number
+  ): InsertOutcome {
+    if (this.size >= MAX_SINGLE_ATTESTATIONS_RETAINED) {
+      return InsertOutcome.ReachLimit;
+    }
+
+    const {data, committeeIndex, attesterIndex, signature} = attestation;
+    let singlesByCommitteeByDataRoot = this.singlesByCommitteeByDataRootBySlot.get(data.slot);
+    if (singlesByCommitteeByDataRoot === undefined) {
+      singlesByCommitteeByDataRoot = new Map();
+      this.singlesByCommitteeByDataRootBySlot.set(data.slot, singlesByCommitteeByDataRoot);
+    }
+
+    let dataRootSingles = singlesByCommitteeByDataRoot.get(attDataRootHex);
+    if (dataRootSingles === undefined) {
+      dataRootSingles = {data, byCommittee: new Map()};
+      singlesByCommitteeByDataRoot.set(attDataRootHex, dataRootSingles);
+    }
+
+    let committee = dataRootSingles.byCommittee.get(committeeIndex);
+    if (committee === undefined) {
+      committee = {committeeSize, singles: new Map()};
+      dataRootSingles.byCommittee.set(committeeIndex, committee);
+    }
+
+    if (committee.singles.has(validatorCommitteeIndex)) {
+      return InsertOutcome.AlreadyKnown;
+    }
+
+    committee.singles.set(validatorCommitteeIndex, {attesterIndex, signature});
+    this.size++;
+    return InsertOutcome.NewData;
+  }
+
+  /**
+   * Delete single attestations included by the parent of the new head. Not the ones of the head itself: a proposer
+   * boost reorg of a weak head must keep them, once a child of it is the head that reorg can no longer happen.
+   * @param included attesters of the attestations included in the new head block
+   * @returns number of deleted single attestations
+   */
+  onHead(blockRoot: RootHex, parentRoot: RootHex, included: IncludedAttesters[]): number {
+    if (this.singlesByCommitteeByDataRootBySlot.size === 0) {
+      this.pendingPrune = null;
+      return 0;
+    }
+
+    // a reorg or a parent imported while the pool was empty drops the pending block without deleting
+    const deleted = this.pendingPrune?.blockRoot === parentRoot ? this.deleteIncluded(this.pendingPrune.included) : 0;
+    this.pendingPrune = {blockRoot, included};
+    return deleted;
+  }
+
+  /** Drop vote slots that no upcoming local proposal can include */
+  prune(proposerTracker: ProposerTracker): void {
+    for (const [slot, singlesByCommitteeByDataRoot] of this.singlesByCommitteeByDataRootBySlot) {
+      if (proposerTracker.shouldCollect(slot)) {
+        continue;
+      }
+
+      for (const dataRootSingles of singlesByCommitteeByDataRoot.values()) {
+        for (const committee of dataRootSingles.byCommittee.values()) {
+          this.size -= committee.singles.size;
+        }
+      }
+      this.singlesByCommitteeByDataRootBySlot.delete(slot);
+    }
+
+    if (this.singlesByCommitteeByDataRootBySlot.size === 0) {
+      this.pendingPrune = null;
+    }
+  }
+
+  isEmpty(): boolean {
+    return this.singlesByCommitteeByDataRootBySlot.size === 0;
+  }
+
+  getStoredSlots(): Slot[] {
+    return Array.from(this.singlesByCommitteeByDataRootBySlot.keys());
+  }
+
+  getDataRoots(slot: Slot): Map<DataRootHex, phase0.AttestationData> {
+    const dataRoots = new Map<DataRootHex, phase0.AttestationData>();
+    for (const [attDataRootHex, dataRootSingles] of this.singlesByCommitteeByDataRootBySlot.get(slot) ?? []) {
+      dataRoots.set(attDataRootHex, dataRootSingles.data);
+    }
+    return dataRoots;
+  }
+
+  getCommitteeIndices(slot: Slot, attDataRootHex: DataRootHex): CommitteeIndex[] {
+    return Array.from(this.singlesByCommitteeByDataRootBySlot.get(slot)?.get(attDataRootHex)?.byCommittee.keys() ?? []);
+  }
+
+  /**
+   * Single attestations of a committee whose attesters are in `notSeenCommitteeMembers`, i.e. not on chain and not
+   * covered by the aggregates picked for the block. `notSeenCommitteeMembers` is only read.
+   * Returns at most `maxCount` single attestations with the highest effective balances, without removing them from the
+   * pool.
+   */
+  getUncovered(
+    slot: Slot,
+    attDataRootHex: DataRootHex,
+    committeeIndex: CommitteeIndex,
+    notSeenCommitteeMembers: ReadonlySet<ValidatorCommitteeIndex>,
+    effectiveBalanceIncrements: EffectiveBalanceIncrements,
+    maxCount: number
+  ): SinglesForCommittee | null {
+    const committee = this.singlesByCommitteeByDataRootBySlot
+      .get(slot)
+      ?.get(attDataRootHex)
+      ?.byCommittee.get(committeeIndex);
+    if (committee === undefined) {
+      return null;
+    }
+
+    const singles: SinglesForCommittee["singles"] = [];
+    // walk the smaller side, notSeenCommitteeMembers is usually tiny but close to the committee size if no aggregate
+    if (notSeenCommitteeMembers.size <= committee.singles.size) {
+      for (const validatorCommitteeIndex of notSeenCommitteeMembers) {
+        const single = committee.singles.get(validatorCommitteeIndex);
+        if (single !== undefined) {
+          singles.push({validatorCommitteeIndex, single});
+        }
+      }
+    } else {
+      for (const [validatorCommitteeIndex, single] of committee.singles) {
+        if (notSeenCommitteeMembers.has(validatorCommitteeIndex)) {
+          singles.push({validatorCommitteeIndex, single});
+        }
+      }
+    }
+    if (singles.length > maxCount) {
+      singles.sort(
+        (a, b) =>
+          effectiveBalanceIncrements[b.single.attesterIndex] - effectiveBalanceIncrements[a.single.attesterIndex]
+      );
+      singles.length = maxCount;
+    }
+    if (singles.length === 0) {
+      return null;
+    }
+
+    let newSeenEffectiveBalance = 0;
+    for (const {single} of singles) {
+      newSeenEffectiveBalance += effectiveBalanceIncrements[single.attesterIndex];
+    }
+    return {committeeSize: committee.committeeSize, singles, newSeenEffectiveBalance, newSeenAttesters: singles.length};
+  }
+
+  /**
+   * Delete single attestations whose votes are already on chain, they add nothing to a block built on top of it.
+   * @param includedAttestations one entry per attestation in the body of a canonical block (the parent of the new
+   * head): the attestation slot and data root, and the validators it covers. A single attestation is included if its
+   * attester is in `attestingIndices` of an entry with the same slot and data root.
+   * @returns number of deleted single attestations
+   */
+  private deleteIncluded(includedAttestations: IncludedAttesters[]): number {
+    // a block may include several attestations of the same data, merge their attesters per data root
+    const includedAttestersByDataRootBySlot = new Map<Slot, Map<DataRootHex, Set<ValidatorIndex>>>();
+    for (const {slot, attDataRootHex, attestingIndices} of includedAttestations) {
+      if (this.singlesByCommitteeByDataRootBySlot.get(slot)?.has(attDataRootHex) !== true) {
+        continue;
+      }
+      let includedAttestersByDataRoot = includedAttestersByDataRootBySlot.get(slot);
+      if (includedAttestersByDataRoot === undefined) {
+        includedAttestersByDataRoot = new Map();
+        includedAttestersByDataRootBySlot.set(slot, includedAttestersByDataRoot);
+      }
+      let includedAttesters = includedAttestersByDataRoot.get(attDataRootHex);
+      if (includedAttesters === undefined) {
+        includedAttesters = new Set();
+        includedAttestersByDataRoot.set(attDataRootHex, includedAttesters);
+      }
+      for (const attesterIndex of attestingIndices) {
+        includedAttesters.add(attesterIndex);
+      }
+    }
+
+    let deleted = 0;
+    for (const [slot, includedAttestersByDataRoot] of includedAttestersByDataRootBySlot) {
+      const singlesByCommitteeByDataRoot = this.singlesByCommitteeByDataRootBySlot.get(slot);
+      if (singlesByCommitteeByDataRoot === undefined) {
+        continue;
+      }
+
+      for (const [attDataRootHex, includedAttesters] of includedAttestersByDataRoot) {
+        const dataRootSingles = singlesByCommitteeByDataRoot.get(attDataRootHex);
+        if (dataRootSingles === undefined) {
+          continue;
+        }
+
+        for (const [committeeIndex, committee] of dataRootSingles.byCommittee) {
+          for (const [validatorCommitteeIndex, {attesterIndex}] of committee.singles) {
+            if (includedAttesters.has(attesterIndex)) {
+              committee.singles.delete(validatorCommitteeIndex);
+              deleted++;
+            }
+          }
+          if (committee.singles.size === 0) {
+            dataRootSingles.byCommittee.delete(committeeIndex);
+          }
+        }
+
+        if (dataRootSingles.byCommittee.size === 0) {
+          singlesByCommitteeByDataRoot.delete(attDataRootHex);
+        }
+      }
+
+      if (singlesByCommitteeByDataRoot.size === 0) {
+        this.singlesByCommitteeByDataRootBySlot.delete(slot);
+      }
+    }
+
+    this.size -= deleted;
+    return deleted;
+  }
+}

package/src/chain/opPools/syncCommitteeMessagePool.ts

@@ -1,9 +1,10 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
+import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {Root, Slot, SubcommitteeIndex, SubnetID, altair} from "@lodestar/types";
-import {MapDef, toRootHex} from "@lodestar/utils";
+import {MapDef, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
 import {pruneBySlot, signatureFromBytesNoCheck} from "./utils.js";
@@ -110,10 +111,16 @@ export class SyncCommitteeMessagePool {
       return null;
     }
 
+    const signature = contribution.signature.toBytes();
+    // The point at infinity is not a valid contribution signature, do not serve such a contribution
+    if (byteArrayEquals(signature, G2_POINT_AT_INFINITY)) {
+      return null;
+    }
+
     return {
       ...contribution,
       aggregationBits: contribution.aggregationBits,
-      signature: contribution.signature.toBytes(),
+      signature,
     };
   }
 

package/src/chain/opPools/syncContributionAndProofPool.ts

@@ -1,10 +1,10 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
 import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {Root, Slot, SubnetID, altair, ssz} from "@lodestar/types";
-import {Logger, MapDef, toRootHex} from "@lodestar/utils";
+import {Logger, MapDef, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
@@ -234,8 +234,18 @@ export function aggregate(
   }
 
   metrics?.opPool.syncContributionAndProofPool.getAggregateParticipants.set(participationCount);
+
+  const syncCommitteeSignature = aggregateSignatures(signatures).toBytes();
+  // The point at infinity is only a valid sync aggregate signature with empty participation bits
+  if (byteArrayEquals(syncCommitteeSignature, G2_POINT_AT_INFINITY)) {
+    return {
+      syncCommitteeBits: BitArray.fromBitLen(SYNC_COMMITTEE_SIZE),
+      syncCommitteeSignature,
+    };
+  }
+
   return {
     syncCommitteeBits,
-    syncCommitteeSignature: aggregateSignatures(signatures).toBytes(),
+    syncCommitteeSignature,
   };
 }

package/src/chain/opPools/utils.ts

@@ -1,6 +1,6 @@
-import {Signature} from "@chainsafe/lodestar-z/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {DbBatch, Id, Repository} from "@lodestar/db";
+import {Signature} from "@lodestar/native/blst";
 import {BLS_WITHDRAWAL_PREFIX, DOMAIN_BEACON_ATTESTER, DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {IBeaconStateView, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {AttesterSlashing, Domain, Slot, capella, phase0} from "@lodestar/types";

package/src/chain/options.ts

@@ -43,12 +43,9 @@ export type IChainOptions = BlockProcessOpts &
     disableProposerSlashings?: boolean;
     /** Ensure blobs returned by the execution engine are valid */
     sanityCheckExecutionEngineBlobs?: boolean;
-    /** Max number of produced blobs by local validators to cache */
-    maxCachedBlobSidecars?: number;
     /** Max number of produced block roots (blinded or full) cached for broadcast validations */
     maxCachedProducedRoots?: number;
     initialCustodyGroupCount?: number;
-    broadcastValidationStrictness?: string;
     minSameMessageSignatureSetsToBatch: number;
     archiveDateEpochs?: number;
     nHistoricalStatesFileDataStore?: boolean;
@@ -91,6 +88,11 @@ export type PoolOpts = {
    * Only preaggregate attestation/sync committee message since clockSlot - preaggregateSlotDistance
    */
   preaggregateSlotDistance?: number;
+  /**
+   * Dev only: collect single attestations of every vote slot a block at the clock slot can include regardless of
+   * proposal duties, so that any produced block can pack them. Combine with `subscribeAllSubnets`
+   */
+  singleAttestationIgnoreProposalDuty?: boolean;
 };
 
 export type SeenCacheOpts = {
@@ -121,7 +123,6 @@ export const defaultChainOptions: IChainOptions = {
   // for attestation validation, having this value ensures we don't have to regen states most of the time
   maxSkipSlots: 32,
   disableProposerSlashings: false,
-  broadcastValidationStrictness: "warn",
   // should be less than or equal to MIN_SIGNATURE_SETS_TO_BATCH_VERIFY
   // batching too much may block the I/O thread so if useWorker=false, suggest this value to be 32
   // since this batch attestation work is designed to work with useWorker=true, make this the lowest value