@lodestar/beacon-node 1.48.0-dev.a0619b279a → 1.48.0-dev.a427d3dbb5

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

@@ -134,8 +134,6 @@ export async function archiveBlocks(
       logger.verbose("Migrated blobSidecars from hot DB to cold DB", {...logCtx, migratedEntries});
     }
 
-    // Keep the normal LevelDB hot-to-cold flow for legacy columns. New columns are written
-    // directly to flat files, so this only moves fallback data left by older versions.
     if (finalizedPostFulu) {
       const migratedSlots = await migrateDataColumnSidecarsFromHotToColdDb(
         config,
@@ -144,7 +142,7 @@ export async function archiveBlocks(
         finalizedCanonicalBlocks,
         currentEpoch
       );
-      logger.verbose("Migrated legacy dataColumnSidecars from hot DB to cold DB", {
+      logger.verbose("Migrated dataColumnSidecars from hot DB to cold DB", {
         ...logCtx,
         migratedEntries: migratedSlots.length,
         slotRange: prettyPrintIndices(migratedSlots),
@@ -197,23 +195,6 @@ export async function archiveBlocks(
       slotRange: prettyPrintIndices(nonCanonicalSlots),
     };
 
-    const columnItems = finalizedNonCanonicalBlocks
-      // Gloas EMPTY and FULL variants share a block root. EMPTY has no sidecars, so deleting by its root could
-      // remove the canonical FULL variant's columns. Pre-Gloas blocks are always FULL.
-      .filter(
-        (summary) => config.getForkSeq(summary.slot) >= ForkSeq.fulu && summary.payloadStatus === PayloadStatus.FULL
-      )
-      .map((summary) => ({slot: summary.slot, blockRoot: summary.blockRoot}));
-    if (columnItems.length > 0) {
-      // Delete sidecars first so their block roots remain available to retry cleanup after a failure or crash.
-      await db.dataColumns.deleteMany(columnItems);
-      logger.verbose("Deleted non canonical data columns of blocks", {
-        ...logCtx,
-        blocks: columnItems.length,
-        slotRange: prettyPrintIndices(columnItems.map(({slot}) => slot).sort((a, b) => a - b)),
-      });
-    }
-
     await db.block.batchDelete(nonCanonicalBlockRoots);
     logger.verbose("Deleted non canonical blocks from hot DB", nonCanonicalLogCtx);
 
@@ -222,6 +203,11 @@ export async function archiveBlocks(
       logger.verbose("Deleted non canonical blobSidecars from hot DB", nonCanonicalLogCtx);
     }
 
+    if (finalizedPostFulu) {
+      await db.dataColumnSidecar.deleteMany(nonCanonicalBlockRoots);
+      logger.verbose("Deleted non canonical dataColumnSidecars from hot DB", nonCanonicalLogCtx);
+    }
+
     if (finalizedPostGloas) {
       await db.executionPayloadEnvelope.batchDelete(nonCanonicalBlockRoots);
       logger.verbose("Deleted non canonical executionPayloadEnvelopes from hot DB", nonCanonicalLogCtx);
@@ -259,16 +245,23 @@ export async function archiveBlocks(
       );
       const dataColumnSidecarsMinEpoch = currentEpoch - dataColumnSidecarsArchiveWindow;
       if (dataColumnSidecarsMinEpoch >= config.FULU_FORK_EPOCH) {
-        const columnsPruneSlot = computeStartSlotAtEpoch(dataColumnSidecarsMinEpoch);
-        const prunedColumnSlots = await db.dataColumns.pruneBefore(columnsPruneSlot);
-        if (prunedColumnSlots.length > 0) {
+        const prefixedKeys = await db.dataColumnSidecarArchive.keys({
+          // The `id` value `0` refers to the column index. So we want to fetch all sidecars less than zero column of `dataColumnSidecarsMinEpoch`
+          lt: {prefix: computeStartSlotAtEpoch(dataColumnSidecarsMinEpoch), id: 0},
+        });
+        // for each slot there could be multiple dataColumnSidecar, so we need to deduplicate it
+        const slotsToDelete = [...new Set(prefixedKeys.map(({prefix}) => prefix))].sort((a, b) => a - b);
+
+        if (slotsToDelete.length > 0) {
+          await db.dataColumnSidecarArchive.deleteMany(slotsToDelete);
           logger.verbose("dataColumnSidecars prune", {
             ...logCtx,
-            slotRange: prettyPrintIndices(prunedColumnSlots),
-            numOfSlots: prunedColumnSlots.length,
+            slotRange: prettyPrintIndices(slotsToDelete),
+            numOfSlots: slotsToDelete.length,
+            totalNumOfSidecars: prefixedKeys.length,
           });
         } else {
-          logger.verbose("dataColumnSidecars prune: no entries before slot", {...logCtx, slot: columnsPruneSlot});
+          logger.verbose(`dataColumnSidecars prune: no entries before epoch ${dataColumnSidecarsMinEpoch}`, logCtx);
         }
       } else {
         logger.verbose(
@@ -396,6 +389,7 @@ async function migrateBlobSidecarsFromHotToColdDb(
       )
     ).filter((e): e is KeyValue<Slot, Uint8Array> => e !== null);
 
+    // put to blockArchive db and delete block db
     await Promise.all([
       db.blobSidecarsArchive.batchPutBinary(canonicalBlobSidecarsEntries),
       db.blobSidecars.batchDelete(canonicalBlocks.map((block) => block.root)),
@@ -408,9 +402,11 @@ async function migrateBlobSidecarsFromHotToColdDb(
 
 // TODO: This function can be simplified further by reducing layers of promises in a loop
 /**
- * Post-gloas the data columns of a Gloas block are tied to its execution payload envelope.
- * Columns only exist once the FULL variant of the block is in the proto-array. Pre-Gloas
- * blocks only have a FULL variant, so the payload-status filter passes them all.
+ * Post-gloas the data columns of a Gloas block are tied to its execution payload envelope —
+ * columns only exist once the FULL variant of the block is in the proto-array. Pre-Gloas (Fulu)
+ * blocks only have a FULL variant, so the `payloadStatus === FULL` filter passes them all.
+ * Blocks whose canonical variant is PENDING/EMPTY are skipped here — their columns will be picked
+ * up on a later run once the FULL variant appears in the ancestor walk.
  */
 async function migrateDataColumnSidecarsFromHotToColdDb(
   config: ChainForkConfig,
@@ -432,24 +428,32 @@ async function migrateDataColumnSidecarsFromHotToColdDb(
     if (batch.length === 0) break;
 
     const promises: Promise<void>[] = [];
+
+    // load Buffer instead of ssz deserialized to improve performance
     for (const block of batch) {
-      const blockEpoch = computeEpochAtSlot(block.slot);
+      const blockSlot = block.slot;
+      const blockEpoch = computeEpochAtSlot(blockSlot);
+
       if (
-        config.getForkSeq(block.slot) < ForkSeq.fulu ||
+        config.getForkSeq(blockSlot) < ForkSeq.fulu ||
+        // if block is out of ${config.MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS}, skip this step
         blockEpoch < currentEpoch - config.MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS
       ) {
         continue;
       }
 
+      // Here we assume the data column sidecars are already in the hot db
       const dataColumnSidecarBytes = await fromAsync(db.dataColumnSidecar.valuesStreamBinary(block.root));
       if (dataColumnSidecarBytes.length === 0) {
+        // Empty stream: either the block has no blobs, or columns were already archived on a
+        // previous run (boundary block). Nothing to migrate.
         logger.debug("DataColumnSidecars in forkchoice but missing in hot db, could be already archived", {
           slot: block.slot,
           root: toRootHex(block.root),
         });
         continue;
       }
-      logger.verbose("Migrated legacy dataColumnSidecars for block", {
+      logger.verbose("Migrated dataColumnSidecars for block", {
         currentEpoch,
         slot: block.slot,
         root: toRootHex(block.root),
@@ -458,14 +462,15 @@ async function migrateDataColumnSidecarsFromHotToColdDb(
       promises.push(
         db.dataColumnSidecarArchive.putManyBinary(
           block.slot,
-          dataColumnSidecarBytes.map((entry) => ({key: entry.id, value: entry.value}))
+          dataColumnSidecarBytes.map((p) => ({key: p.id, value: p.value}))
         )
       );
       migratedSlots.push(block.slot);
     }
 
+    promises.push(db.dataColumnSidecar.deleteMany(batch.map((block) => block.root)));
+
     await Promise.all(promises);
-    await db.dataColumnSidecar.deleteMany(batch.map((block) => block.root));
   }
 
   // Ancestor walk is newest to oldest; sort ascending so `prettyPrintIndices` renders cleanly.

package/src/chain/blocks/writeBlockInputToDb.ts

@@ -1,6 +1,6 @@
-import {ForkPostDeneb, ForkPostFulu, isForkPostDeneb} from "@lodestar/params";
+import {ForkPostDeneb, isForkPostDeneb} from "@lodestar/params";
 import {SignedBeaconBlock} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
+import {fromHex, toRootHex} from "@lodestar/utils";
 import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {BeaconChain} from "../chain.js";
 import {IBlockInput, IDataColumnsInput, isBlockInputBlobs, isBlockInputColumns} from "./blockInput/index.js";
@@ -76,6 +76,7 @@ async function writeBlockAndBlobsToDb(this: BeaconChain, blockInput: IBlockInput
  */
 export async function writeDataColumnsToDb(this: BeaconChain, blockInput: IDataColumnsInput): Promise<void> {
   const {slot, blockRootHex} = blockInput;
+  const blockRoot = fromHex(blockRootHex);
 
   if (!blockInput.hasComputedAllData()) {
     // Supernodes may only have a subset of the data columns by the time the block begins to be imported
@@ -88,19 +89,25 @@ export async function writeDataColumnsToDb(this: BeaconChain, blockInput: IDataC
 
   const {custodyColumns} = this.custodyConfig;
   const dataColumnSidecars = blockInput.getCustodyColumns();
-  const dataColumnSidecarType = this.config.getForkTypes<ForkPostFulu>(slot).DataColumnSidecar;
 
-  const binaryColumns: {index: number; data: Uint8Array}[] = [];
+  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);
-    binaryColumns.push({
-      index: dataColumnSidecar.index,
-      data: serialized ?? dataColumnSidecarType.serialize(dataColumnSidecar),
-    });
+    if (serialized) {
+      binaryPuts.push({key: dataColumnSidecar.index, value: serialized});
+    } else {
+      nonbinaryPuts.push(dataColumnSidecar);
+    }
   }
-  await this.db.dataColumns.putManyBinary({slot, blockRoot: blockRootHex}, binaryColumns);
 
-  this.logger.debug("Persisted dataColumnSidecars", {
+  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,

package/src/chain/chain.ts

@@ -268,7 +268,6 @@ export class BeaconChain implements IBeaconChain {
       db,
       dbName,
       dataDir,
-      dataColumnDir,
       logger,
       processShutdownCallback,
       clock,
@@ -286,7 +285,6 @@ export class BeaconChain implements IBeaconChain {
       db: IBeaconDb;
       dbName: string;
       dataDir: string;
-      dataColumnDir?: string;
       logger: Logger;
       processShutdownCallback: ProcessShutdownCallback;
       /** Used for testing to supply fake clock */
@@ -507,12 +505,7 @@ export class BeaconChain implements IBeaconChain {
 
     this.archiveStore = new ArchiveStore(
       {db, chain: this, logger: logger as LoggerNode, metrics},
-      {
-        ...opts,
-        dbName,
-        dataColumnDir: dataColumnDir ?? path.join(dataDir, "data_columns"),
-        anchorState: {finalizedCheckpoint: anchorState.finalizedCheckpoint},
-      },
+      {...opts, dbName, anchorState: {finalizedCheckpoint: anchorState.finalizedCheckpoint}},
       signal
     );
 
@@ -976,15 +969,12 @@ export class BeaconChain implements IBeaconChain {
 
   async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecar[]> {
     const fork = this.config.getForkName(blockSlot);
-    const sidecarsByIndex = new Map<number, DataColumnSidecar>();
 
     if (isForkPostGloas(fork)) {
       // After gloas, columns are tracked in PayloadEnvelopeInput
       const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
       if (payloadInput) {
-        for (const sidecar of payloadInput.getAllColumns()) {
-          sidecarsByIndex.set(sidecar.index, sidecar);
-        }
+        return payloadInput.getAllColumns();
       }
     } else {
       // Before gloas, columns are tracked in BlockInput
@@ -993,17 +983,16 @@ export class BeaconChain implements IBeaconChain {
         if (!isBlockInputColumns(blockInput)) {
           throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
         }
-        for (const sidecar of blockInput.getAllColumns()) {
-          sidecarsByIndex.set(sidecar.index, sidecar);
-        }
+        return blockInput.getAllColumns();
       }
     }
 
-    for (const sidecar of await this.db.dataColumns.getAll({slot: blockSlot, blockRoot: blockRootHex})) {
-      if (!sidecarsByIndex.has(sidecar.index)) sidecarsByIndex.set(sidecar.index, sidecar);
+    const sidecarsUnfinalized = await this.db.dataColumnSidecar.values(fromHex(blockRootHex));
+    if (sidecarsUnfinalized.length > 0) {
+      return sidecarsUnfinalized;
     }
-
-    return [...sidecarsByIndex.values()].sort((a, b) => a.index - b.index);
+    const sidecarsFinalized = await this.db.dataColumnSidecarArchive.values(blockSlot);
+    return sidecarsFinalized;
   }
 
   async getSerializedDataColumnSidecars(
@@ -1012,25 +1001,22 @@ export class BeaconChain implements IBeaconChain {
     indices: number[]
   ): Promise<(Uint8Array | undefined)[]> {
     const fork = this.config.getForkName(blockSlot);
-    const dataColumnSidecars: (Uint8Array | undefined)[] = indices.map(() => undefined);
 
     if (isForkPostGloas(fork)) {
       // After gloas, columns are tracked in PayloadEnvelopeInput
       const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
       if (payloadInput) {
-        for (let i = 0; i < indices.length; i++) {
-          const index = indices[i];
+        return indices.map((index) => {
           const sidecar = payloadInput.getColumn(index);
           if (!sidecar) {
-            continue;
+            return undefined;
           }
           const serialized = this.serializedCache.get(sidecar);
           if (serialized) {
-            dataColumnSidecars[i] = serialized;
-          } else {
-            dataColumnSidecars[i] = sszTypesFor(fork as ForkPostGloas).DataColumnSidecar.serialize(sidecar);
+            return serialized;
           }
-        }
+          return sszTypesFor(fork as ForkPostGloas).DataColumnSidecar.serialize(sidecar);
+        });
       }
     } else {
       // Before gloas, columns are tracked in BlockInput
@@ -1039,42 +1025,26 @@ export class BeaconChain implements IBeaconChain {
         if (!isBlockInputColumns(blockInput)) {
           throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
         }
-        for (let i = 0; i < indices.length; i++) {
-          const index = indices[i];
+        return indices.map((index) => {
           const sidecar = blockInput.getColumn(index);
           if (!sidecar) {
-            continue;
+            return undefined;
           }
           const serialized = this.serializedCache.get(sidecar);
           if (serialized) {
-            dataColumnSidecars[i] = serialized;
-          } else {
-            dataColumnSidecars[i] = sszTypesFor(blockInput.forkName as ForkPostFulu).DataColumnSidecar.serialize(
-              sidecar
-            );
+            return serialized;
           }
-        }
+          return sszTypesFor(blockInput.forkName as ForkPostFulu).DataColumnSidecar.serialize(sidecar);
+        });
       }
     }
 
-    const missingPositions = dataColumnSidecars
-      .map((sidecar, position) => (sidecar === undefined ? position : -1))
-      .filter((position) => position !== -1);
-
-    if (missingPositions.length > 0) {
-      const persistedSidecars = await this.db.dataColumns.getManyBinary(
-        {slot: blockSlot, blockRoot: blockRootHex},
-        missingPositions.map((position) => indices[position])
-      );
-      for (let i = 0; i < missingPositions.length; i++) {
-        const sidecar = persistedSidecars[i];
-        if (sidecar !== undefined) {
-          dataColumnSidecars[missingPositions[i]] = sidecar;
-        }
-      }
+    const sidecarsUnfinalized = await this.db.dataColumnSidecar.getManyBinary(fromHex(blockRootHex), indices);
+    if (sidecarsUnfinalized.some((sidecar) => sidecar != null)) {
+      return sidecarsUnfinalized;
     }
-
-    return dataColumnSidecars;
+    const sidecarsFinalized = await this.db.dataColumnSidecarArchive.getManyBinary(blockSlot, indices);
+    return sidecarsFinalized;
   }
 
   async produceCommonBlockBody(blockAttributes: BlockAttributes): Promise<CommonBlockBody> {

package/src/db/beacon.ts

@@ -1,11 +1,6 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {Db, LevelDbControllerMetrics, encodeKey} from "@lodestar/db";
-import {Slot} from "@lodestar/types";
-import {Logger} from "@lodestar/utils";
 import {Bucket} from "./buckets.js";
-import {type IDataColumnStore, LegacyDataColumnStore} from "./dataColumnStore.js";
-import {FlatFileStore} from "./flatFileStore/flatFileStore.js";
-import type {FlatFileStoreMetrics} from "./flatFileStore/metrics.js";
 import {IBeaconDb} from "./interface.js";
 import {CheckpointStateRepository} from "./repositories/checkpointState.js";
 import {
@@ -29,10 +24,9 @@ import {
   VoluntaryExitRepository,
 } from "./repositories/index.js";
 
-export type BeaconDbOpts = {
-  dataColumnDir: string;
-  logger: Logger;
-  metrics?: FlatFileStoreMetrics | null;
+export type BeaconDbModules = {
+  config: ChainForkConfig;
+  db: Db;
 };
 
 export class BeaconDb implements IBeaconDb {
@@ -63,14 +57,9 @@ export class BeaconDb implements IBeaconDb {
 
   backfilledRanges: BackfilledRanges;
 
-  readonly dataColumns: IDataColumnStore;
-  lastLegacyArchiveSlot: Slot | null = null;
-  private readonly flatFileStore: FlatFileStore;
-
   constructor(
     config: ChainForkConfig,
-    protected readonly db: Db,
-    opts: BeaconDbOpts
+    protected readonly db: Db
   ) {
     // Warning: If code is ever run in the constructor, must change this stub to not extend 'packages/beacon-node/test/utils/stub/beaconDb.ts' -
     this.block = new BlockRepository(config, db);
@@ -98,30 +87,14 @@ export class BeaconDb implements IBeaconDb {
     this.syncCommitteeWitness = new SyncCommitteeWitnessRepository(config, db);
 
     this.backfilledRanges = new BackfilledRanges(config, db);
-
-    this.flatFileStore = new FlatFileStore(opts.dataColumnDir, config, opts.logger, opts.metrics);
-    this.dataColumns = new LegacyDataColumnStore(
-      this.flatFileStore,
-      this.dataColumnSidecar,
-      this.dataColumnSidecarArchive,
-      this.blockArchive
-    );
-  }
-
-  async init(): Promise<void> {
-    await this.flatFileStore.init();
-    const [lastLegacyKey] = await this.dataColumnSidecarArchive.keys({reverse: true, limit: 1});
-    this.lastLegacyArchiveSlot = lastLegacyKey?.prefix ?? null;
   }
 
-  async close(): Promise<void> {
-    await this.flatFileStore.close();
+  close(): Promise<void> {
     return this.db.close();
   }
 
-  setMetrics(metrics: LevelDbControllerMetrics, flatFileStoreMetrics: FlatFileStoreMetrics | null = null): void {
+  setMetrics(metrics: LevelDbControllerMetrics): void {
     this.db.setMetrics(metrics);
-    this.flatFileStore.setMetrics(flatFileStoreMetrics);
   }
 
   async pruneHotDb(): Promise<void> {

package/src/db/index.ts

@@ -1,4 +1,3 @@
 export {BeaconDb} from "./beacon.js";
 export {Bucket} from "./buckets.js";
-export type {DataColumnKey, IDataColumnStore, IndexedDataColumnBytes} from "./dataColumnStore.js";
 export type {IBeaconDb} from "./interface.js";

package/src/db/interface.ts

@@ -1,7 +1,4 @@
 import {LevelDbControllerMetrics} from "@lodestar/db";
-import {Slot} from "@lodestar/types";
-import type {IDataColumnStore} from "./dataColumnStore.js";
-import type {FlatFileStoreMetrics} from "./flatFileStore/metrics.js";
 import {CheckpointStateRepository} from "./repositories/checkpointState.js";
 import {
   AttesterSlashingRepository,
@@ -62,11 +59,6 @@ export interface IBeaconDb {
 
   backfilledRanges: BackfilledRanges;
 
-  dataColumns: IDataColumnStore;
-  /** Highest legacy column slot at startup; later archival writes the block-root index first. */
-  readonly lastLegacyArchiveSlot: Slot | null;
-  init(): Promise<void>;
-
   pruneHotDb(): Promise<void>;
 
   deleteDeprecatedEth1Data(): Promise<void>;
@@ -74,5 +66,5 @@ export interface IBeaconDb {
   /**  Close the connection to the db instance and close the db store. */
   close(): Promise<void>;
   /** To inject metrics after CLI initialization */
-  setMetrics(metrics: LevelDbControllerMetrics, flatFileStoreMetrics?: FlatFileStoreMetrics | null): void;
+  setMetrics(metrics: LevelDbControllerMetrics): void;
 }

package/src/db/repositories/blockArchive.ts

@@ -1,17 +1,16 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {Db, DbBatch, FilterOptions, KeyValue, Repository} from "@lodestar/db";
+import {Db, FilterOptions, KeyValue, Repository} from "@lodestar/db";
 import {Root, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
-import {bytesToInt, intToBytes} from "@lodestar/utils";
+import {bytesToInt} from "@lodestar/utils";
 import {getSignedBlockTypeFromBytes} from "../../util/multifork.js";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 import {
   deleteParentRootIndex,
   deleteRootIndex,
   getParentRootIndex,
-  getParentRootIndexKey,
   getRootIndex,
-  getRootIndexKey,
-  getSlotIndexKey,
+  storeParentRootIndex,
+  storeRootIndex,
 } from "./blockArchiveIndex.js";
 
 export interface BlockFilterOptions extends FilterOptions<Slot> {
@@ -57,91 +56,37 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
   // Overrides to index
 
   async put(key: Slot, value: SignedBeaconBlock): Promise<void> {
-    await this.batchPut([{key, value}]);
-  }
-
-  async putBinary(key: Slot, value: Uint8Array): Promise<void> {
-    const block = this.decodeValue(value);
-    await this.batchPutBinary([
-      {
-        key,
-        value,
-        slot: block.message.slot,
-        blockRoot: this.config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message),
-        parentRoot: block.message.parentRoot,
-      },
+    const blockRoot = this.config.getForkTypes(value.message.slot).BeaconBlock.hashTreeRoot(value.message);
+    const slot = value.message.slot;
+    await Promise.all([
+      super.put(key, value),
+      storeRootIndex(this.db, slot, blockRoot),
+      storeParentRootIndex(this.db, slot, value.message.parentRoot),
     ]);
   }
 
   async batchPut(items: KeyValue<Slot, SignedBeaconBlock>[]): Promise<void> {
-    await this.batchPutBinary(
-      items.map(({key, value}) => ({
-        key,
-        value: this.encodeValue(value),
-        slot: value.message.slot,
-        blockRoot: this.config.getForkTypes(value.message.slot).BeaconBlock.hashTreeRoot(value.message),
-        parentRoot: value.message.parentRoot,
-      }))
-    );
+    await Promise.all([
+      super.batchPut(items),
+      Array.from(items).map((item) => {
+        const slot = item.value.message.slot;
+        const blockRoot = this.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(item.value.message);
+        return storeRootIndex(this.db, slot, blockRoot);
+      }),
+      Array.from(items).map((item) => {
+        const slot = item.value.message.slot;
+        const parentRoot = item.value.message.parentRoot;
+        return storeParentRootIndex(this.db, slot, parentRoot);
+      }),
+    ]);
   }
 
   async batchPutBinary(items: BlockArchiveBatchPutBinaryItem[]): Promise<void> {
-    await this.db.batchPut(
-      items.flatMap((item) => this.indexedBlockEntries(item)),
-      this.dbReqOpts
-    );
-  }
-
-  async delete(slot: Slot): Promise<void> {
-    await this.batchDelete([slot]);
-  }
-
-  async batchDelete(slots: Slot[]): Promise<void> {
-    await this.db.batchDelete(
-      slots.flatMap((slot) => [this.encodeKey(slot), getSlotIndexKey(slot)]),
-      this.dbReqOpts
-    );
-  }
-
-  async batch(operations: DbBatch<Slot, SignedBeaconBlock>): Promise<void> {
-    await this.batchBinary(
-      operations.map((operation) =>
-        operation.type === "put" ? {...operation, value: this.encodeValue(operation.value)} : operation
-      )
-    );
-  }
-
-  async batchBinary(operations: DbBatch<Slot, Uint8Array>): Promise<void> {
-    const batch: DbBatch<Uint8Array, Uint8Array> = [];
-    for (const operation of operations) {
-      if (operation.type === "del") {
-        batch.push(
-          {type: "del", key: this.encodeKey(operation.key)},
-          {type: "del", key: getSlotIndexKey(operation.key)}
-        );
-      } else {
-        const block = this.decodeValue(operation.value);
-        const entries = this.indexedBlockEntries({
-          key: operation.key,
-          value: operation.value,
-          slot: block.message.slot,
-          blockRoot: this.config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message),
-          parentRoot: block.message.parentRoot,
-        });
-        batch.push(...entries.map((entry) => ({type: "put" as const, ...entry})));
-      }
-    }
-    await this.db.batch(batch, this.dbReqOpts);
-  }
-
-  private indexedBlockEntries(item: BlockArchiveBatchPutBinaryItem): KeyValue<Uint8Array, Uint8Array>[] {
-    const slotBytes = intToBytes(item.slot, 8, "be");
-    return [
-      {key: this.encodeKey(item.key), value: item.value},
-      {key: getRootIndexKey(item.blockRoot), value: slotBytes},
-      {key: getParentRootIndexKey(item.parentRoot), value: slotBytes},
-      {key: getSlotIndexKey(item.key), value: item.blockRoot},
-    ];
+    await Promise.all([
+      super.batchPutBinary(items),
+      Array.from(items).map((item) => storeRootIndex(this.db, item.slot, item.blockRoot)),
+      Array.from(items).map((item) => storeParentRootIndex(this.db, item.slot, item.parentRoot)),
+    ]);
   }
 
   async remove(value: SignedBeaconBlock): Promise<void> {
@@ -155,10 +100,10 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
   async batchRemove(values: SignedBeaconBlock[]): Promise<void> {
     await Promise.all([
       super.batchRemove(values),
-      ...values.map((value) =>
+      Array.from(values).map((value) =>
         deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).SignedBeaconBlock, value)
       ),
-      ...values.map((value) => deleteParentRootIndex(this.db, value)),
+      Array.from(values).map((value) => deleteParentRootIndex(this.db, value)),
     ]);
   }
 
@@ -195,10 +140,6 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
     return slot !== null ? this.get(slot) : null;
   }
 
-  async getRootBySlot(slot: Slot): Promise<Root | null> {
-    return this.db.get(getSlotIndexKey(slot), {bucketId: getBucketNameByValue(Bucket.index_mainChain)});
-  }
-
   async getSlotByRoot(root: Root): Promise<Slot | null> {
     return this.parseSlot(await getRootIndex(this.db, root));
   }

package/src/db/repositories/blockArchiveIndex.ts

@@ -1,6 +1,7 @@
 import {Db, encodeKey} from "@lodestar/db";
 import {ForkAll} from "@lodestar/params";
 import {Root, SSZTypesFor, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
+import {intToBytes} from "@lodestar/utils";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 export const rootIndexBucketId = getBucketNameByValue(Bucket.index_blockArchiveRootIndex);
@@ -14,6 +15,14 @@ export async function getParentRootIndex(db: Db, parentRoot: Root): Promise<Uint
   return db.get(getParentRootIndexKey(parentRoot), {bucketId: parentRootIndexBucketId});
 }
 
+export async function storeRootIndex(db: Db, slot: Slot, blockRoot: Root): Promise<void> {
+  return db.put(getRootIndexKey(blockRoot), intToBytes(slot, 8, "be"), {bucketId: rootIndexBucketId});
+}
+
+export async function storeParentRootIndex(db: Db, slot: Slot, parentRoot: Root): Promise<void> {
+  return db.put(getParentRootIndexKey(parentRoot), intToBytes(slot, 8, "be"), {bucketId: parentRootIndexBucketId});
+}
+
 export async function deleteRootIndex(
   db: Db,
   signedBeaconBlockType: SSZTypesFor<ForkAll, "SignedBeaconBlock">,
@@ -34,7 +43,3 @@ export function getParentRootIndexKey(parentRoot: Root): Uint8Array {
 export function getRootIndexKey(root: Root): Uint8Array {
   return encodeKey(Bucket.index_blockArchiveRootIndex, root);
 }
-
-export function getSlotIndexKey(slot: Slot): Uint8Array {
-  return encodeKey(Bucket.index_mainChain, slot);
-}