@lodestar/beacon-node 1.35.0-dev.91dadf81de → 1.35.0-dev.955e9f89ed

package/src/chain/seenCache/seenAttesters.ts

@@ -1,58 +0,0 @@
-import {Epoch, ValidatorIndex} from "@lodestar/types";
-import {MapDef} from "@lodestar/utils";
-
-// How many *non future* epochs we intend to keep for SeenAttesters.
-// Pre and post deneb specs require us to accept attestations from current and
-// previous epoch.
-//
-// Pre-deneb:
-// - `attestation.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= attestation.data.slot`
-//
-// Post-deneb:
-// - `attestation.data.slot <= current_slot`
-// - `compute_epoch_at_slot(attestation.data.slot) in (get_previous_epoch(state), get_current_epoch(state))`
-//
-// When factored in MAXIMUM_GOSSIP_CLOCK_DISPARITY, it is possible we keep 3 epochs of SeenAttesters:
-// previous, current and future epoch. This constant is solely used to calculate `lowestPermissibleEpoch`
-// which prunes anything older than it.
-//
-// Assuming we're at epoch 100 while all other nodes at epoch 99, they all accept attestations at epoch 98, 99.
-// If MAX_RETAINED_EPOCH = 2 then our lowestPermissibleEpoch is 98 which is fine
-//
-// Assuming we're at epoch 99 while all other nodes at epoch 100, they all accept attestations at epoch 99, 100.
-// If MAX_RETAINED_EPOCH = 2 then lowestPermissibleEpoch is 97 which is more than enough
-const EPOCH_LOOKBACK_LIMIT = 2;
-
-/**
- * Keeps a cache to filter unaggregated attestations from the same validator in the same epoch.
- */
-export class SeenAttesters {
-  protected readonly validatorIndexesByEpoch = new MapDef<Epoch, Set<ValidatorIndex>>(() => new Set<ValidatorIndex>());
-  protected lowestPermissibleEpoch: Epoch = 0;
-
-  isKnown(targetEpoch: Epoch, validatorIndex: ValidatorIndex): boolean {
-    return this.validatorIndexesByEpoch.get(targetEpoch)?.has(validatorIndex) === true;
-  }
-
-  add(targetEpoch: Epoch, validatorIndex: ValidatorIndex): void {
-    if (targetEpoch < this.lowestPermissibleEpoch) {
-      throw Error(`EpochTooLow ${targetEpoch} < ${this.lowestPermissibleEpoch}`);
-    }
-
-    this.validatorIndexesByEpoch.getOrDefault(targetEpoch).add(validatorIndex);
-  }
-
-  prune(currentEpoch: Epoch): void {
-    this.lowestPermissibleEpoch = Math.max(currentEpoch - EPOCH_LOOKBACK_LIMIT, 0);
-    for (const epoch of this.validatorIndexesByEpoch.keys()) {
-      if (epoch < this.lowestPermissibleEpoch) {
-        this.validatorIndexesByEpoch.delete(epoch);
-      }
-    }
-  }
-}
-
-/**
- * Keeps a cache to filter aggregated attestations from the same aggregators in the same epoch
- */
-export class SeenAggregators extends SeenAttesters {}

package/src/chain/seenCache/seenBlockAttesters.ts

@@ -1,18 +0,0 @@
-import {Epoch, ValidatorIndex} from "@lodestar/types";
-import {SeenAttesters} from "./seenAttesters.js";
-// TODO abstract out the Seen* caches into an abstract abstract data structure
-// that all the caches can extend since they share similar structure.
-
-export class SeenBlockAttesters extends SeenAttesters {
-  addIndices(epoch: Epoch, validatorIndexes: ValidatorIndex[]): void {
-    if (epoch < this.lowestPermissibleEpoch) {
-      throw Error(`EpochTooLow ${epoch} < ${this.lowestPermissibleEpoch}`);
-    }
-
-    const indexesByEpoch = this.validatorIndexesByEpoch.getOrDefault(epoch);
-
-    for (const index of validatorIndexes) {
-      indexesByEpoch.add(index);
-    }
-  }
-}

package/src/chain/seenCache/seenBlockProposers.ts

@@ -1,48 +0,0 @@
-import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {Epoch, Slot, ValidatorIndex} from "@lodestar/types";
-import {MapDef} from "@lodestar/utils";
-
-/**
- * Keeps a cache to filter block proposals from the same validator in the same slot.
- *
- * This cache is not bounded and for extremely long periods of non-finality it can grow a lot. However it's practically
- * limited by the possible shufflings in those epochs, and the stored data is very cheap
- */
-export class SeenBlockProposers {
-  private readonly proposerIndexesBySlot = new MapDef<Slot, Set<ValidatorIndex>>(() => new Set<ValidatorIndex>());
-  private finalizedSlot: Epoch = 0;
-
-  isKnown(blockSlot: Slot, proposerIndex: ValidatorIndex): boolean {
-    return this.proposerIndexesBySlot.get(blockSlot)?.has(proposerIndex) === true;
-  }
-
-  add(blockSlot: Slot, proposerIndex: ValidatorIndex): void {
-    if (blockSlot < this.finalizedSlot) {
-      throw Error(`blockSlot ${blockSlot} < finalizedSlot ${this.finalizedSlot}`);
-    }
-
-    this.proposerIndexesBySlot.getOrDefault(blockSlot).add(proposerIndex);
-  }
-
-  prune(finalizedSlot: Slot): void {
-    this.finalizedSlot = finalizedSlot;
-    for (const slot of this.proposerIndexesBySlot.keys()) {
-      if (slot < finalizedSlot) {
-        this.proposerIndexesBySlot.delete(slot);
-      }
-    }
-  }
-
-  seenAtEpoch(epoch: Slot, index: ValidatorIndex): boolean {
-    const fromSlot = computeStartSlotAtEpoch(epoch);
-    const toSlot = computeStartSlotAtEpoch(epoch + 1);
-
-    for (let slot = fromSlot; slot < toSlot; slot++) {
-      if (this.proposerIndexesBySlot.get(slot)?.has(index) === true) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-}

package/src/chain/seenCache/seenCommittee.ts

@@ -1,43 +0,0 @@
-import {RootHex, Slot, SubcommitteeIndex, ValidatorIndex} from "@lodestar/types";
-import {MapDef} from "@lodestar/utils";
-
-/**
- * SyncCommittee signatures are only useful during a single slot according to our peer's clocks
- */
-const MAX_SLOTS_IN_CACHE = 3;
-
-/** ValidataorSubnetKey = `validatorIndex + subcommitteeIndex` */
-type ValidatorSubnetKey = string;
-
-/**
- * Cache seen SyncCommitteeMessage by slot + validator index.
- */
-export class SeenSyncCommitteeMessages {
-  private readonly seenCacheBySlot = new MapDef<Slot, Map<ValidatorSubnetKey, RootHex>>(() => new Map());
-
-  /**
-   * based on slot + validator index
-   */
-  get(slot: Slot, subnet: SubcommitteeIndex, validatorIndex: ValidatorIndex): RootHex | null {
-    const root = this.seenCacheBySlot.getOrDefault(slot).get(seenCacheKey(subnet, validatorIndex));
-    return root ?? null;
-  }
-
-  /** Register item as seen in the cache */
-  add(slot: Slot, subnet: SubcommitteeIndex, validatorIndex: ValidatorIndex, root: RootHex): void {
-    this.seenCacheBySlot.getOrDefault(slot).set(seenCacheKey(subnet, validatorIndex), root);
-  }
-
-  /** Prune per clock slot */
-  prune(clockSlot: Slot): void {
-    for (const slot of this.seenCacheBySlot.keys()) {
-      if (slot < clockSlot - MAX_SLOTS_IN_CACHE) {
-        this.seenCacheBySlot.delete(slot);
-      }
-    }
-  }
-}
-
-function seenCacheKey(subnet: SubcommitteeIndex, validatorIndex: ValidatorIndex): ValidatorSubnetKey {
-  return `${subnet}-${validatorIndex}`;
-}

package/src/chain/seenCache/seenCommitteeContribution.ts

@@ -1,104 +0,0 @@
-import {Slot, ValidatorIndex} from "@lodestar/types";
-import {ContributionAndProof, SyncCommitteeContribution} from "@lodestar/types/altair";
-import {MapDef, toRootHex} from "@lodestar/utils";
-import {Metrics} from "../../metrics/index.js";
-import {isSuperSetOrEqual} from "../../util/bitArray.js";
-import {AggregationInfo, insertDesc} from "./seenAggregateAndProof.js";
-
-/**
- * SyncCommittee aggregates are only useful for the next block they have signed.
- */
-const MAX_SLOTS_IN_CACHE = 8;
-
-/** AggregatorSubnetKey = `aggregatorIndex + subcommitteeIndex` */
-type AggregatorSubnetKey = string;
-
-/** ContributionDataKey = `slot + beacon_block_root + subcommittee_index */
-type ContributionDataKey = string;
-
-/**
- * Cache SyncCommitteeContribution and seen ContributionAndProof.
- * This is used for SignedContributionAndProof validation and block factory.
- * This stays in-memory and should be pruned per slot.
- */
-export class SeenContributionAndProof {
-  private readonly seenAggregatorBySlot = new MapDef<Slot, Set<AggregatorSubnetKey>>(
-    () => new Set<AggregatorSubnetKey>()
-  );
-
-  private readonly seenContributionBySlot = new MapDef<Slot, MapDef<ContributionDataKey, AggregationInfo[]>>(
-    () => new MapDef(() => [])
-  );
-
-  constructor(private readonly metrics: Metrics | null) {}
-
-  /**
-   * _[IGNORE]_ A valid sync committee contribution with equal `slot`, `beacon_block_root` and `subcommittee_index` whose
-   * `aggregation_bits` is non-strict superset has _not_ already been seen.
-   */
-  participantsKnown(contribution: SyncCommitteeContribution): boolean {
-    const {aggregationBits, slot} = contribution;
-    const contributionMap = this.seenContributionBySlot.getOrDefault(slot);
-    const seenAggregationInfoArr = contributionMap.getOrDefault(toContributionDataKey(contribution));
-    this.metrics?.seenCache.committeeContributions.isKnownCalls.inc();
-    // seenAttestingIndicesArr is sorted by trueBitCount desc
-
-    for (let i = 0; i < seenAggregationInfoArr.length; i++) {
-      if (isSuperSetOrEqual(seenAggregationInfoArr[i].aggregationBits, aggregationBits)) {
-        this.metrics?.seenCache.committeeContributions.isKnownHits.inc();
-        this.metrics?.seenCache.committeeContributions.superSetCheckTotal.observe(i + 1);
-        return true;
-      }
-    }
-
-    this.metrics?.seenCache.committeeContributions.superSetCheckTotal.observe(seenAggregationInfoArr.length);
-    return false;
-  }
-
-  /**
-   * Gossip validation requires to check:
-   * The sync committee contribution is the first valid contribution received for the aggregator with index
-   * contribution_and_proof.aggregator_index for the slot contribution.slot and subcommittee index contribution.subcommittee_index.
-   */
-  isAggregatorKnown(slot: Slot, subcommitteeIndex: number, aggregatorIndex: ValidatorIndex): boolean {
-    return this.seenAggregatorBySlot.get(slot)?.has(seenAggregatorKey(subcommitteeIndex, aggregatorIndex)) === true;
-  }
-
-  /** Register item as seen in the cache */
-  add(contributionAndProof: ContributionAndProof, trueBitCount: number): void {
-    const {contribution, aggregatorIndex} = contributionAndProof;
-    const {subcommitteeIndex, slot, aggregationBits} = contribution;
-
-    // add to seenAggregatorBySlot
-    this.seenAggregatorBySlot.getOrDefault(slot).add(seenAggregatorKey(subcommitteeIndex, aggregatorIndex));
-
-    // add to seenContributionBySlot
-    const contributionMap = this.seenContributionBySlot.getOrDefault(slot);
-    const seenAggregationInfoArr = contributionMap.getOrDefault(toContributionDataKey(contribution));
-    insertDesc(seenAggregationInfoArr, {aggregationBits, trueBitCount});
-  }
-
-  /** Prune per head slot */
-  prune(headSlot: Slot): void {
-    for (const slot of this.seenAggregatorBySlot.keys()) {
-      if (slot < headSlot - MAX_SLOTS_IN_CACHE) {
-        this.seenAggregatorBySlot.delete(slot);
-      }
-    }
-
-    for (const slot of this.seenContributionBySlot.keys()) {
-      if (slot < headSlot - MAX_SLOTS_IN_CACHE) {
-        this.seenContributionBySlot.delete(slot);
-      }
-    }
-  }
-}
-
-function seenAggregatorKey(subcommitteeIndex: number, aggregatorIndex: ValidatorIndex): AggregatorSubnetKey {
-  return `${subcommitteeIndex}-${aggregatorIndex}`;
-}
-
-function toContributionDataKey(contribution: SyncCommitteeContribution): ContributionDataKey {
-  const {slot, beaconBlockRoot, subcommitteeIndex} = contribution;
-  return `${slot} - ${toRootHex(beaconBlockRoot)} - ${subcommitteeIndex}`;
-}

package/src/chain/seenCache/seenGossipBlockInput.ts

@@ -1,373 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {CheckpointWithHex} from "@lodestar/fork-choice";
-import {ForkName, ForkPostFulu, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
-import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {RootHex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
-import {LodestarError, Logger} from "@lodestar/utils";
-import {Metrics} from "../../metrics/metrics.js";
-import {IClock} from "../../util/clock.js";
-import {CustodyConfig} from "../../util/dataColumns.js";
-import {
-  BlockInput,
-  BlockInputBlobs,
-  BlockInputColumns,
-  BlockInputPreData,
-  BlockWithSource,
-  DAType,
-  ForkBlobsDA,
-  IBlockInput,
-  LogMetaBasic,
-  LogMetaBlobs,
-  LogMetaColumns,
-  SourceMeta,
-  isBlockInputBlobs,
-  isBlockInputColumns,
-  isDaOutOfRange,
-} from "../blocks/blockInput/index.js";
-import {ChainEvent, ChainEventEmitter} from "../emitter.js";
-
-const MAX_BLOCK_INPUT_CACHE_SIZE = 5;
-
-export type SeenBlockInputCacheModules = {
-  config: ChainForkConfig;
-  clock: IClock;
-  chainEvents: ChainEventEmitter;
-  signal: AbortSignal;
-  custodyConfig: CustodyConfig;
-  metrics: Metrics | null;
-  logger?: Logger;
-};
-
-export type GetByBlobOptions = {
-  throwErrorIfAlreadyKnown?: boolean;
-};
-
-/**
- * Consumers that create BlockInputs or change types of old BlockInputs
- *
- * - gossipHandlers (block and blob)
- * - beaconBlocksMaybeBlobsByRange
- * - unavailableBeaconBlobsByRoot (beaconBlocksMaybeBlobsByRoot)
- * - publishBlock in the beacon/blocks/index.ts API
- *   https://github.com/ChainSafe/lodestar/blob/unstable/packages/beacon-node/src/api/impl/beacon/blocks/index.ts#L62
- * - maybeValidateBlobs in verifyBlocksDataAvailability (is_data_available spec function)
- *   https://github.com/ChainSafe/lodestar/blob/unstable/packages/beacon-node/src/chain/blocks/verifyBlocksDataAvailability.ts#L111
- *
- *
- * Pruning management for SeenBlockInputCache
- * ------------------------------------------
- * There are four cases for how pruning needs to be handled
- * - Normal operation following head via gossip (and/or reqresp). For this situation the consumer (process pipeline or
- *   caller of processBlock) will call the `prune` method to remove any processed BlockInputs from the cache. This will
- *   also remove any ancestors of the processed BlockInput as that will also need to have been successfully processed
- *   for import to work correctly
- * - onFinalized event handler will help to prune any non-canonical forks once the chain finalizes. Any block-slots that
- *   are before the finalized checkpoint will be pruned.
- * - Range-sync periods.  The range process uses this cache to store and sync blocks with DA data as the chain is pulled
- *   from peers.  We pull batches, by epoch, so 32 slots are pulled at a time and several batches are pulled concurrently.
- *   It is important to set the MAX_BLOCK_INPUT_CACHE_SIZE high enough to support range sync activities.  Currently the
- *   value is set for 5 batches of 32 slots.  As process block is called (similar to following head) the BlockInput and
- *   its ancestors will be pruned.
- * - Non-Finality times.  This is a bit more tricky.  There can be long periods of non-finality and storing everything
- *   will cause OOM.  The pruneToMax will help ensure a hard limit on the number of stored blocks (with DA) that are held
- *   in memory at any one time.  The value for MAX_BLOCK_INPUT_CACHE_SIZE is set to accommodate range-sync but in
- *   practice this value may need to be massaged in the future if we find issues when debugging non-finality
- */
-
-export class SeenBlockInput {
-  private readonly config: ChainForkConfig;
-  private readonly custodyConfig: CustodyConfig;
-  private readonly clock: IClock;
-  private readonly chainEvents: ChainEventEmitter;
-  private readonly signal: AbortSignal;
-  private readonly metrics: Metrics | null;
-  private readonly logger?: Logger;
-  private blockInputs = new Map<RootHex, IBlockInput>();
-
-  constructor({config, custodyConfig, clock, chainEvents, signal, metrics, logger}: SeenBlockInputCacheModules) {
-    this.config = config;
-    this.custodyConfig = custodyConfig;
-    this.clock = clock;
-    this.chainEvents = chainEvents;
-    this.signal = signal;
-    this.metrics = metrics;
-    this.logger = logger;
-
-    if (metrics) {
-      metrics.seenCache.blockInput.blockInputCount.addCollect(() =>
-        metrics.seenCache.blockInput.blockInputCount.set(this.blockInputs.size)
-      );
-    }
-
-    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.onFinalized);
-    this.signal.addEventListener("abort", () => {
-      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.onFinalized);
-    });
-  }
-
-  has(rootHex: RootHex): boolean {
-    return this.blockInputs.has(rootHex);
-  }
-
-  get(rootHex: RootHex): IBlockInput | undefined {
-    return this.blockInputs.get(rootHex);
-  }
-
-  /**
-   * Removes the single BlockInput from the cache
-   */
-  remove(rootHex: RootHex): void {
-    this.blockInputs.delete(rootHex);
-  }
-
-  /**
-   * Removes a processed BlockInput from the cache and also removes any ancestors of processed blocks
-   */
-  prune(rootHex: RootHex): void {
-    let blockInput = this.blockInputs.get(rootHex);
-    let parentRootHex = blockInput?.parentRootHex;
-    let deletedCount = 0;
-    while (blockInput) {
-      deletedCount++;
-      this.blockInputs.delete(blockInput.blockRootHex);
-      blockInput = this.blockInputs.get(parentRootHex ?? "");
-      parentRootHex = blockInput?.parentRootHex;
-    }
-    this.logger?.debug(`BlockInputCache.prune deleted ${deletedCount} cached BlockInputs`);
-    this.pruneToMaxSize();
-  }
-
-  onFinalized = (checkpoint: CheckpointWithHex) => {
-    let deletedCount = 0;
-    const cutoffSlot = computeStartSlotAtEpoch(checkpoint.epoch);
-    for (const [rootHex, blockInput] of this.blockInputs) {
-      if (blockInput.slot < cutoffSlot) {
-        deletedCount++;
-        this.blockInputs.delete(rootHex);
-      }
-    }
-    this.logger?.debug(`BlockInputCache.onFinalized deleted ${deletedCount} cached BlockInputs`);
-    this.pruneToMaxSize();
-  };
-
-  getByBlock({blockRootHex, block, source, seenTimestampSec, peerIdStr}: BlockWithSource): BlockInput {
-    // TODO(peerDAS): Why is it necessary to static cast this here. All conditional paths result in a valid value so should be defined correctly below
-    let blockInput = this.blockInputs.get(blockRootHex) as IBlockInput;
-    if (!blockInput) {
-      const {forkName, daOutOfRange} = this.buildCommonProps(block.message.slot);
-      if (!isForkPostDeneb(forkName)) {
-        blockInput = BlockInputPreData.createFromBlock({
-          block,
-          blockRootHex,
-          daOutOfRange,
-          forkName,
-          source,
-          seenTimestampSec,
-          peerIdStr,
-        });
-      } else if (isForkPostFulu(forkName)) {
-        blockInput = BlockInputColumns.createFromBlock({
-          block: block as SignedBeaconBlock<ForkPostFulu>,
-          blockRootHex,
-          daOutOfRange,
-          forkName,
-          custodyColumns: this.custodyConfig.custodyColumns,
-          sampledColumns: this.custodyConfig.sampledColumns,
-          source,
-          seenTimestampSec,
-          peerIdStr,
-        });
-      } else {
-        blockInput = BlockInputBlobs.createFromBlock({
-          block: block as SignedBeaconBlock<ForkBlobsDA>,
-          blockRootHex,
-          daOutOfRange,
-          forkName,
-          source,
-          seenTimestampSec,
-          peerIdStr,
-        });
-      }
-      this.blockInputs.set(blockInput.blockRootHex, blockInput);
-    }
-
-    if (!blockInput.hasBlock()) {
-      blockInput.addBlock({block, blockRootHex, source, seenTimestampSec, peerIdStr});
-    } else {
-      this.logger?.debug("Attempt to cache block but is already cached on BlockInput", blockInput.getLogMeta());
-      this.metrics?.seenCache.blockInput.duplicateBlockCount.inc({source});
-    }
-
-    return blockInput as BlockInput;
-  }
-
-  getByBlob(
-    {
-      blockRootHex,
-      blobSidecar,
-      source,
-      seenTimestampSec,
-      peerIdStr,
-    }: SourceMeta & {blockRootHex: RootHex; blobSidecar: deneb.BlobSidecar},
-    opts: GetByBlobOptions = {}
-  ): BlockInputBlobs {
-    // TODO(peerDAS): Why is it necessary to static cast this here. All conditional paths result in a valid value so should be defined correctly below
-    let blockInput = this.blockInputs.get(blockRootHex) as IBlockInput;
-    let created = false;
-    if (!blockInput) {
-      created = true;
-      const {forkName, daOutOfRange} = this.buildCommonProps(blobSidecar.signedBlockHeader.message.slot);
-      blockInput = BlockInputBlobs.createFromBlob({
-        blobSidecar,
-        blockRootHex,
-        daOutOfRange,
-        forkName,
-        source,
-        seenTimestampSec,
-        peerIdStr,
-      });
-      this.metrics?.seenCache.blockInput.createdByBlob.inc();
-      this.blockInputs.set(blockRootHex, blockInput);
-    }
-
-    if (!isBlockInputBlobs(blockInput)) {
-      throw new SeenBlockInputCacheError(
-        {
-          code: SeenBlockInputCacheErrorCode.WRONG_BLOCK_INPUT_TYPE,
-          cachedType: blockInput.type,
-          requestedType: DAType.Blobs,
-          ...blockInput.getLogMeta(),
-        },
-        `BlockInputType mismatch adding blobIndex=${blobSidecar.index}`
-      );
-    }
-
-    if (!blockInput.hasBlob(blobSidecar.index)) {
-      blockInput.addBlob({blobSidecar, blockRootHex, source, seenTimestampSec, peerIdStr});
-    } else if (!created) {
-      this.logger?.debug(
-        `Attempt to cache blob index #${blobSidecar.index} but is already cached on BlockInput`,
-        blockInput.getLogMeta()
-      );
-      this.metrics?.seenCache.blockInput.duplicateBlobCount.inc({source});
-      if (opts.throwErrorIfAlreadyKnown) {
-        throw new SeenBlockInputCacheError({
-          code: SeenBlockInputCacheErrorCode.GOSSIP_BLOB_ALREADY_KNOWN,
-          ...blockInput.getLogMeta(),
-        });
-      }
-    }
-
-    return blockInput;
-  }
-
-  getByColumn(
-    {
-      blockRootHex,
-      columnSidecar,
-      seenTimestampSec,
-      source,
-      peerIdStr,
-    }: SourceMeta & {blockRootHex: RootHex; columnSidecar: fulu.DataColumnSidecar},
-    opts: GetByBlobOptions = {}
-  ): BlockInputColumns {
-    let blockInput = this.blockInputs.get(blockRootHex);
-    let created = false;
-    if (!blockInput) {
-      created = true;
-      const {forkName, daOutOfRange} = this.buildCommonProps(columnSidecar.signedBlockHeader.message.slot);
-      blockInput = BlockInputColumns.createFromColumn({
-        columnSidecar,
-        blockRootHex,
-        daOutOfRange,
-        forkName,
-        source,
-        seenTimestampSec,
-        peerIdStr,
-        custodyColumns: this.custodyConfig.custodyColumns,
-        sampledColumns: this.custodyConfig.sampledColumns,
-      });
-      this.metrics?.seenCache.blockInput.createdByBlob.inc();
-      this.blockInputs.set(blockRootHex, blockInput);
-    }
-
-    if (!isBlockInputColumns(blockInput)) {
-      throw new SeenBlockInputCacheError(
-        {
-          code: SeenBlockInputCacheErrorCode.WRONG_BLOCK_INPUT_TYPE,
-          cachedType: blockInput.type,
-          requestedType: DAType.Columns,
-          ...blockInput.getLogMeta(),
-        },
-        `BlockInputType mismatch adding columnIndex=${columnSidecar.index}`
-      );
-    }
-
-    if (!blockInput.hasColumn(columnSidecar.index)) {
-      blockInput.addColumn({columnSidecar, blockRootHex, source, seenTimestampSec, peerIdStr});
-    } else if (!created) {
-      this.logger?.debug(
-        `Attempt to cache column index #${columnSidecar.index} but is already cached on BlockInput`,
-        blockInput.getLogMeta()
-      );
-      this.metrics?.seenCache.blockInput.duplicateColumnCount.inc({source});
-      if (opts.throwErrorIfAlreadyKnown) {
-        throw new SeenBlockInputCacheError({
-          code: SeenBlockInputCacheErrorCode.GOSSIP_COLUMN_ALREADY_KNOWN,
-          ...blockInput.getLogMeta(),
-        });
-      }
-    }
-
-    return blockInput;
-  }
-
-  private buildCommonProps(slot: Slot): {
-    daOutOfRange: boolean;
-    forkName: ForkName;
-  } {
-    const forkName = this.config.getForkName(slot);
-    return {
-      forkName,
-      daOutOfRange: isDaOutOfRange(this.config, forkName, slot, this.clock.currentEpoch),
-    };
-  }
-
-  /**
-   * Use custom implementation of pruneSetToMax to allow for sorting by slot
-   * and deleting via key/rootHex
-   */
-  private pruneToMaxSize() {
-    let itemsToDelete = this.blockInputs.size - MAX_BLOCK_INPUT_CACHE_SIZE;
-
-    if (itemsToDelete > 0) {
-      const sorted = [...this.blockInputs.entries()].sort((a, b) => b[1].slot - a[1].slot);
-      for (const [rootHex] of sorted) {
-        this.blockInputs.delete(rootHex);
-        itemsToDelete--;
-        if (itemsToDelete <= 0) return;
-      }
-    }
-  }
-}
-
-enum SeenBlockInputCacheErrorCode {
-  WRONG_BLOCK_INPUT_TYPE = "BLOCK_INPUT_CACHE_ERROR_WRONG_BLOCK_INPUT_TYPE",
-  GOSSIP_BLOB_ALREADY_KNOWN = "BLOCK_INPUT_CACHE_ERROR_GOSSIP_BLOB_ALREADY_KNOWN",
-  GOSSIP_COLUMN_ALREADY_KNOWN = "BLOCK_INPUT_CACHE_ERROR_GOSSIP_COLUMN_ALREADY_KNOWN",
-}
-
-type SeenBlockInputCacheErrorType =
-  | (LogMetaBasic & {
-      code: SeenBlockInputCacheErrorCode.WRONG_BLOCK_INPUT_TYPE;
-      cachedType: DAType;
-      requestedType: DAType;
-    })
-  | (LogMetaBlobs & {
-      code: SeenBlockInputCacheErrorCode.GOSSIP_BLOB_ALREADY_KNOWN;
-    })
-  | (LogMetaColumns & {
-      code: SeenBlockInputCacheErrorCode.GOSSIP_COLUMN_ALREADY_KNOWN;
-    });
-
-class SeenBlockInputCacheError extends LodestarError<SeenBlockInputCacheErrorType> {}

package/src/chain/serializeState.ts

@@ -1,32 +0,0 @@
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {AllocSource, BufferPool} from "../util/bufferPool.js";
-
-type ProcessStateBytesFn<T> = (stateBytes: Uint8Array) => Promise<T>;
-
-/*
- * Serialize state using the BufferPool if provided.
- */
-export async function serializeState<T>(
-  state: CachedBeaconStateAllForks,
-  source: AllocSource,
-  processFn: ProcessStateBytesFn<T>,
-  bufferPool?: BufferPool | null
-): Promise<T> {
-  const size = state.type.tree_serializedSize(state.node);
-  let stateBytes: Uint8Array | null = null;
-  if (bufferPool) {
-    using bufferWithKey = bufferPool.alloc(size, source);
-    if (bufferWithKey) {
-      stateBytes = bufferWithKey.buffer;
-      const dataView = new DataView(stateBytes.buffer, stateBytes.byteOffset, stateBytes.byteLength);
-      state.serializeToBytes({uint8Array: stateBytes, dataView}, 0);
-      return processFn(stateBytes);
-    }
-    // release the buffer back to the pool automatically
-  }
-
-  // we already have metrics in BufferPool so no need to do it here
-  stateBytes = state.serialize();
-
-  return processFn(stateBytes);
-}