@lodestar/beacon-node 1.48.0-dev.baa28132d2 → 1.48.0-dev.bb3ffba9e9

package/src/db/flatFileStore/errors.ts

@@ -0,0 +1,53 @@
+import {LodestarError} from "@lodestar/utils";
+
+export enum DataColumnStoreErrorCode {
+  INVALID_ROOT = "DATA_COLUMN_STORE_INVALID_ROOT",
+  INVALID_SLOT = "DATA_COLUMN_STORE_INVALID_SLOT",
+  SLOT_OUT_OF_RANGE = "DATA_COLUMN_STORE_SLOT_OUT_OF_RANGE",
+  INVALID_BITMAP_LENGTH = "DATA_COLUMN_STORE_INVALID_BITMAP_LENGTH",
+  INVALID_BLOCK_ROOT_LENGTH = "DATA_COLUMN_STORE_INVALID_BLOCK_ROOT_LENGTH",
+  FILE_TOO_SMALL = "DATA_COLUMN_STORE_FILE_TOO_SMALL",
+  UNSUPPORTED_VERSION = "DATA_COLUMN_STORE_UNSUPPORTED_VERSION",
+  EMPTY_COLUMNS = "DATA_COLUMN_STORE_EMPTY_COLUMNS",
+  INVALID_COLUMN_INDEX = "DATA_COLUMN_STORE_INVALID_COLUMN_INDEX",
+  DUPLICATE_COLUMN_INDEX = "DATA_COLUMN_STORE_DUPLICATE_COLUMN_INDEX",
+  INVALID_OFFSET_TABLE = "DATA_COLUMN_STORE_INVALID_OFFSET_TABLE",
+  SLOT_PRUNED = "DATA_COLUMN_STORE_SLOT_PRUNED",
+  SLOT_MISMATCH = "DATA_COLUMN_STORE_SLOT_MISMATCH",
+  ROOT_MISMATCH = "DATA_COLUMN_STORE_ROOT_MISMATCH",
+  UNEXPECTED_EOF = "DATA_COLUMN_STORE_UNEXPECTED_EOF",
+  OPERATION_FAILED = "DATA_COLUMN_STORE_OPERATION_FAILED",
+  BATCH_DELETE_FAILED = "DATA_COLUMN_STORE_BATCH_DELETE_FAILED",
+  STARTUP_FAILED = "DATA_COLUMN_STORE_STARTUP_FAILED",
+}
+
+export type DataColumnStoreErrorType =
+  | {code: DataColumnStoreErrorCode.INVALID_ROOT; root: string}
+  | {code: DataColumnStoreErrorCode.INVALID_SLOT; slot: number}
+  | {code: DataColumnStoreErrorCode.SLOT_OUT_OF_RANGE}
+  | {code: DataColumnStoreErrorCode.INVALID_BITMAP_LENGTH; length: number}
+  | {code: DataColumnStoreErrorCode.INVALID_BLOCK_ROOT_LENGTH; length: number}
+  | {code: DataColumnStoreErrorCode.FILE_TOO_SMALL; actual: number; minimum: number}
+  | {code: DataColumnStoreErrorCode.UNSUPPORTED_VERSION; version: number}
+  | {code: DataColumnStoreErrorCode.EMPTY_COLUMNS}
+  | {code: DataColumnStoreErrorCode.INVALID_COLUMN_INDEX; index: number}
+  | {code: DataColumnStoreErrorCode.DUPLICATE_COLUMN_INDEX; index: number}
+  | {code: DataColumnStoreErrorCode.INVALID_OFFSET_TABLE; reason: string}
+  | {code: DataColumnStoreErrorCode.SLOT_PRUNED; slot: number; minRetainedSlot: number}
+  | {code: DataColumnStoreErrorCode.SLOT_MISMATCH; headerSlot: number; pathSlot: number}
+  | {code: DataColumnStoreErrorCode.ROOT_MISMATCH; headerRoot: string; pathRoot: string}
+  | {code: DataColumnStoreErrorCode.UNEXPECTED_EOF; offset: number}
+  | {code: DataColumnStoreErrorCode.OPERATION_FAILED; operation: string}
+  | {code: DataColumnStoreErrorCode.BATCH_DELETE_FAILED; failures: number}
+  | {code: DataColumnStoreErrorCode.STARTUP_FAILED};
+
+export class DataColumnStoreError extends LodestarError<DataColumnStoreErrorType> {
+  constructor(type: DataColumnStoreErrorType, message?: string, cause?: unknown) {
+    super(type, message);
+    this.cause = cause;
+  }
+}
+
+export function isFsNotFoundError(error: unknown): boolean {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/src/db/flatFileStore/flatFileStore.ts

@@ -0,0 +1,310 @@
+import fs from "node:fs";
+import path from "node:path";
+import {ChainForkConfig} from "@lodestar/config";
+import {ForkPostFulu} from "@lodestar/params";
+import {DataColumnSidecar, RootHex, Slot} from "@lodestar/types";
+import {Logger, fromHex, toRootHex} from "@lodestar/utils";
+import {atomicWrite, mkdirDurable} from "./atomicWrite.js";
+import {
+  DCOL_HEADER_SIZE,
+  type DcolHeader,
+  encodeDcolFile,
+  getColumnByteRange,
+  mergeDcolColumns,
+  offsetTableSize,
+  parseDcolHeader,
+  parseDcolOffsets,
+  readAllColumns,
+  totalBits,
+} from "./dcolFormat.js";
+import {DataColumnStoreError, DataColumnStoreErrorCode, isFsNotFoundError} from "./errors.js";
+import type {IFlatFileStore} from "./interface.js";
+import {type FlatFileStoreMetrics, FlatFileStoreOperation, observeFlatFileStoreOperation} from "./metrics.js";
+import {assertValidRootHex, padSlot} from "./path.js";
+import {SlotIndex} from "./slotIndex.js";
+import {uncompress} from "./snappy.js";
+
+/**
+ * Filesystem storage for data columns, keyed by slot and block root.
+ * Hot and finalized data share the same layout. The top-level slot index is rebuilt on startup
+ * without inspecting the contents of slot directories.
+ * Per-slot mutation locking coordinates incremental writes, deletion, and pruning.
+ */
+export class FlatFileStore implements IFlatFileStore {
+  private readonly slotIndex = new SlotIndex();
+  private readonly mutationLocks = new Map<Slot, Promise<void>>();
+  private minRetainedSlot: Slot = 0;
+  private metrics: FlatFileStoreMetrics | null = null;
+
+  constructor(
+    private readonly dataColumnDir: string,
+    private readonly config: ChainForkConfig,
+    private readonly logger: Logger,
+    metrics: FlatFileStoreMetrics | null = null
+  ) {
+    this.setMetrics(metrics);
+  }
+
+  setMetrics(metrics: FlatFileStoreMetrics | null): void {
+    if (metrics === this.metrics) return;
+    this.metrics = metrics;
+    metrics?.slotIndexSize.addCollect((metric) => metric.set(this.slotIndex.size));
+  }
+
+  async init(): Promise<void> {
+    const endTimer = this.metrics?.startupDuration.startTimer();
+    try {
+      await mkdirDurable(this.dataColumnDir);
+      const stats = await this.slotIndex.rebuildFromDisk(this.dataColumnDir);
+      if (stats.ignoredEntries > 0) {
+        this.logger.warn("Ignored non-canonical flat file store entries", {
+          entries: stats.ignoredEntries,
+        });
+      }
+      this.logger.info("Flat file store initialized", {
+        slots: stats.slots,
+      });
+    } catch (e) {
+      this.metrics?.startupErrors.inc();
+      if (e instanceof DataColumnStoreError) {
+        throw e;
+      }
+      throw new DataColumnStoreError(
+        {code: DataColumnStoreErrorCode.STARTUP_FAILED},
+        "Flat file store initialization failed",
+        e
+      );
+    } finally {
+      endTimer?.();
+    }
+  }
+
+  async close(): Promise<void> {
+    // All operations are stateless file I/O.
+  }
+
+  async getDataColumns(slot: Slot, blockRoot: RootHex): Promise<DataColumnSidecar[]> {
+    return observeFlatFileStoreOperation(this.metrics, FlatFileStoreOperation.read, async () => {
+      const data = await this.readFile(slot, blockRoot);
+      if (!data) return [];
+
+      this.metrics?.readBytes.inc(data.length);
+      const header = parseDcolHeader(data);
+      validateDcolHeader(header, slot, blockRoot);
+      const columns = readAllColumns(data, header);
+      const dataColumnSidecarType = this.config.getForkTypes<ForkPostFulu>(slot).DataColumnSidecar;
+
+      return columns.map((col) => dataColumnSidecarType.deserialize(col.data));
+    });
+  }
+
+  async getDataColumnsBinary(
+    slot: Slot,
+    blockRoot: RootHex,
+    indices: number[]
+  ): Promise<(Uint8Array | undefined)[] | null> {
+    return observeFlatFileStoreOperation(this.metrics, FlatFileStoreOperation.read, () =>
+      this.getColumnsBinaryUninstrumented(slot, blockRoot, indices)
+    );
+  }
+
+  async putDataColumnsBinary(
+    slot: Slot,
+    blockRoot: RootHex,
+    columns: {index: number; data: Uint8Array}[]
+  ): Promise<void> {
+    const rootBytes = fromHex(blockRoot);
+    if (columns.length === 0) return;
+
+    await observeFlatFileStoreOperation(this.metrics, FlatFileStoreOperation.write, async () => {
+      const release = await this.acquireMutationLock(slot);
+      try {
+        if (slot < this.minRetainedSlot) {
+          throw new DataColumnStoreError(
+            {code: DataColumnStoreErrorCode.SLOT_PRUNED, slot, minRetainedSlot: this.minRetainedSlot},
+            `Cannot write pruned data column slot=${slot} minRetainedSlot=${this.minRetainedSlot}`
+          );
+        }
+        const existing = await this.readFile(slot, blockRoot);
+        let fileData: Uint8Array;
+
+        if (existing) {
+          this.metrics?.readBytes.inc(existing.length);
+          const header = parseDcolHeader(existing);
+          validateDcolHeader(header, slot, blockRoot);
+          fileData = mergeDcolColumns(existing, columns);
+        } else {
+          fileData = encodeDcolFile(rootBytes, slot, columns);
+        }
+
+        // The rename can succeed even if syncing its directory fails.
+        this.slotIndex.add(slot);
+        await atomicWrite(this.filePath(slot, blockRoot), fileData);
+        this.metrics?.writeBytes.inc(fileData.length);
+      } finally {
+        release();
+      }
+    });
+  }
+
+  async deleteMany(items: {slot: Slot; blockRoot: RootHex}[]): Promise<void> {
+    const results = await Promise.allSettled(items.map(({slot, blockRoot}) => this.delete(slot, blockRoot)));
+    const errors = results
+      .filter((result): result is PromiseRejectedResult => result.status === "rejected")
+      .map((result) => result.reason);
+    if (errors.length > 0) {
+      throw new DataColumnStoreError(
+        {code: DataColumnStoreErrorCode.BATCH_DELETE_FAILED, failures: errors.length},
+        "Failed to delete flat file data",
+        new AggregateError(errors)
+      );
+    }
+  }
+
+  async pruneBefore(minSlot: Slot): Promise<Slot[]> {
+    return observeFlatFileStoreOperation(this.metrics, FlatFileStoreOperation.prune, async () => {
+      this.minRetainedSlot = Math.max(this.minRetainedSlot, minSlot);
+      const slotsToPrune = new Set(this.slotIndex.getBefore(this.minRetainedSlot));
+      for (const slot of this.mutationLocks.keys()) {
+        if (slot < this.minRetainedSlot) slotsToPrune.add(slot);
+      }
+
+      for (const slot of slotsToPrune) {
+        const release = await this.acquireMutationLock(slot);
+        try {
+          await fs.promises.rm(path.join(this.dataColumnDir, padSlot(slot)), {recursive: true, force: true});
+          this.slotIndex.remove(slot);
+          this.metrics?.prunedDirectories.inc();
+        } finally {
+          release();
+        }
+      }
+      return [...slotsToPrune].sort((a, b) => a - b);
+    });
+  }
+
+  private filePath(slot: Slot, rootHex: RootHex): string {
+    assertValidRootHex(rootHex);
+    return path.join(this.dataColumnDir, padSlot(slot), `${rootHex}.dcol`);
+  }
+
+  private acquireMutationLock(slot: Slot): Promise<() => void> {
+    let release!: () => void;
+    const prev = this.mutationLocks.get(slot) ?? Promise.resolve();
+    const next = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const chained = prev.then(() => next);
+    this.mutationLocks.set(slot, chained);
+
+    return prev.then(() => {
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        release();
+        if (this.mutationLocks.get(slot) === chained) {
+          this.mutationLocks.delete(slot);
+        }
+      };
+    });
+  }
+
+  private async readFile(slot: Slot, rootHex: RootHex): Promise<Uint8Array | null> {
+    try {
+      return await fs.promises.readFile(this.filePath(slot, rootHex));
+    } catch (e) {
+      if (!isFsNotFoundError(e)) throw e;
+      return null;
+    }
+  }
+
+  private async getColumnsBinaryUninstrumented(
+    slot: Slot,
+    rootHex: RootHex,
+    indices: number[]
+  ): Promise<(Uint8Array | undefined)[] | null> {
+    let fd: fs.promises.FileHandle;
+    try {
+      fd = await fs.promises.open(this.filePath(slot, rootHex), "r");
+    } catch (e) {
+      if (!isFsNotFoundError(e)) throw e;
+      return null;
+    }
+
+    try {
+      const headerBuf = new Uint8Array(DCOL_HEADER_SIZE);
+      await readExactly(fd, headerBuf, 0);
+      this.metrics?.readBytes.inc(headerBuf.length);
+      const header = parseDcolHeader(headerBuf);
+      validateDcolHeader(header, slot, rootHex);
+
+      const N = totalBits(header.bitmap);
+      const tableSize = offsetTableSize(N);
+      const offsetTable = new Uint8Array(tableSize);
+      await readExactly(fd, offsetTable, DCOL_HEADER_SIZE);
+      this.metrics?.readBytes.inc(offsetTable.length);
+      const fileSize = (await fd.stat()).size;
+      const offsets = parseDcolOffsets(offsetTable, N, fileSize - DCOL_HEADER_SIZE - tableSize);
+
+      const results: (Uint8Array | undefined)[] = [];
+      for (const idx of indices) {
+        const range = getColumnByteRange(header, offsets, idx);
+        if (!range) {
+          results.push(undefined);
+          continue;
+        }
+        const buf = new Uint8Array(range.length);
+        await readExactly(fd, buf, range.offset);
+        this.metrics?.readBytes.inc(buf.length);
+        results.push(uncompress(buf));
+      }
+
+      return results;
+    } finally {
+      await fd.close();
+    }
+  }
+
+  private async delete(slot: Slot, rootHex: RootHex): Promise<void> {
+    await observeFlatFileStoreOperation(this.metrics, FlatFileStoreOperation.delete, async () => {
+      const release = await this.acquireMutationLock(slot);
+      try {
+        await fs.promises.rm(this.filePath(slot, rootHex), {force: true});
+      } finally {
+        release();
+      }
+    });
+  }
+}
+
+function validateDcolHeader(header: DcolHeader, slot: Slot, rootHex: RootHex): void {
+  if (header.slot !== slot) {
+    throw new DataColumnStoreError(
+      {code: DataColumnStoreErrorCode.SLOT_MISMATCH, headerSlot: header.slot, pathSlot: slot},
+      `Dcol slot mismatch: header=${header.slot} path=${slot}`
+    );
+  }
+  const headerRoot = toRootHex(header.blockRoot);
+  if (headerRoot !== rootHex) {
+    throw new DataColumnStoreError(
+      {code: DataColumnStoreErrorCode.ROOT_MISMATCH, headerRoot, pathRoot: rootHex},
+      `Dcol block root mismatch: header=${headerRoot} path=${rootHex}`
+    );
+  }
+}
+
+async function readExactly(fd: fs.promises.FileHandle, buffer: Uint8Array, position: number): Promise<void> {
+  let totalRead = 0;
+  while (totalRead < buffer.length) {
+    const {bytesRead} = await fd.read(buffer, totalRead, buffer.length - totalRead, position + totalRead);
+    if (bytesRead === 0) {
+      const offset = position + totalRead;
+      throw new DataColumnStoreError(
+        {code: DataColumnStoreErrorCode.UNEXPECTED_EOF, offset},
+        `Unexpected end of dcol file at offset ${offset}`
+      );
+    }
+    totalRead += bytesRead;
+  }
+}

package/src/db/flatFileStore/index.ts

@@ -0,0 +1,3 @@
+export {FlatFileStore} from "./flatFileStore.js";
+export type {IFlatFileStore} from "./interface.js";
+export type {FlatFileStoreMetrics} from "./metrics.js";

package/src/db/flatFileStore/interface.ts

@@ -0,0 +1,21 @@
+import {DataColumnSidecar, RootHex, Slot} from "@lodestar/types";
+
+/**
+ * Flat file storage interface for data columns.
+ *
+ * No hot/cold distinction — data is always keyed by (slot, blockRoot).
+ * All filesystem operations are crash-safe via atomic writes.
+ *
+ */
+export interface IFlatFileStore {
+  init(): Promise<void>;
+  close(): Promise<void>;
+
+  getDataColumns(slot: Slot, blockRoot: RootHex): Promise<DataColumnSidecar[]>;
+  /** Returns null if the file is absent, and undefined entries for columns missing from an existing file. */
+  getDataColumnsBinary(slot: Slot, blockRoot: RootHex, indices: number[]): Promise<(Uint8Array | undefined)[] | null>;
+  putDataColumnsBinary(slot: Slot, blockRoot: RootHex, columns: {index: number; data: Uint8Array}[]): Promise<void>;
+
+  deleteMany(items: {slot: Slot; blockRoot: RootHex}[]): Promise<void>;
+  pruneBefore(slot: Slot): Promise<Slot[]>;
+}

package/src/db/flatFileStore/metrics.ts

@@ -0,0 +1,48 @@
+import type {Counter, GaugeExtra, Histogram} from "@lodestar/utils";
+import {DataColumnStoreError, DataColumnStoreErrorCode} from "./errors.js";
+
+export const FlatFileStoreOperation = {
+  read: "read",
+  write: "write",
+  delete: "delete",
+  prune: "prune",
+} as const;
+
+export type FlatFileStoreOperation = (typeof FlatFileStoreOperation)[keyof typeof FlatFileStoreOperation];
+
+type OperationLabels = {operation: FlatFileStoreOperation};
+
+export type FlatFileStoreMetrics = {
+  operationDuration: Record<FlatFileStoreOperation, Histogram>;
+  operationErrors: Counter<OperationLabels>;
+  readBytes: Counter;
+  writeBytes: Counter;
+  prunedDirectories: Counter;
+  slotIndexSize: GaugeExtra;
+  startupDuration: Histogram;
+  startupErrors: Counter;
+};
+
+export async function observeFlatFileStoreOperation<T>(
+  metrics: FlatFileStoreMetrics | null,
+  operation: FlatFileStoreOperation,
+  fn: () => Promise<T>
+): Promise<T> {
+  const labels = {operation};
+  const endTimer = metrics?.operationDuration[operation].startTimer();
+  try {
+    return await fn();
+  } catch (e) {
+    metrics?.operationErrors.inc(labels);
+    if (e instanceof DataColumnStoreError) {
+      throw e;
+    }
+    throw new DataColumnStoreError(
+      {code: DataColumnStoreErrorCode.OPERATION_FAILED, operation},
+      `Flat file store ${operation} operation failed`,
+      e
+    );
+  } finally {
+    endTimer?.();
+  }
+}

package/src/db/flatFileStore/path.ts

@@ -0,0 +1,32 @@
+import type {RootHex} from "@lodestar/types";
+import {DataColumnStoreError, DataColumnStoreErrorCode} from "./errors.js";
+
+const ROOT_HEX_PATTERN = /^0x[0-9a-f]{64}$/;
+
+export function isValidRootHex(rootHex: string): rootHex is RootHex {
+  return ROOT_HEX_PATTERN.test(rootHex);
+}
+
+export function assertValidRootHex(rootHex: string): asserts rootHex is RootHex {
+  if (!isValidRootHex(rootHex)) {
+    throw new DataColumnStoreError(
+      {code: DataColumnStoreErrorCode.INVALID_ROOT, root: rootHex},
+      `Invalid flat file root: ${rootHex}`
+    );
+  }
+}
+
+/**
+ * Zero-pad a slot number to 12 digits for lexicographic ordering in directory names.
+ * Twelve digits covers many centuries of Ethereum; larger safe integers remain untruncated.
+ */
+export function padSlot(slot: number): string {
+  if (!Number.isSafeInteger(slot) || slot < 0) {
+    throw new DataColumnStoreError(
+      {code: DataColumnStoreErrorCode.INVALID_SLOT, slot},
+      `Invalid flat file slot: ${slot}`
+    );
+  }
+
+  return String(slot).padStart(12, "0");
+}

package/src/db/flatFileStore/slotIndex.ts

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import {Slot} from "@lodestar/types";
+import {isFsNotFoundError} from "./errors.js";
+import {padSlot} from "./path.js";
+
+export type SlotIndexRebuildStats = {
+  slots: number;
+  ignoredEntries: number;
+};
+
+export class SlotIndex {
+  private readonly slots = new Set<Slot>();
+
+  get size(): number {
+    return this.slots.size;
+  }
+
+  add(slot: Slot): void {
+    this.slots.add(slot);
+  }
+
+  remove(slot: Slot): void {
+    this.slots.delete(slot);
+  }
+
+  getBefore(minSlot: Slot): Slot[] {
+    const slots: Slot[] = [];
+    for (const slot of this.slots) {
+      if (slot < minSlot) slots.push(slot);
+    }
+    return slots;
+  }
+
+  async rebuildFromDisk(columnsDir: string): Promise<SlotIndexRebuildStats> {
+    this.slots.clear();
+    let entries: fs.Dirent[];
+    try {
+      entries = await fs.promises.readdir(columnsDir, {withFileTypes: true});
+    } catch (e) {
+      if (!isFsNotFoundError(e)) throw e;
+      return {slots: 0, ignoredEntries: 0};
+    }
+
+    let ignoredEntries = 0;
+    for (const entry of entries) {
+      const slot = Number(entry.name);
+      if (!entry.isDirectory() || !Number.isSafeInteger(slot) || slot < 0 || entry.name !== padSlot(slot)) {
+        ignoredEntries++;
+        continue;
+      }
+      this.slots.add(slot);
+    }
+
+    return {slots: this.slots.size, ignoredEntries};
+  }
+}

package/src/db/flatFileStore/snappy.ts

@@ -0,0 +1,14 @@
+import {compressSync, uncompressSync} from "snappy";
+
+export function compress(data: Uint8Array): Uint8Array {
+  return compressSync(toBuffer(data));
+}
+
+export function uncompress(data: Uint8Array): Uint8Array {
+  const result = uncompressSync(toBuffer(data), {asBuffer: true}) as Buffer;
+  return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+
+function toBuffer(data: Uint8Array): Buffer {
+  return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+}

package/src/db/index.ts

@@ -1,3 +1,4 @@
 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,4 +1,7 @@
 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,
@@ -59,6 +62,11 @@ 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>;
@@ -66,5 +74,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): void;
+  setMetrics(metrics: LevelDbControllerMetrics, flatFileStoreMetrics?: FlatFileStoreMetrics | null): void;
 }