@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/lib/chain/seenCache/seenGossipBlockInput.js

@@ -1,405 +1,271 @@
-import { toHexString } from "@chainsafe/ssz";
-import { ForkName, NUMBER_OF_COLUMNS, isForkPostDeneb } from "@lodestar/params";
-import { ssz } from "@lodestar/types";
-import { pruneSetToMax } from "@lodestar/utils";
-import { RecoverResult, getDataColumnsFromExecution, hasSampledDataColumns, recoverDataColumnSidecars, } from "../../util/dataColumns.js";
-import { callInNextEventLoop } from "../../util/eventLoop.js";
-import { BlobsSource, BlockSource, DataColumnsSource, GossipedInputType, getBlockInput, getBlockInputBlobs, getBlockInputDataColumns, } from "../blocks/types.js";
+import { isForkPostDeneb, isForkPostFulu } from "@lodestar/params";
+import { computeStartSlotAtEpoch } from "@lodestar/state-transition";
+import { LodestarError } from "@lodestar/utils";
+import { BlockInputBlobs, BlockInputColumns, BlockInputPreData, DAType, isBlockInputBlobs, isBlockInputColumns, isDaOutOfRange, } from "../blocks/blockInput/index.js";
 import { ChainEvent } from "../emitter.js";
-import { DataColumnSidecarErrorCode, DataColumnSidecarGossipError } from "../errors/dataColumnSidecarError.js";
-import { GossipAction } from "../errors/gossipValidation.js";
-export var BlockInputAvailabilitySource;
-(function (BlockInputAvailabilitySource) {
-    BlockInputAvailabilitySource["GOSSIP"] = "gossip";
-    BlockInputAvailabilitySource["RECOVERED"] = "recovered";
-    BlockInputAvailabilitySource["UNKNOWN_SYNC"] = "unknown_sync";
-})(BlockInputAvailabilitySource || (BlockInputAvailabilitySource = {}));
-// TODO(fulu): dedup with gossipHandlers.ts
-const BLOCK_AVAILABILITY_CUTOFF_MS = 3_000;
-const MAX_GOSSIPINPUT_CACHE = 5;
+const MAX_BLOCK_INPUT_CACHE_SIZE = 5;
 /**
- * For predeneb, SeenGossipBlockInput only tracks and caches block so that we don't need to download known block
- * roots. From deneb, it serves same purpose plus tracks and caches the live blobs and blocks on the network to
- * solve data availability for the blockInput. If no block has been seen yet for some already seen blobs, it
- * responds will null, but on the first block or the consequent blobs it responds with blobs promise till all blobs
- * become available.
+ * Consumers that create BlockInputs or change types of old BlockInputs
  *
- * One can start processing block on blobs promise blockInput response and can await on the promise before
- * fully importing the block. The blobs promise is gets resolved as soon as all blobs corresponding to that
- * block are seen by SeenGossipBlockInput
+ * - 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 SeenGossipBlockInput {
-    constructor(custodyConfig, executionEngine, emitter, clock, logger) {
-        this.blockInputCache = new Map();
-        this.globalCacheId = 0;
+export class SeenBlockInput {
+    config;
+    custodyConfig;
+    clock;
+    chainEvents;
+    signal;
+    metrics;
+    logger;
+    blockInputs = new Map();
+    constructor({ config, custodyConfig, clock, chainEvents, signal, metrics, logger }) {
+        this.config = config;
         this.custodyConfig = custodyConfig;
-        this.executionEngine = executionEngine;
         this.clock = clock;
-        this.emitter = emitter;
+        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);
+        });
     }
-    prune() {
-        pruneSetToMax(this.blockInputCache, MAX_GOSSIPINPUT_CACHE);
+    has(rootHex) {
+        return this.blockInputs.has(rootHex);
     }
-    hasBlock(blockRoot) {
-        return this.blockInputCache.has(blockRoot);
+    get(rootHex) {
+        return this.blockInputs.get(rootHex);
     }
     /**
-     * Intended to be used for gossip validation, specifically this check:
-     * [IGNORE] The sidecar is the first sidecar for the tuple (block_header.slot, block_header.proposer_index,
-     *          sidecar.index) with valid header signature, sidecar inclusion proof, and kzg proof
+     * Removes the single BlockInput from the cache
      */
-    hasDataColumnSidecar(sidecar) {
-        const blockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(sidecar.signedBlockHeader.message);
-        const blockRootHex = toHexString(blockRoot);
-        const blockCache = this.blockInputCache.get(blockRootHex);
-        if (blockCache === undefined) {
-            return false;
-        }
-        if (blockCache.cachedData === undefined || blockCache.cachedData.fork !== ForkName.fulu) {
-            return false;
-        }
-        const existingSidecar = blockCache.cachedData.dataColumnsCache.get(sidecar.index);
-        if (!existingSidecar) {
-            return false;
-        }
-        return (sidecar.signedBlockHeader.message.slot === existingSidecar.dataColumn.signedBlockHeader.message.slot &&
-            sidecar.index === existingSidecar.dataColumn.index &&
-            sidecar.signedBlockHeader.message.proposerIndex ===
-                existingSidecar.dataColumn.signedBlockHeader.message.proposerIndex);
+    remove(rootHex) {
+        this.blockInputs.delete(rootHex);
     }
-    getGossipBlockInput(config, gossipedInput, metrics) {
-        let blockHex;
-        let blockCache;
-        let fork;
-        if (gossipedInput.type === GossipedInputType.block) {
-            const { signedBlock } = gossipedInput;
-            fork = config.getForkName(signedBlock.message.slot);
-            blockHex = toHexString(config.getForkTypes(signedBlock.message.slot).BeaconBlock.hashTreeRoot(signedBlock.message));
-            blockCache = this.blockInputCache.get(blockHex) ?? getEmptyBlockInputCacheEntry(fork, ++this.globalCacheId);
-            blockCache.block = signedBlock;
+    /**
+     * Removes a processed BlockInput from the cache and also removes any ancestors of processed blocks
+     */
+    prune(rootHex) {
+        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;
         }
-        else if (gossipedInput.type === GossipedInputType.blob) {
-            const { blobSidecar } = gossipedInput;
-            const blockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(blobSidecar.signedBlockHeader.message);
-            fork = config.getForkName(blobSidecar.signedBlockHeader.message.slot);
-            blockHex = toHexString(blockRoot);
-            blockCache = this.blockInputCache.get(blockHex) ?? getEmptyBlockInputCacheEntry(fork, ++this.globalCacheId);
-            if (blockCache.cachedData?.fork !== ForkName.deneb && blockCache.cachedData?.fork !== ForkName.electra) {
-                throw Error(`blob data at non deneb/electra fork=${blockCache.fork}`);
+        this.logger?.debug(`BlockInputCache.prune deleted ${deletedCount} cached BlockInputs`);
+        this.pruneToMaxSize();
+    }
+    onFinalized = (checkpoint) => {
+        let deletedCount = 0;
+        const cutoffSlot = computeStartSlotAtEpoch(checkpoint.epoch);
+        for (const [rootHex, blockInput] of this.blockInputs) {
+            if (blockInput.slot < cutoffSlot) {
+                deletedCount++;
+                this.blockInputs.delete(rootHex);
             }
-            // TODO: freetheblobs check if its the same blob or a duplicate and throw/take actions
-            blockCache.cachedData?.blobsCache.set(blobSidecar.index, blobSidecar);
         }
-        else if (gossipedInput.type === GossipedInputType.dataColumn) {
-            const { dataColumnSidecar, dataColumnBytes } = gossipedInput;
-            const blockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(dataColumnSidecar.signedBlockHeader.message);
-            fork = config.getForkName(dataColumnSidecar.signedBlockHeader.message.slot);
-            blockHex = toHexString(blockRoot);
-            blockCache = this.blockInputCache.get(blockHex) ?? getEmptyBlockInputCacheEntry(fork, ++this.globalCacheId);
-            if (blockCache.cachedData?.fork !== ForkName.fulu) {
-                throw Error(`data column data at non fulu fork=${blockCache.fork}`);
+        this.logger?.debug(`BlockInputCache.onFinalized deleted ${deletedCount} cached BlockInputs`);
+        this.pruneToMaxSize();
+    };
+    getByBlock({ blockRootHex, block, source, seenTimestampSec, peerIdStr }) {
+        // 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);
+        if (!blockInput) {
+            const { forkName, daOutOfRange } = this.buildCommonProps(block.message.slot);
+            if (!isForkPostDeneb(forkName)) {
+                blockInput = BlockInputPreData.createFromBlock({
+                    block,
+                    blockRootHex,
+                    daOutOfRange,
+                    forkName,
+                    source,
+                    seenTimestampSec,
+                    peerIdStr,
+                });
             }
-            if (this.hasDataColumnSidecar(dataColumnSidecar)) {
-                throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
-                    code: DataColumnSidecarErrorCode.ALREADY_KNOWN,
-                    slot: dataColumnSidecar.signedBlockHeader.message.slot,
-                    columnIdx: dataColumnSidecar.index,
+            else if (isForkPostFulu(forkName)) {
+                blockInput = BlockInputColumns.createFromBlock({
+                    block: block,
+                    blockRootHex,
+                    daOutOfRange,
+                    forkName,
+                    custodyColumns: this.custodyConfig.custodyColumns,
+                    sampledColumns: this.custodyConfig.sampledColumns,
+                    source,
+                    seenTimestampSec,
+                    peerIdStr,
                 });
             }
-            blockCache.cachedData?.dataColumnsCache.set(dataColumnSidecar.index, {
-                dataColumn: dataColumnSidecar,
-                // easily splice out the unsigned message as blob is a fixed length type
-                dataColumnBytes: dataColumnBytes?.slice(0, dataColumnBytes.length) ?? null,
-            });
+            else {
+                blockInput = BlockInputBlobs.createFromBlock({
+                    block: block,
+                    blockRootHex,
+                    daOutOfRange,
+                    forkName,
+                    source,
+                    seenTimestampSec,
+                    peerIdStr,
+                });
+            }
+            this.blockInputs.set(blockInput.blockRootHex, blockInput);
+        }
+        if (!blockInput.hasBlock()) {
+            blockInput.addBlock({ block, blockRootHex, source, seenTimestampSec, peerIdStr });
         }
         else {
-            // somehow helps resolve typescript that all types have been exausted
-            throw Error("Invalid gossipedInput type");
+            this.logger?.debug("Attempt to cache block but is already cached on BlockInput", blockInput.getLogMeta());
+            this.metrics?.seenCache.blockInput.duplicateBlockCount.inc({ source });
         }
-        if (!this.blockInputCache.has(blockHex)) {
-            this.blockInputCache.set(blockHex, blockCache);
-            callInNextEventLoop(() => {
-                getDataColumnsFromExecution(config, this.custodyConfig, this.executionEngine, this.emitter, blockCache, metrics)
-                    .then((_success) => {
-                    // TODO: (@matthewkeil) add metrics collection point here
-                })
-                    .catch((error) => {
-                    this.logger.warn("Error getting data columns from execution", { blockHex }, error);
-                });
+        return blockInput;
+    }
+    getByBlob({ blockRootHex, blobSidecar, source, seenTimestampSec, peerIdStr, }, opts = {}) {
+        // 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);
+        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);
         }
-        const { block: signedBlock, blockInputPromise, resolveBlockInput, cachedData } = blockCache;
-        if (signedBlock !== undefined) {
-            if (!isForkPostDeneb(fork)) {
-                return {
-                    blockInput: getBlockInput.preData(config, signedBlock, BlockSource.gossip),
-                    blockInputMeta: { pending: null, haveBlobs: 0, expectedBlobs: 0 },
-                };
-            }
-            if (cachedData === undefined || !isForkPostDeneb(cachedData.fork)) {
-                throw Error("Missing or Invalid fork cached Data for post-deneb block");
-            }
-            if (cachedData.fork === ForkName.deneb || cachedData.fork === ForkName.electra) {
-                const { blobsCache, resolveAvailability } = cachedData;
-                // block is available, check if all blobs have shown up
-                const { slot, body } = signedBlock.message;
-                const { blobKzgCommitments } = body;
-                const blockInfo = `blockHex=${blockHex}, slot=${slot}`;
-                if (blobKzgCommitments.length < blobsCache.size) {
-                    throw Error(`Received more blobs=${blobsCache.size} than commitments=${blobKzgCommitments.length} for ${blockInfo}`);
-                }
-                if (blobKzgCommitments.length === blobsCache.size) {
-                    const allBlobs = getBlockInputBlobs(blobsCache);
-                    const { blobs } = allBlobs;
-                    const blockData = {
-                        fork: cachedData.fork,
-                        ...allBlobs,
-                        blobsSource: BlobsSource.gossip,
-                    };
-                    resolveAvailability(blockData);
-                    metrics?.syncUnknownBlock.resolveAvailabilitySource.inc({ source: BlockInputAvailabilitySource.GOSSIP });
-                    const blockInput = getBlockInput.availableData(config, signedBlock, BlockSource.gossip, blockData);
-                    resolveBlockInput(blockInput);
-                    return {
-                        blockInput,
-                        blockInputMeta: { pending: null, haveBlobs: blobs.length, expectedBlobs: blobKzgCommitments.length },
-                    };
-                }
-                const blockInput = getBlockInput.dataPromise(config, signedBlock, BlockSource.gossip, cachedData);
-                resolveBlockInput(blockInput);
-                return {
-                    blockInput,
-                    blockInputMeta: {
-                        pending: GossipedInputType.blob,
-                        haveBlobs: blobsCache.size,
-                        expectedBlobs: blobKzgCommitments.length,
-                    },
-                };
-            }
-            if (cachedData.fork === ForkName.fulu) {
-                const { dataColumnsCache, resolveAvailability, calledRecover } = cachedData;
-                // block is available, check if all blobs have shown up
-                const { slot } = signedBlock.message;
-                const blockInfo = `blockHex=${blockHex}, slot=${slot}`;
-                if (NUMBER_OF_COLUMNS < dataColumnsCache.size) {
-                    throw Error(`Received more dataColumns=${dataColumnsCache.size} than columns=${NUMBER_OF_COLUMNS} for ${blockInfo}`);
-                }
-                // get the custody columns and see if we have got all the requisite columns
-                const blobKzgCommitmentsLen = signedBlock.message.body.blobKzgCommitments.length;
-                if (blobKzgCommitmentsLen === 0) {
-                    const blockData = {
-                        fork: cachedData.fork,
-                        dataColumns: [],
-                        dataColumnsBytes: [],
-                        dataColumnsSource: DataColumnsSource.gossip,
-                    };
-                    resolveAvailability(blockData);
-                    metrics?.syncUnknownBlock.resolveAvailabilitySource.inc({ source: BlockInputAvailabilitySource.GOSSIP });
-                    const blockInput = getBlockInput.availableData(config, signedBlock, BlockSource.gossip, blockData);
-                    resolveBlockInput(blockInput);
-                    return {
-                        blockInput,
-                        blockInputMeta: { pending: null, haveColumns: 0, expectedColumns: 0 },
-                    };
-                }
-                const resolveAvailabilityAndBlockInput = (source) => {
-                    const allDataColumns = getBlockInputDataColumns(dataColumnsCache, this.custodyConfig.sampledColumns);
-                    const blockData = {
-                        fork: cachedData.fork,
-                        ...allDataColumns,
-                        dataColumnsSource: DataColumnsSource.gossip,
-                    };
-                    resolveAvailability(blockData);
-                    // TODO(das): should not use syncUnknownBlock metrics here
-                    metrics?.syncUnknownBlock.resolveAvailabilitySource.inc({ source });
-                    metrics?.dataColumns.bySource.inc({ source: DataColumnsSource.gossip });
-                    const blockInput = getBlockInput.availableData(config, signedBlock, BlockSource.gossip, blockData);
-                    resolveBlockInput(blockInput);
-                    return blockInput;
-                };
-                const columnCount = dataColumnsCache.size;
-                if (
-                // only try to recover all columns with "--supernode"
-                this.custodyConfig.sampledColumns.length === NUMBER_OF_COLUMNS &&
-                    columnCount >= NUMBER_OF_COLUMNS / 2 &&
-                    columnCount < NUMBER_OF_COLUMNS &&
-                    !calledRecover &&
-                    // doing recover right away is not efficient because it may delay data_column_sidecar validation
-                    this.clock.secFromSlot(slot) * 1000 >= BLOCK_AVAILABILITY_CUTOFF_MS) {
-                    // should call once per slot
-                    cachedData.calledRecover = true;
-                    callInNextEventLoop(async () => {
-                        const logCtx = {
-                            blockHex,
-                            slot,
-                            dataColumns: dataColumnsCache.size,
-                        };
-                        const recoverResult = await recoverDataColumnSidecars(dataColumnsCache, this.clock, metrics).catch((e) => {
-                            this.logger.error("Error recovering data column sidecars", logCtx, e);
-                            return RecoverResult.Failed;
-                        });
-                        metrics?.recoverDataColumnSidecars.reconstructionResult.inc({ result: recoverResult });
-                        switch (recoverResult) {
-                            case RecoverResult.SuccessResolved: {
-                                resolveAvailabilityAndBlockInput(BlockInputAvailabilitySource.RECOVERED);
-                                // Publish columns if and only if subscribed to them
-                                const sampledColumns = this.custodyConfig.sampledColumns.map((columnIndex) => {
-                                    const dataColumn = dataColumnsCache.get(columnIndex)?.dataColumn;
-                                    if (!dataColumn) {
-                                        throw Error(`After recover, missing data column for index=${columnIndex} in cache`);
-                                    }
-                                    return dataColumn;
-                                });
-                                // for columns that we already seen, it will be ignored through `ignoreDuplicatePublishError` gossip option
-                                this.emitter.emit(ChainEvent.publishDataColumns, sampledColumns);
-                                this.logger.verbose("Recovered data column sidecars and resolved availability", logCtx);
-                                break;
-                            }
-                            case RecoverResult.SuccessLate:
-                                this.logger.verbose("Recovered data column sidecars but it's late to resolve availability", logCtx);
-                                break;
-                            case RecoverResult.Failed:
-                                this.logger.verbose("Failed to recover data column sidecars", logCtx);
-                                break;
-                            case RecoverResult.NotAttemptedFull:
-                                this.logger.verbose("Did not attempt because we have full column sidecars", logCtx);
-                                break;
-                            case RecoverResult.NotAttemptedLessThanHalf:
-                                this.logger.verbose("Did not attempt because we have too few column sidecars", logCtx);
-                                break;
-                            default:
-                                break;
-                        }
-                    });
-                }
-                if (hasSampledDataColumns(this.custodyConfig, dataColumnsCache)) {
-                    const blockInput = resolveAvailabilityAndBlockInput(BlockInputAvailabilitySource.GOSSIP);
-                    const allDataColumns = getBlockInputDataColumns(dataColumnsCache, this.custodyConfig.sampledColumns);
-                    const { dataColumns } = allDataColumns;
-                    return {
-                        blockInput,
-                        blockInputMeta: {
-                            pending: null,
-                            haveColumns: dataColumns.length,
-                            expectedColumns: this.custodyConfig.sampledColumns.length,
-                        },
-                    };
-                }
-                const blockInput = getBlockInput.dataPromise(config, signedBlock, BlockSource.gossip, cachedData);
-                resolveBlockInput(blockInput);
-                return {
-                    blockInput,
-                    blockInputMeta: {
-                        pending: GossipedInputType.dataColumn,
-                        haveColumns: dataColumnsCache.size,
-                        expectedColumns: this.custodyConfig.sampledColumns.length,
-                    },
-                };
+        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(),
+                });
             }
-            throw Error(`Invalid fork=${fork}`);
         }
-        // will need to wait for the block to showup
-        if (cachedData === undefined) {
-            throw Error("Missing cachedData for deneb+ blobs");
+        return blockInput;
+    }
+    getByColumn({ blockRootHex, columnSidecar, seenTimestampSec, source, peerIdStr, }, opts = {}) {
+        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 (cachedData.fork === ForkName.deneb || cachedData.fork === ForkName.electra) {
-            const { blobsCache } = cachedData;
-            return {
-                blockInput: {
-                    block: null,
-                    blockRootHex: blockHex,
-                    cachedData,
-                    blockInputPromise,
-                },
-                blockInputMeta: { pending: GossipedInputType.block, haveBlobs: blobsCache.size, expectedBlobs: null },
-            };
+        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 (fork === ForkName.fulu) {
-            const { dataColumnsCache } = cachedData;
-            return {
-                blockInput: {
-                    block: null,
-                    blockRootHex: blockHex,
-                    cachedData,
-                    blockInputPromise,
-                },
-                blockInputMeta: { pending: GossipedInputType.block, haveColumns: dataColumnsCache.size, expectedColumns: null },
-            };
+        if (!blockInput.hasColumn(columnSidecar.index)) {
+            blockInput.addColumn({ columnSidecar, blockRootHex, source, seenTimestampSec, peerIdStr });
         }
-        throw Error(`invalid fork=${fork} data not implemented`);
-        /**
-         * TODO: @matthewkeil this code was unreachable.  Commented to remove lint error but need to verify the condition
-         * again to make sure this is not necessary before deleting it
-         *
-         * DO NOT DELETE until verified can be removed
-         */
-        // will need to wait for the block to showup
-        // if (cachedData === undefined) {
-        //   throw Error("Missing cachedData for deneb+ blobs");
-        // }
-        // const {blobsCache} = cachedData as CachedBlobs;
-        // return {
-        //   blockInput: {
-        //     block: null,
-        //     blockRootHex: blockHex,
-        //     cachedData: cachedData as CachedData,
-        //     blockInputPromise,
-        //   },
-        //   blockInputMeta: {pending: GossipedInputType.block, haveBlobs: blobsCache.size, expectedBlobs: null},
-        // };
-    }
-}
-export function getEmptyBlockInputCacheEntry(fork, globalCacheId) {
-    // Capture both the promise and its callbacks for blockInput and final availability
-    // It is not spec'ed but in tests in Firefox and NodeJS the promise constructor is run immediately
-    let resolveBlockInput = null;
-    const blockInputPromise = new Promise((resolveCB) => {
-        resolveBlockInput = resolveCB;
-    });
-    if (resolveBlockInput === null) {
-        throw Error("Promise Constructor was not executed immediately");
-    }
-    if (!isForkPostDeneb(fork)) {
-        return { fork, blockInputPromise, resolveBlockInput };
-    }
-    if (fork === ForkName.deneb || fork === ForkName.electra) {
-        let resolveAvailability = null;
-        const availabilityPromise = new Promise((resolveCB) => {
-            resolveAvailability = resolveCB;
-        });
-        if (resolveAvailability === null) {
-            throw Error("Promise Constructor was not executed immediately");
+        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(),
+                });
+            }
         }
-        const blobsCache = new Map();
-        const cachedData = {
-            fork,
-            blobsCache,
-            availabilityPromise,
-            resolveAvailability,
-            cacheId: ++globalCacheId,
+        return blockInput;
+    }
+    buildCommonProps(slot) {
+        const forkName = this.config.getForkName(slot);
+        return {
+            forkName,
+            daOutOfRange: isDaOutOfRange(this.config, forkName, slot, this.clock.currentEpoch),
         };
-        return { fork, blockInputPromise, resolveBlockInput, cachedData };
     }
-    if (fork === ForkName.fulu) {
-        let resolveAvailability = null;
-        const availabilityPromise = new Promise((resolveCB) => {
-            resolveAvailability = resolveCB;
-        });
-        if (resolveAvailability === null) {
-            throw Error("Promise Constructor was not executed immediately");
+    /**
+     * Use custom implementation of pruneSetToMax to allow for sorting by slot
+     * and deleting via key/rootHex
+     */
+    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;
+            }
         }
-        const dataColumnsCache = new Map();
-        const cachedData = {
-            fork,
-            dataColumnsCache,
-            availabilityPromise,
-            resolveAvailability,
-            cacheId: ++globalCacheId,
-            calledRecover: false,
-        };
-        return { fork, blockInputPromise, resolveBlockInput, cachedData };
     }
-    throw Error(`Invalid fork=${fork} for getEmptyBlockInputCacheEntry`);
+}
+var SeenBlockInputCacheErrorCode;
+(function (SeenBlockInputCacheErrorCode) {
+    SeenBlockInputCacheErrorCode["WRONG_BLOCK_INPUT_TYPE"] = "BLOCK_INPUT_CACHE_ERROR_WRONG_BLOCK_INPUT_TYPE";
+    SeenBlockInputCacheErrorCode["GOSSIP_BLOB_ALREADY_KNOWN"] = "BLOCK_INPUT_CACHE_ERROR_GOSSIP_BLOB_ALREADY_KNOWN";
+    SeenBlockInputCacheErrorCode["GOSSIP_COLUMN_ALREADY_KNOWN"] = "BLOCK_INPUT_CACHE_ERROR_GOSSIP_COLUMN_ALREADY_KNOWN";
+})(SeenBlockInputCacheErrorCode || (SeenBlockInputCacheErrorCode = {}));
+class SeenBlockInputCacheError extends LodestarError {
 }
 //# sourceMappingURL=seenGossipBlockInput.js.map