@lodestar/beacon-node 1.41.0-dev.a35cbde8b3 → 1.41.0-dev.aeab9f930d

package/src/chain/archiveStore/utils/archiveBlocks.ts

@@ -1,10 +1,10 @@
 import path from "node:path";
 import {ChainForkConfig} from "@lodestar/config";
 import {KeyValue} from "@lodestar/db";
-import {IForkChoice} from "@lodestar/fork-choice";
+import {CheckpointWithPayloadStatus, IForkChoice} from "@lodestar/fork-choice";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {Epoch, RootHex, Slot} from "@lodestar/types";
+import {Epoch, Slot} from "@lodestar/types";
 import {Logger, fromAsync, fromHex, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {IBeaconDb} from "../../../db/index.js";
 import {BlockArchiveBatchPutBinaryItem} from "../../../db/repositories/index.js";
@@ -19,7 +19,6 @@ const BLOCK_BATCH_SIZE = 256;
 const BLOB_SIDECAR_BATCH_SIZE = 32;
 
 type BlockRootSlot = {slot: Slot; root: Uint8Array};
-type CheckpointHex = {epoch: Epoch; rootHex: RootHex};
 
 /**
  * Persist orphaned block to disk
@@ -53,7 +52,7 @@ export async function archiveBlocks(
   forkChoice: IForkChoice,
   lightclientServer: LightClientServer | undefined,
   logger: Logger,
-  finalizedCheckpoint: CheckpointHex,
+  finalizedCheckpoint: CheckpointWithPayloadStatus,
   currentEpoch: Epoch,
   archiveDataEpochs?: number,
   persistOrphanedBlocks?: boolean,
@@ -62,7 +61,7 @@ export async function archiveBlocks(
   // Use fork choice to determine the blocks to archive and delete
   // getAllAncestorBlocks response includes the finalized block, so it's also moved to the cold db
   const {ancestors: finalizedCanonicalBlocks, nonAncestors: finalizedNonCanonicalBlocks} =
-    forkChoice.getAllAncestorAndNonAncestorBlocks(finalizedCheckpoint.rootHex);
+    forkChoice.getAllAncestorAndNonAncestorBlocks(finalizedCheckpoint.rootHex, finalizedCheckpoint.payloadStatus);
 
   // NOTE: The finalized block will be exactly the first block of `epoch` or previous
   const finalizedPostDeneb = finalizedCheckpoint.epoch >= config.DENEB_FORK_EPOCH;

package/src/chain/archiveStore/utils/archivePayloads.ts

@@ -0,0 +1,15 @@
+import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {IBeaconChain} from "../../interface.js";
+
+/**
+ * Archives execution payload envelopes from hot DB to archive DB after finalization.
+ */
+export async function archiveExecutionPayloadEnvelopes(
+  chain: IBeaconChain,
+  _finalized: CheckpointWithHex
+): Promise<void> {
+  const finalizedBlock = chain.forkChoice.getFinalizedBlock();
+  if (!finalizedBlock) return;
+
+  // TODO GLOAS: Implement payload envelope archival after epbs fork choice changes are merged
+}

package/src/chain/archiveStore/utils/updateBackfillRange.ts

@@ -20,7 +20,7 @@ export async function updateBackfillRange(
   try {
     // Mark the sequence in backfill db from finalized block's slot till anchor slot as
     // filled.
-    const finalizedBlockFC = chain.forkChoice.getBlockHex(finalized.rootHex);
+    const finalizedBlockFC = chain.forkChoice.getBlockHexDefaultStatus(finalized.rootHex);
     if (finalizedBlockFC && finalizedBlockFC.slot > chain.anchorStateLatestBlockSlot) {
       await db.backfilledRanges.put(finalizedBlockFC.slot, chain.anchorStateLatestBlockSlot);
 

package/src/chain/blocks/blockInput/blockInput.ts

@@ -1,5 +1,5 @@
-import {ForkName, ForkPostFulu, ForkPreDeneb, ForkPreGloas, NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {BeaconBlockBody, BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {ForkName, ForkPostFulu, ForkPostGloas, ForkPreDeneb, ForkPreGloas, NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {BeaconBlockBody, BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu, gloas} from "@lodestar/types";
 import {byteArrayEquals, fromHex, prettyBytes, toRootHex, withTimeout} from "@lodestar/utils";
 import {VersionedHashes} from "../../../execution/index.js";
 import {kzgCommitmentToVersionedHash} from "../../../util/blobs.js";
@@ -24,7 +24,7 @@ import {
   SourceMeta,
 } from "./types.js";
 
-export type BlockInput = BlockInputPreData | BlockInputBlobs | BlockInputColumns;
+export type BlockInput = BlockInputPreData | BlockInputBlobs | BlockInputColumns | BlockInputNoData;
 
 export function isBlockInputPreDeneb(blockInput: IBlockInput): blockInput is BlockInputPreData {
   return blockInput.type === DAType.PreData;
@@ -37,6 +37,10 @@ export function isBlockInputColumns(blockInput: IBlockInput): blockInput is Bloc
   return blockInput.type === DAType.Columns;
 }
 
+export function isBlockInputNoData(blockInput: IBlockInput): blockInput is BlockInputNoData {
+  return blockInput.type === DAType.NoData;
+}
+
 function createPromise<T>(): PromiseParts<T> {
   let resolve!: (value: T) => void;
   let reject!: (e: Error) => void;
@@ -101,6 +105,7 @@ abstract class AbstractBlockInput<F extends ForkName = ForkName, TData extends D
   }
 
   abstract addBlock(props: AddBlock<F>): void;
+  abstract getSerializedCacheKeys(): object[];
 
   hasBlock(): boolean {
     return this.state.hasBlock;
@@ -239,6 +244,10 @@ export class BlockInputPreData extends AbstractBlockInput<ForkPreDeneb, null> {
       );
     }
   }
+
+  getSerializedCacheKeys(): object[] {
+    return [this.state.block];
+  }
 }
 
 // Blobs DA
@@ -522,6 +531,20 @@ export class BlockInputBlobs extends AbstractBlockInput<ForkBlobsDA, deneb.BlobS
   getBlobs(): deneb.BlobSidecars {
     return this.getAllBlobsWithSource().map(({blobSidecar}) => blobSidecar);
   }
+
+  getSerializedCacheKeys(): object[] {
+    const objects: object[] = [];
+
+    if (this.state.hasBlock) {
+      objects.push(this.state.block);
+    }
+
+    for (const {blobSidecar} of this.blobsCache.values()) {
+      objects.push(blobSidecar);
+    }
+
+    return objects;
+  }
 }
 
 function blockAndBlobArePaired(block: SignedBeaconBlock<ForkBlobsDA>, blobSidecar: deneb.BlobSidecar): boolean {
@@ -902,4 +925,81 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
     }
     return Promise.resolve(this.getSampledColumns());
   }
+
+  getSerializedCacheKeys(): object[] {
+    const objects: object[] = [];
+
+    if (this.state.hasBlock) {
+      objects.push(this.state.block);
+    }
+
+    objects.push(...this.getAllColumns());
+
+    return objects;
+  }
+}
+
+type BlockInputNoDataState = {
+  hasBlock: true;
+  hasAllData: true;
+  block: SignedBeaconBlock<ForkPostGloas>;
+  source: SourceMeta;
+  timeCompleteSec: number;
+};
+
+export class BlockInputNoData extends AbstractBlockInput<ForkPostGloas, null> {
+  type = DAType.NoData as const;
+
+  state: BlockInputNoDataState;
+
+  private constructor(init: BlockInputInit, state: BlockInputNoDataState) {
+    super(init);
+    this.state = state;
+    this.dataPromise.resolve(null);
+    this.blockPromise.resolve(state.block);
+  }
+
+  static createFromBlock(props: AddBlock<ForkPostGloas> & CreateBlockInputMeta): BlockInputNoData {
+    const init: BlockInputInit = {
+      daOutOfRange: props.daOutOfRange,
+      timeCreated: props.seenTimestampSec,
+      forkName: props.forkName,
+      slot: props.block.message.slot,
+      blockRootHex: props.blockRootHex,
+      parentRootHex: toRootHex(props.block.message.parentRoot),
+    };
+    const state: BlockInputNoDataState = {
+      hasBlock: true,
+      hasAllData: true,
+      block: props.block,
+      source: {
+        source: props.source,
+        seenTimestampSec: props.seenTimestampSec,
+        peerIdStr: props.peerIdStr,
+      },
+      timeCompleteSec: props.seenTimestampSec,
+    };
+    return new BlockInputNoData(init, state);
+  }
+
+  addBlock(_: AddBlock<ForkPostGloas>, opts = {throwOnDuplicateAdd: true}): void {
+    if (opts.throwOnDuplicateAdd) {
+      throw new BlockInputError(
+        {
+          code: BlockInputErrorCode.INVALID_CONSTRUCTION,
+          blockRoot: this.blockRootHex,
+        },
+        "Cannot addBlock to BlockInputNoData - block already exists"
+      );
+    }
+  }
+
+  getBlobKzgCommitments(): deneb.BlobKzgCommitments {
+    return (this.state.block.message.body as gloas.BeaconBlockBody).signedExecutionPayloadBid.message
+      .blobKzgCommitments;
+  }
+
+  getSerializedCacheKeys(): object[] {
+    return [this.state.block];
+  }
 }

package/src/chain/blocks/blockInput/types.ts

@@ -6,6 +6,7 @@ export enum DAType {
   PreData = "pre-data",
   Blobs = "blobs",
   Columns = "columns",
+  NoData = "no-data",
 }
 
 export type DAData = null | deneb.BlobSidecars | fulu.DataColumnSidecars;
@@ -99,6 +100,18 @@ export type MissingColumnMeta = {
   versionedHashes: VersionedHashes;
 };
 
+/**
+ * Minimal interface required to write data columns to the DB.
+ * Used by `writeDataColumnsToDb` and designed to be reusable across forks (e.g. Fulu, Gloas).
+ */
+export interface IDataColumnsInput {
+  readonly slot: Slot;
+  readonly blockRootHex: string;
+  getCustodyColumns(): fulu.DataColumnSidecars;
+  hasComputedAllData(): boolean;
+  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<fulu.DataColumnSidecars>;
+}
+
 /**
  * This is used to validate that BlockInput implementations follow some minimal subset of operations
  * and that adding a new implementation won't break consumers that rely on this subset.
@@ -138,6 +151,11 @@ export interface IBlockInput<F extends ForkName = ForkName, TData extends DAData
 
   /** Only safe to call when `hasBlockAndAllData` is true */
   getTimeComplete(): number;
+  /**
+   * Return object references used as keys in `SerializedCache` that can be safely removed
+   * once this block input lifecycle has completed.
+   */
+  getSerializedCacheKeys(): object[];
 
   waitForBlock(timeout: number, signal?: AbortSignal): Promise<SignedBeaconBlock<F>>;
   waitForAllData(timeout: number, signal?: AbortSignal): Promise<TData>;

package/src/chain/blocks/importBlock.ts

@@ -20,7 +20,7 @@ import {
   isStartSlotOfEpoch,
   isStateValidatorsNodesPopulated,
 } from "@lodestar/state-transition";
-import {Attestation, BeaconBlock, altair, capella, electra, phase0, ssz} from "@lodestar/types";
+import {Attestation, BeaconBlock, altair, capella, electra, isGloasBeaconBlock, phase0, ssz} from "@lodestar/types";
 import {isErrorAborted, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {callInNextEventLoop} from "../../util/eventLoop.js";
@@ -95,7 +95,7 @@ export async function importBlock(
   // Without this, a supernode syncing from behind can accumulate many blocks worth of column
   // data in memory (up to 128 columns per block) causing OOM before persistence catches up.
   await this.unfinalizedBlockWrites.waitForSpace();
-  this.unfinalizedBlockWrites.push([blockInput]).catch((e) => {
+  this.unfinalizedBlockWrites.push(blockInput).catch((e) => {
     if (!isQueueErrorAborted(e)) {
       this.logger.error("Error pushing block to unfinalized write queue", {slot: blockSlot}, e as Error);
     }
@@ -230,6 +230,32 @@ export async function importBlock(
     }
   }
 
+  // 4.5. Import payload attestations to fork choice (Gloas)
+  //
+  if (isGloasBeaconBlock(block.message)) {
+    for (const payloadAttestation of block.message.body.payloadAttestations) {
+      try {
+        // Extract PTC indices from aggregation bits
+        const ptcIndices: number[] = [];
+        for (let i = 0; i < payloadAttestation.aggregationBits.bitLen; i++) {
+          if (payloadAttestation.aggregationBits.get(i)) {
+            ptcIndices.push(i);
+          }
+        }
+
+        if (ptcIndices.length > 0) {
+          this.forkChoice.notifyPtcMessages(
+            toRootHex(payloadAttestation.data.beaconBlockRoot),
+            ptcIndices,
+            payloadAttestation.data.payloadPresent
+          );
+        }
+      } catch (e) {
+        this.logger.warn("Error processing PayloadAttestation from block", {slot: blockSlot}, e as Error);
+      }
+    }
+  }
+
   // 5. Compute head. If new head, immediately stateCache.setHeadState()
 
   const oldHead = this.forkChoice.getHead();
@@ -345,7 +371,7 @@ export async function importBlock(
         //  3) Proposer boost reorg related flag is turned on (this is checked inside the function)
         //  4) Block meets the criteria of being re-orged out (this is also checked inside the function)
         const result = this.forkChoice.shouldOverrideForkChoiceUpdate(
-          blockSummary.blockRoot,
+          blockSummary,
           this.clock.secFromSlot(currentSlot),
           currentSlot
         );
@@ -441,7 +467,12 @@ export async function importBlock(
     this.metrics?.currentActiveValidators.set(activeValidatorsCount);
     this.metrics?.currentValidators.set({status: "active"}, activeValidatorsCount);
 
-    const parentBlockSummary = this.forkChoice.getBlock(checkpointState.latestBlockHeader.parentRoot);
+    const parentBlockSummary = isGloasBeaconBlock(block.message)
+      ? this.forkChoice.getBlockHexAndBlockHash(
+          toRootHex(checkpointState.latestBlockHeader.parentRoot),
+          toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash)
+        )
+      : this.forkChoice.getBlockDefaultStatus(checkpointState.latestBlockHeader.parentRoot);
 
     if (parentBlockSummary) {
       const justifiedCheckpoint = checkpointState.currentJustifiedCheckpoint;

package/src/chain/blocks/verifyBlocksDataAvailability.ts

@@ -29,6 +29,9 @@ export async function verifyBlocksDataAvailability(
 
   const availableTime = Math.max(0, Math.max(...blocks.map((blockInput) => blockInput.getTimeComplete())));
   const dataAvailabilityStatuses: DataAvailabilityStatus[] = blocks.map((blockInput) => {
+    if (blockInput.type === DAType.NoData) {
+      return DataAvailabilityStatus.NotRequired;
+    }
     if (blockInput.type === DAType.PreData) {
       return DataAvailabilityStatus.PreData;
     }

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -21,7 +21,7 @@ import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {BlockProcessOpts} from "../options.js";
-import {isBlockInputBlobs, isBlockInputColumns} from "./blockInput/blockInput.js";
+import {isBlockInputBlobs, isBlockInputColumns, isBlockInputNoData} from "./blockInput/blockInput.js";
 import {IBlockInput} from "./blockInput/types.js";
 import {ImportBlockOpts} from "./types.js";
 
@@ -51,7 +51,8 @@ type VerifyBlockExecutionResponse =
   | VerifyExecutionErrorResponse
   | {executionStatus: ExecutionStatus.Valid; lvhResponse: LVHValidResponse; execError: null}
   | {executionStatus: ExecutionStatus.Syncing; lvhResponse?: LVHValidResponse; execError: null}
-  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null};
+  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null}
+  | {executionStatus: ExecutionStatus.PayloadSeparated; lvhResponse: undefined; execError: null};
 
 /**
  * Verifies 1 or more execution payloads from a linear sequence of blocks.
@@ -148,6 +149,12 @@ export async function verifyBlockExecutionPayload(
   preState0: CachedBeaconStateAllForks
 ): Promise<VerifyBlockExecutionResponse> {
   const block = blockInput.getBlock();
+
+  // Gloas block doesn't have execution payload. Return right away
+  if (isBlockInputNoData(blockInput)) {
+    return {executionStatus: ExecutionStatus.PayloadSeparated, lvhResponse: undefined, execError: null};
+  }
+
   /** Not null if execution is enabled */
   const executionPayloadEnabled =
     isExecutionStateType(preState0) &&

package/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -1,7 +1,7 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {RootHex, Slot} from "@lodestar/types";
+import {RootHex, Slot, isGloasBeaconBlock} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {IClock} from "../../util/clock.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
@@ -90,7 +90,12 @@ export function verifyBlocksSanityChecks(
     } else {
       // When importing a block segment, only the first NON-IGNORED block must be known to the fork-choice.
       const parentRoot = toRootHex(block.message.parentRoot);
-      parentBlock = chain.forkChoice.getBlockHex(parentRoot);
+      parentBlock = isGloasBeaconBlock(block.message)
+        ? chain.forkChoice.getBlockHexAndBlockHash(
+            parentRoot,
+            toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash)
+          )
+        : chain.forkChoice.getBlockHexDefaultStatus(parentRoot);
       if (!parentBlock) {
         throw new BlockError(block, {code: BlockErrorCode.PARENT_UNKNOWN, parentRoot});
       }

package/src/chain/blocks/writeBlockInputToDb.ts

@@ -1,7 +1,9 @@
-import {fulu} from "@lodestar/types";
-import {prettyPrintIndices, toRootHex} from "@lodestar/utils";
+import {ForkPostDeneb, isForkPostDeneb} from "@lodestar/params";
+import {SignedBeaconBlock} from "@lodestar/types";
+import {fromHex, toRootHex} from "@lodestar/utils";
+import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {BeaconChain} from "../chain.js";
-import {IBlockInput, isBlockInputBlobs, isBlockInputColumns} from "./blockInput/index.js";
+import {IBlockInput, IDataColumnsInput, isBlockInputBlobs, isBlockInputColumns} from "./blockInput/index.js";
 import {BLOB_AVAILABILITY_TIMEOUT} from "./verifyBlocksDataAvailability.js";
 
 /**
@@ -10,129 +12,128 @@ import {BLOB_AVAILABILITY_TIMEOUT} from "./verifyBlocksDataAvailability.js";
  *
  * This operation may be performed before, during or after importing to the fork-choice. As long as errors
  * are handled properly for eventual consistency.
+ *
+ * Block+blobs (pre-fulu) and data columns (fulu+) are written in parallel.
  */
-export async function writeBlockInputToDb(this: BeaconChain, blocksInputs: IBlockInput[]): Promise<void> {
-  const fnPromises: Promise<void>[] = [];
-  // track slots for logging
-  const slots: number[] = [];
-
-  for (const blockInput of blocksInputs) {
-    const block = blockInput.getBlock();
-    const slot = block.message.slot;
-    slots.push(slot);
-    const blockRoot = this.config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message);
-    const blockRootHex = toRootHex(blockRoot);
-    const blockBytes = this.serializedCache.get(block);
-    if (blockBytes) {
-      // skip serializing data if we already have it
-      this.metrics?.importBlock.persistBlockWithSerializedDataCount.inc();
-      fnPromises.push(this.db.block.putBinary(this.db.block.getId(block), blockBytes));
-    } else {
-      this.metrics?.importBlock.persistBlockNoSerializedDataCount.inc();
-      fnPromises.push(this.db.block.add(block));
-    }
+export async function writeBlockInputToDb(this: BeaconChain, blockInput: IBlockInput): Promise<void> {
+  const promises: Promise<void>[] = [writeBlockAndBlobsToDb.call(this, blockInput)];
 
-    this.logger.debug("Persist block to hot DB", {
-      slot: block.message.slot,
-      root: blockRootHex,
-      inputType: blockInput.type,
-    });
+  if (isBlockInputColumns(blockInput)) {
+    promises.push(writeDataColumnsToDb.call(this, blockInput));
+  }
 
-    if (!blockInput.hasAllData()) {
-      await blockInput.waitForAllData(BLOB_AVAILABILITY_TIMEOUT);
-    }
+  await Promise.all(promises);
+  this.logger.debug("Persisted blockInput to db", {slot: blockInput.slot, root: blockInput.blockRootHex});
+}
 
-    // NOTE: Old data is pruned on archive
-    if (isBlockInputColumns(blockInput)) {
-      if (!blockInput.hasComputedAllData()) {
-        // Supernodes may only have a subset of the data columns by the time the block begins to be imported
-        // because full data availability can be assumed after NUMBER_OF_COLUMNS / 2 columns are available.
-        // Here, however, all data columns must be fully available/reconstructed before persisting to the DB.
-        await blockInput.waitForComputedAllData(BLOB_AVAILABILITY_TIMEOUT).catch(() => {
-          this.logger.debug("Failed to wait for computed all data", {slot, blockRoot: blockRootHex});
-        });
-      }
+async function writeBlockAndBlobsToDb(this: BeaconChain, blockInput: IBlockInput): Promise<void> {
+  const block = blockInput.getBlock();
+  const slot = block.message.slot;
+  const blockRoot = this.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block.message);
+  const blockRootHex = toRootHex(blockRoot);
+  const numBlobs = isForkPostDeneb(blockInput.forkName)
+    ? getBlobKzgCommitments(blockInput.forkName, block as SignedBeaconBlock<ForkPostDeneb>).length
+    : undefined;
+  const fnPromises: Promise<void>[] = [];
 
-      const {custodyColumns} = this.custodyConfig;
-      const blobsLen = (block.message as fulu.BeaconBlock).body.blobKzgCommitments.length;
-      let dataColumnsLen: number;
-      if (blobsLen === 0) {
-        dataColumnsLen = 0;
-      } else {
-        dataColumnsLen = custodyColumns.length;
-      }
+  const blockBytes = this.serializedCache.get(block);
+  if (blockBytes) {
+    // skip serializing data if we already have it
+    this.metrics?.importBlock.persistBlockWithSerializedDataCount.inc();
+    fnPromises.push(this.db.block.putBinary(this.db.block.getId(block), blockBytes));
+  } else {
+    this.metrics?.importBlock.persistBlockNoSerializedDataCount.inc();
+    fnPromises.push(this.db.block.add(block));
+  }
 
-      const dataColumnSidecars = blockInput.getCustodyColumns();
-      if (dataColumnSidecars.length !== dataColumnsLen) {
-        this.logger.debug(
-          `Invalid dataColumnSidecars=${dataColumnSidecars.length} for custody expected custodyColumnsLen=${dataColumnsLen}`
-        );
-      }
+  this.logger.debug("Persist block to hot DB", {slot, root: blockRootHex, inputType: blockInput.type, numBlobs});
 
-      const binaryPuts = [];
-      const nonbinaryPuts = [];
-      for (const dataColumnSidecar of dataColumnSidecars) {
-        // skip reserializing column if we already have it
-        const serialized = this.serializedCache.get(dataColumnSidecar);
-        if (serialized) {
-          binaryPuts.push({key: dataColumnSidecar.index, value: serialized});
-        } else {
-          nonbinaryPuts.push(dataColumnSidecar);
+  if (isBlockInputBlobs(blockInput)) {
+    fnPromises.push(
+      (async () => {
+        if (!blockInput.hasAllData()) {
+          await blockInput.waitForAllData(BLOB_AVAILABILITY_TIMEOUT);
         }
-      }
-      fnPromises.push(this.db.dataColumnSidecar.putManyBinary(blockRoot, binaryPuts));
-      fnPromises.push(this.db.dataColumnSidecar.putMany(blockRoot, nonbinaryPuts));
-      this.logger.debug("Persisted dataColumnSidecars to hot DB", {
-        slot: block.message.slot,
-        root: blockRootHex,
-        dataColumnSidecars: dataColumnSidecars.length,
-        numBlobs: blobsLen,
-        custodyColumns: custodyColumns.length,
-      });
-    } else if (isBlockInputBlobs(blockInput)) {
-      const blobSidecars = blockInput.getBlobs();
-      fnPromises.push(this.db.blobSidecars.add({blockRoot, slot: block.message.slot, blobSidecars}));
-      this.logger.debug("Persisted blobSidecars to hot DB", {
-        blobsLen: blobSidecars.length,
-        slot: block.message.slot,
-        root: blockRootHex,
-      });
-    }
+        const blobSidecars = blockInput.getBlobs();
+        await this.db.blobSidecars.add({blockRoot, slot, blobSidecars});
+        this.logger.debug("Persisted blobSidecars to hot DB", {
+          slot,
+          root: blockRootHex,
+          numBlobs: blobSidecars.length,
+        });
+      })()
+    );
+  }
+
+  await Promise.all(fnPromises);
+}
+
+/**
+ * Persists data columns to DB for a given block. Accepts a narrow sub-interface of IBlockInput
+ * so it can be reused across forks (e.g. Fulu, Gloas).
+ *
+ * NOTE: Old data is pruned on archive.
+ */
+export async function writeDataColumnsToDb(this: BeaconChain, blockInput: IDataColumnsInput): Promise<void> {
+  const {slot, blockRootHex} = blockInput;
+  const blockRoot = fromHex(blockRootHex);
 
-    await Promise.all(fnPromises);
-    this.logger.debug("Persisted blocksInput to db", {
-      blocksInput: blocksInputs.length,
-      slots: prettyPrintIndices(slots),
+  if (!blockInput.hasComputedAllData()) {
+    // Supernodes may only have a subset of the data columns by the time the block begins to be imported
+    // because full data availability can be assumed after NUMBER_OF_COLUMNS / 2 columns are available.
+    // Here, however, all data columns must be fully available/reconstructed before persisting to the DB.
+    await blockInput.waitForComputedAllData(BLOB_AVAILABILITY_TIMEOUT).catch(() => {
+      this.logger.debug("Failed to wait for computed all data", {slot, blockRoot: blockRootHex});
     });
   }
+
+  const {custodyColumns} = this.custodyConfig;
+  const dataColumnSidecars = blockInput.getCustodyColumns();
+
+  const binaryPuts: {key: number; value: Uint8Array}[] = [];
+  const nonbinaryPuts = [];
+  for (const dataColumnSidecar of dataColumnSidecars) {
+    // skip reserializing column if we already have it
+    const serialized = this.serializedCache.get(dataColumnSidecar);
+    if (serialized) {
+      binaryPuts.push({key: dataColumnSidecar.index, value: serialized});
+    } else {
+      nonbinaryPuts.push(dataColumnSidecar);
+    }
+  }
+
+  await Promise.all([
+    this.db.dataColumnSidecar.putManyBinary(blockRoot, binaryPuts),
+    this.db.dataColumnSidecar.putMany(blockRoot, nonbinaryPuts),
+  ]);
+
+  this.logger.debug("Persisted dataColumnSidecars to hot DB", {
+    slot,
+    root: blockRootHex,
+    dataColumnSidecars: dataColumnSidecars.length,
+    custodyColumns: custodyColumns.length,
+    numBlobs: dataColumnSidecars[0]?.column.length,
+  });
 }
 
-export async function persistBlockInputs(this: BeaconChain, blockInputs: IBlockInput[]): Promise<void> {
+export async function persistBlockInput(this: BeaconChain, blockInput: IBlockInput): Promise<void> {
   await writeBlockInputToDb
-    .call(this, blockInputs)
+    .call(this, blockInput)
     .catch((e) => {
       this.logger.debug(
         "Error persisting block input in hot db",
         {
-          count: blockInputs.length,
-          slot: blockInputs[0].slot,
-          root: blockInputs[0].blockRootHex,
+          slot: blockInput.slot,
+          root: blockInput.blockRootHex,
         },
         e
       );
     })
     .finally(() => {
-      for (const blockInput of blockInputs) {
-        this.seenBlockInputCache.prune(blockInput.blockRootHex);
-      }
-      // Without forcefully clearing this cache, we would rely on WeakMap to evict memory which is not reliable.
-      // Clear here (after the DB write) so that writeBlockInputToDb can still use the cached serialized bytes.
-      this.serializedCache.clear();
-      if (blockInputs.length === 1) {
-        this.logger.debug("Pruned block input", {
-          slot: blockInputs[0].slot,
-          root: blockInputs[0].blockRootHex,
-        });
-      }
+      this.seenBlockInputCache.prune(blockInput.blockRootHex);
+      this.logger.debug("Pruned block input", {
+        slot: blockInput.slot,
+        root: blockInput.blockRootHex,
+      });
     });
 }