@lodestar/beacon-node 1.35.0-dev.e18102ed8c → 1.35.0-dev.f45a2be721

package/src/chain/seenCache/seenAttesters.ts

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,381 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {ForkName, ForkPostFulu, ForkPreGloas, isForkPostDeneb, isForkPostFulu, isForkPostGloas} 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);
+
+      // TODO GLOAS: Implement
+      if (isForkPostGloas(forkName)) {
+        throw Error("Not implemented");
+      }
+      // Pre-deneb
+      if (!isForkPostDeneb(forkName)) {
+        blockInput = BlockInputPreData.createFromBlock({
+          block,
+          blockRootHex,
+          daOutOfRange,
+          forkName,
+          source,
+          seenTimestampSec,
+          peerIdStr,
+        });
+        // Fulu Only
+      } else if (isForkPostFulu(forkName)) {
+        blockInput = BlockInputColumns.createFromBlock({
+          block: block as SignedBeaconBlock<ForkPostFulu & ForkPreGloas>,
+          blockRootHex,
+          daOutOfRange,
+          forkName,
+          custodyColumns: this.custodyConfig.custodyColumns,
+          sampledColumns: this.custodyConfig.sampledColumns,
+          source,
+          seenTimestampSec,
+          peerIdStr,
+        });
+        // Deneb and Electra
+      } 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

@@ -0,0 +1,32 @@
+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);
+}