@lodestar/beacon-node 1.35.0-dev.47c570ab76 → 1.35.0-dev.56313c7299

package/lib/chain/seenCache/seenGossipBlockInput.js

@@ -1,271 +1,405 @@
-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 { 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 { ChainEvent } from "../emitter.js";
-const MAX_BLOCK_INPUT_CACHE_SIZE = 5;
+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;
 /**
- * Consumers that create BlockInputs or change types of old BlockInputs
+ * 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.
  *
- * - 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
+ * 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
  */
-export class SeenBlockInput {
-    config;
-    custodyConfig;
-    clock;
-    chainEvents;
-    signal;
-    metrics;
-    logger;
-    blockInputs = new Map();
-    constructor({ config, custodyConfig, clock, chainEvents, signal, metrics, logger }) {
-        this.config = config;
+export class SeenGossipBlockInput {
+    constructor(custodyConfig, executionEngine, emitter, clock, logger) {
+        this.blockInputCache = new Map();
+        this.globalCacheId = 0;
         this.custodyConfig = custodyConfig;
+        this.executionEngine = executionEngine;
         this.clock = clock;
-        this.chainEvents = chainEvents;
-        this.signal = signal;
-        this.metrics = metrics;
+        this.emitter = emitter;
         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) {
-        return this.blockInputs.has(rootHex);
     }
-    get(rootHex) {
-        return this.blockInputs.get(rootHex);
+    prune() {
+        pruneSetToMax(this.blockInputCache, MAX_GOSSIPINPUT_CACHE);
     }
-    /**
-     * Removes the single BlockInput from the cache
-     */
-    remove(rootHex) {
-        this.blockInputs.delete(rootHex);
+    hasBlock(blockRoot) {
+        return this.blockInputCache.has(blockRoot);
     }
     /**
-     * Removes a processed BlockInput from the cache and also removes any ancestors of processed blocks
+     * 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
      */
-    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;
+    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;
         }
-        this.logger?.debug(`BlockInputCache.prune deleted ${deletedCount} cached BlockInputs`);
-        this.pruneToMaxSize();
+        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);
     }
-    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);
-            }
+    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;
         }
-        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,
-                });
+        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}`);
             }
-            else if (isForkPostFulu(forkName)) {
-                blockInput = BlockInputColumns.createFromBlock({
-                    block: block,
-                    blockRootHex,
-                    daOutOfRange,
-                    forkName,
-                    custodyColumns: this.custodyConfig.custodyColumns,
-                    sampledColumns: this.custodyConfig.sampledColumns,
-                    source,
-                    seenTimestampSec,
-                    peerIdStr,
-                });
+            // 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}`);
             }
-            else {
-                blockInput = BlockInputBlobs.createFromBlock({
-                    block: 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,
                 });
             }
-            this.blockInputs.set(blockInput.blockRootHex, blockInput);
-        }
-        if (!blockInput.hasBlock()) {
-            blockInput.addBlock({ block, blockRootHex, 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 {
-            this.logger?.debug("Attempt to cache block but is already cached on BlockInput", blockInput.getLogMeta());
-            this.metrics?.seenCache.blockInput.duplicateBlockCount.inc({ source });
+            // somehow helps resolve typescript that all types have been exausted
+            throw Error("Invalid gossipedInput type");
         }
-        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,
+        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);
+                });
             });
-            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(),
-                });
+        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,
+                    },
+                };
+            }
+            throw Error(`Invalid fork=${fork}`);
         }
-        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 (!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}`);
+        // will need to wait for the block to showup
+        if (cachedData === undefined) {
+            throw Error("Missing cachedData for deneb+ blobs");
         }
-        if (!blockInput.hasColumn(columnSidecar.index)) {
-            blockInput.addColumn({ columnSidecar, blockRootHex, source, seenTimestampSec, peerIdStr });
+        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 },
+            };
         }
-        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(),
-                });
-            }
+        if (fork === ForkName.fulu) {
+            const { dataColumnsCache } = cachedData;
+            return {
+                blockInput: {
+                    block: null,
+                    blockRootHex: blockHex,
+                    cachedData,
+                    blockInputPromise,
+                },
+                blockInputMeta: { pending: GossipedInputType.block, haveColumns: dataColumnsCache.size, expectedColumns: null },
+            };
         }
-        return blockInput;
+        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");
     }
-    buildCommonProps(slot) {
-        const forkName = this.config.getForkName(slot);
-        return {
-            forkName,
-            daOutOfRange: isDaOutOfRange(this.config, forkName, slot, this.clock.currentEpoch),
+    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");
+        }
+        const blobsCache = new Map();
+        const cachedData = {
+            fork,
+            blobsCache,
+            availabilityPromise,
+            resolveAvailability,
+            cacheId: ++globalCacheId,
         };
+        return { fork, blockInputPromise, resolveBlockInput, cachedData };
     }
-    /**
-     * 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;
-            }
+    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");
         }
+        const dataColumnsCache = new Map();
+        const cachedData = {
+            fork,
+            dataColumnsCache,
+            availabilityPromise,
+            resolveAvailability,
+            cacheId: ++globalCacheId,
+            calledRecover: false,
+        };
+        return { fork, blockInputPromise, resolveBlockInput, cachedData };
     }
-}
-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 {
+    throw Error(`Invalid fork=${fork} for getEmptyBlockInputCacheEntry`);
 }
 //# sourceMappingURL=seenGossipBlockInput.js.map