@lodestar/beacon-node 1.51.0-dev.bf4ea87c7b → 1.51.0-dev.c0ed1935bc

package/src/chain/bls/multithread/index.ts

@@ -342,7 +342,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
       } else {
         this.jobs.push(job);
       }
-      callInNextEventLoop(this.runJob);
+      callInNextEventLoop(() => void this.runJob());
     }
   }
 
@@ -377,7 +377,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
     let completedJobsCount = 0;
 
     if (this.jobs.length > 0) {
-      callInNextEventLoop(this.runJob);
+      callInNextEventLoop(() => void this.runJob());
     }
 
     try {
@@ -423,7 +423,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
       if (workReqs.length === 0) {
         worker.status = {code: WorkerStatusCode.idle, workerApi};
         this.workersBusy--;
-        callInNextEventLoop(this.runJob);
+        callInNextEventLoop(() => void this.runJob());
         return;
       }
 
@@ -499,7 +499,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
     this.workersBusy--;
 
     // Potentially run a new job
-    callInNextEventLoop(this.runJob);
+    callInNextEventLoop(() => void this.runJob());
   };
 
   /**
@@ -542,7 +542,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
         this.jobs.unshift(job);
       }
       this.bufferedJobs = null;
-      callInNextEventLoop(this.runJob);
+      callInNextEventLoop(() => void this.runJob());
     }
   };
 

package/src/chain/bls/multithread/types.ts

@@ -1,4 +1,4 @@
-import {type BlsSignatureSet} from "@chainsafe/lodestar-z/bls-verifier";
+import {type BlsSignatureSet} from "@lodestar/native/bls-verifier";
 import {SameMessageSignatureSet, VerifySignatureOpts} from "../interface.js";
 
 export type WorkerData = {

package/src/chain/bls/multithread/worker.ts

@@ -1,10 +1,6 @@
 import worker from "node:worker_threads";
-import {
-  type BlsSignatureSet,
-  verifySignatureSets,
-  verifySignatureSetsSameMessage,
-} from "@chainsafe/lodestar-z/bls-verifier";
 import {expose} from "@chainsafe/threads/worker";
+import {type BlsSignatureSet, verifySignatureSets, verifySignatureSetsSameMessage} from "@lodestar/native/bls-verifier";
 import {
   BlsWorkReq,
   BlsWorkResult,

package/src/chain/bls/singleThread.ts

@@ -1,4 +1,4 @@
-import {verifySignatureSetsSameMessage} from "@chainsafe/lodestar-z/bls-verifier";
+import {verifySignatureSetsSameMessage} from "@lodestar/native/bls-verifier";
 import {ISignatureSet} from "@lodestar/state-transition";
 import {Metrics} from "../../metrics/index.js";
 import {IBlsVerifier, SameMessageSignatureSet} from "./interface.js";

package/src/chain/bls/utils.ts

@@ -2,7 +2,7 @@ import {
   BLS_VERIFIER_MAX_BATCH_SIZE,
   BLS_VERIFIER_MAX_SAME_MESSAGE_BATCH_SIZE,
   verifySignatureSets,
-} from "@chainsafe/lodestar-z/bls-verifier";
+} from "@lodestar/native/bls-verifier";
 import {ISignatureSet, SignatureSetType, toBlsSignatureSet} from "@lodestar/state-transition";
 import {SameMessageSignatureSet} from "./interface.js";
 

package/src/chain/chain.ts

@@ -1,6 +1,5 @@
 import path from "node:path";
 import {PrivateKey} from "@libp2p/interface";
-import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {Type} from "@chainsafe/ssz";
 import {routes} from "@lodestar/api";
 import {BeaconConfig} from "@lodestar/config";
@@ -14,6 +13,7 @@ import {
   UpdateHeadOpt,
 } from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
+import {type PubkeyCache} from "@lodestar/native/pubkeys";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
   type ForkPostFulu,
@@ -100,6 +100,7 @@ import {
   AttestationPool,
   DeferredVoluntaryExitPool,
   ExecutionPayloadBidPool,
+  InclusionListStore,
   OpPool,
   PayloadAttestationPool,
   ProposerPreferencesPool,
@@ -198,6 +199,7 @@ export class BeaconChain implements IBeaconChain {
   readonly executionPayloadBidPool: ExecutionPayloadBidPool;
   readonly payloadAttestationPool: PayloadAttestationPool;
   readonly proposerPreferencesPool = new ProposerPreferencesPool();
+  readonly inclusionListStore: InclusionListStore;
   readonly opPool: OpPool;
   readonly deferredVoluntaryExitPool: DeferredVoluntaryExitPool;
 
@@ -335,6 +337,7 @@ export class BeaconChain implements IBeaconChain {
     this.payloadAttestationPool = new PayloadAttestationPool(config, clock, metrics);
     this.opPool = new OpPool(config);
     this.deferredVoluntaryExitPool = new DeferredVoluntaryExitPool(logger);
+    this.inclusionListStore = new InclusionListStore(config);
 
     this.seenAggregatedAttestations = new SeenAggregatedAttestations(metrics);
     this.seenContributionAndProof = new SeenContributionAndProof(metrics);
@@ -1483,10 +1486,10 @@ export class BeaconChain implements IBeaconChain {
     this.metrics?.forkChoice.requests.inc();
     const timer = this.metrics?.forkChoice.findHead.startTimer({caller: FindHeadFnName.predictProposerHead});
     const slot = this.clock.currentSlot;
-    const secFromSlot = this.clock.secFromSlot(slot);
+    const msFromSlot = this.clock.msFromSlot(slot);
 
     try {
-      return this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetPredictedProposerHead, secFromSlot, slot}).head;
+      return this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetPredictedProposerHead, msFromSlot, slot}).head;
     } catch (e) {
       this.metrics?.forkChoice.errors.inc({entrypoint: UpdateHeadOpt.GetPredictedProposerHead});
       throw e;
@@ -1498,13 +1501,13 @@ export class BeaconChain implements IBeaconChain {
   getProposerHead(slot: Slot): ProtoBlock {
     this.metrics?.forkChoice.requests.inc();
     const timer = this.metrics?.forkChoice.findHead.startTimer({caller: FindHeadFnName.getProposerHead});
-    const secFromSlot = this.clock.secFromSlot(slot);
+    const msFromSlot = this.clock.msFromSlot(slot);
 
     try {
       // Do not emit head event here, when proposing we rely on the one emitted when importing our own block
       const {head, isHeadTimely, notReorgedReason} = this.forkChoice.updateAndGetHead({
         mode: UpdateHeadOpt.GetProposerHead,
-        secFromSlot,
+        msFromSlot,
         slot,
       });
 
@@ -1832,6 +1835,7 @@ export class BeaconChain implements IBeaconChain {
     this.executionPayloadBidPool.prune(slot);
     this.seenExecutionPayloadBids.prune(slot);
     this.proposerPreferencesPool.prune(slot);
+    this.inclusionListStore.prune(slot);
     this.seenAttestationDatas.onSlot(slot);
     this.reprocessController.onSlot(slot);
 

package/src/chain/errors/blockError.ts

@@ -72,7 +72,7 @@ export enum BlockErrorCode {
    * whoever served the block MAY be downscored. Mirrors PayloadErrorCode.EXECUTION_ENGINE_INVALID.
    */
   EXECUTION_ENGINE_INVALID = "BLOCK_ERROR_EXECUTION_INVALID",
-  /** The blobs are unavailable */
+  /** The blob or column data did not arrive within the availability wait */
   DATA_UNAVAILABLE = "BLOCK_ERROR_DATA_UNAVAILABLE",
   /** Block contains too many kzg commitments */
   TOO_MANY_KZG_COMMITMENTS = "BLOCK_ERROR_TOO_MANY_KZG_COMMITMENTS",

package/src/chain/errors/executionPayloadBid.ts

@@ -21,6 +21,8 @@ export enum ExecutionPayloadBidErrorCode {
   NO_MATCHING_PROPOSER_PREFERENCES = "EXECUTION_PAYLOAD_BID_ERROR_NO_MATCHING_PROPOSER_PREFERENCES",
   PROPOSER_PREFERENCES_FEE_RECIPIENT_MISMATCH = "EXECUTION_PAYLOAD_BID_ERROR_PROPOSER_PREFERENCES_FEE_RECIPIENT_MISMATCH",
   PROPOSER_PREFERENCES_GAS_LIMIT_MISMATCH = "EXECUTION_PAYLOAD_BID_ERROR_PROPOSER_PREFERENCES_GAS_LIMIT_MISMATCH",
+  INCLUSION_LIST_BITS_NOT_INCLUSIVE = "EXECUTION_PAYLOAD_BID_ERROR_INCLUSION_LIST_BITS_NOT_INCLUSIVE",
+  BEFORE_INCLUSION_LIST_DEADLINE = "EXECUTION_PAYLOAD_BID_ERROR_BEFORE_INCLUSION_LIST_DEADLINE",
 }
 
 export type ExecutionPayloadBidErrorType =
@@ -86,6 +88,16 @@ export type ExecutionPayloadBidErrorType =
       bidFeeRecipient: string;
       expectedFeeRecipient: string;
     }
+  | {
+      code: ExecutionPayloadBidErrorCode.INCLUSION_LIST_BITS_NOT_INCLUSIVE;
+      builderIndex: BuilderIndex;
+      slot: Slot;
+    }
+  | {
+      code: ExecutionPayloadBidErrorCode.BEFORE_INCLUSION_LIST_DEADLINE;
+      builderIndex: BuilderIndex;
+      slot: Slot;
+    }
   | {
       code: ExecutionPayloadBidErrorCode.PROPOSER_PREFERENCES_GAS_LIMIT_MISMATCH;
       builderIndex: BuilderIndex;

package/src/chain/errors/inclusionList.ts

@@ -0,0 +1,38 @@
+import {Epoch, RootHex, Slot, ValidatorIndex} from "@lodestar/types";
+import {GossipActionError} from "./gossipValidation.js";
+
+export enum InclusionListErrorCode {
+  EMPTY_TRANSACTIONS = "INCLUSION_LIST_ERROR_EMPTY_TRANSACTIONS",
+  MAXIMUM_SIZE_EXCEEDED = "INCLUSION_LIST_ERROR_MAXIMUM_SIZE_EXCEEDED",
+  EMPTY_TRANSACTION = "INCLUSION_LIST_ERROR_EMPTY_TRANSACTION",
+  INVALID_SLOT = "INCLUSION_LIST_ERROR_INVALID_SLOT",
+  MORE_THAN_TWO = "INCLUSION_LIST_ERROR_MORE_THAN_TWO",
+  VALIDATOR_NOT_IN_COMMITTEE = "INCLUSION_LIST_ERROR_VALIDATOR_NOT_IN_COMMITTEE",
+  UNKNOWN_DEPENDENT_ROOT = "INCLUSION_LIST_ERROR_UNKNOWN_DEPENDENT_ROOT",
+  INVALID_DEPENDENT_ROOT_SLOT = "INCLUSION_LIST_ERROR_INVALID_DEPENDENT_ROOT_SLOT",
+  INVALID_DEPENDENT_ROOT = "INCLUSION_LIST_ERROR_INVALID_DEPENDENT_ROOT",
+  MISSING_SHUFFLING = "INCLUSION_LIST_ERROR_MISSING_SHUFFLING",
+  INVALID_SIGNATURE = "INCLUSION_LIST_ERROR_INVALID_SIGNATURE",
+  PRE_HEZE_SLOT = "INCLUSION_LIST_ERROR_PRE_HEZE_SLOT",
+}
+
+export type InclusionListErrorType =
+  | {code: InclusionListErrorCode.EMPTY_TRANSACTIONS}
+  | {code: InclusionListErrorCode.MAXIMUM_SIZE_EXCEEDED; totalBytes: number; maxBytes: number}
+  | {code: InclusionListErrorCode.EMPTY_TRANSACTION; transactionIndex: number}
+  | {code: InclusionListErrorCode.INVALID_SLOT; inclusionListSlot: Slot; currentSlot: Slot}
+  | {code: InclusionListErrorCode.MORE_THAN_TWO; validatorIndex: ValidatorIndex}
+  | {code: InclusionListErrorCode.VALIDATOR_NOT_IN_COMMITTEE; validatorIndex: ValidatorIndex}
+  | {code: InclusionListErrorCode.UNKNOWN_DEPENDENT_ROOT; dependentRoot: RootHex}
+  | {
+      code: InclusionListErrorCode.INVALID_DEPENDENT_ROOT_SLOT;
+      dependentRoot: RootHex;
+      dependentSlot: Slot;
+      maxSlot: Slot;
+    }
+  | {code: InclusionListErrorCode.INVALID_DEPENDENT_ROOT; dependentRoot: RootHex; epoch: Epoch}
+  | {code: InclusionListErrorCode.MISSING_SHUFFLING; dependentRoot: RootHex; epoch: Epoch}
+  | {code: InclusionListErrorCode.INVALID_SIGNATURE}
+  | {code: InclusionListErrorCode.PRE_HEZE_SLOT; inclusionListSlot: Slot};
+
+export class InclusionListError extends GossipActionError<InclusionListErrorType> {}

package/src/chain/errors/index.ts

@@ -8,6 +8,7 @@ export * from "./envelopeReconstructionError.js";
 export * from "./executionPayloadBid.js";
 export * from "./executionPayloadEnvelope.js";
 export * from "./gossipValidation.js";
+export * from "./inclusionList.js";
 export * from "./payloadAttestation.js";
 export * from "./proposerPreferences.js";
 export * from "./proposerSlashingError.js";

package/src/chain/interface.ts

@@ -1,7 +1,7 @@
-import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {Type} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {CheckpointWithHex, IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
+import {type PubkeyCache} from "@lodestar/native/pubkeys";
 import {EpochShuffling, IBeaconStateView} from "@lodestar/state-transition";
 import {
   BeaconBlock,
@@ -49,6 +49,7 @@ import {
   AttestationPool,
   DeferredVoluntaryExitPool,
   ExecutionPayloadBidPool,
+  InclusionListStore,
   OpPool,
   PayloadAttestationPool,
   ProposerPreferencesPool,
@@ -76,8 +77,7 @@ import {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenCache/seenPa
 import {ShufflingCache} from "./shufflingCache.js";
 import {ValidatorMonitor} from "./validatorMonitor.js";
 
-export {BlockType, type AssembledBlockType};
-export {type ProposerPreparationData};
+export {type AssembledBlockType, BlockType, type ProposerPreparationData};
 export type BlockHash = RootHex;
 
 export type StateGetOpts = {
@@ -131,6 +131,7 @@ export interface IBeaconChain {
   readonly executionPayloadBidPool: ExecutionPayloadBidPool;
   readonly payloadAttestationPool: PayloadAttestationPool;
   readonly proposerPreferencesPool: ProposerPreferencesPool;
+  readonly inclusionListStore: InclusionListStore;
   readonly opPool: OpPool;
   readonly deferredVoluntaryExitPool: DeferredVoluntaryExitPool;
 

package/src/chain/opPools/aggregatedAttestationPool.ts

@@ -1,7 +1,7 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {IForkChoice} from "@lodestar/fork-choice";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {
   ForkName,
   ForkSeq,

package/src/chain/opPools/attestationPool.ts

@@ -1,6 +1,6 @@
-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, isForkPostElectra} from "@lodestar/params";
 import {Attestation, RootHex, SingleAttestation, Slot, isElectraSingleAttestation} from "@lodestar/types";
 import {MapDef, assert} from "@lodestar/utils";

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,6 +2,7 @@ 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";

package/src/chain/opPools/payloadAttestationPool.ts

@@ -1,6 +1,6 @@
-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 {RootHex, Slot, gloas} from "@lodestar/types";
 import {MapDef, toRootHex} from "@lodestar/utils";

package/src/chain/opPools/syncCommitteeMessagePool.ts

@@ -1,6 +1,6 @@
-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 {Root, Slot, SubcommitteeIndex, SubnetID, altair} from "@lodestar/types";
 import {MapDef, toRootHex} from "@lodestar/utils";

package/src/chain/opPools/syncContributionAndProofPool.ts

@@ -1,6 +1,6 @@
-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";

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

@@ -48,7 +48,6 @@ export type IChainOptions = BlockProcessOpts &
     /** 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;
@@ -121,7 +120,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