feat: update backfill related db repositories

packages/beacon-node/src/db/buckets.ts

@@ -51,7 +51,7 @@ export enum Bucket {
   // altair_lightClientSyncCommitteeProof = 35, // DEPRECATED on v0.32.0
   // index_lightClientInitProof = 36, // DEPRECATED on v0.32.0
 
-  backfilled_ranges = 42, // Backfilled From to To, inclusive of both From, To
+  backfill_state = 42, // stores Epoch -> EpochBackfillState data and backfill range singleton object
 
   // Buckets to support LightClient server v2
   lightClient_syncCommitteeWitness = 51, // BlockRoot -> SyncCommitteeWitness

packages/beacon-node/src/db/repositories/backfillState.ts

@@ -0,0 +1,79 @@
+import {ContainerType, ListBasicType, ValueOf} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {DatabaseController, Repository} from "@lodestar/db";
+import {ForkName, NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
+import {Epoch, ssz} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+import {BACKFILL_RANGE_KEY} from "../single/backfillRange.js";
+
+export const epochBackfillStateSSZ = new ContainerType(
+  {
+    hasBlock: ssz.Boolean,
+    hasBlobs: ssz.Boolean,
+    columnIndices: new ListBasicType(ssz.ColumnIndex, NUMBER_OF_COLUMNS),
+  },
+  {typeName: "EpochBackfillState", jsonCase: "eth2"}
+);
+export type EpochBackfillStateWrapper = ValueOf<typeof epochBackfillStateSSZ>;
+export type EpochBackfillState = {
+  hasBlock: boolean;
+  hasBlobs: boolean | null;
+  columnIndices: number[] | null;
+};
+
+export class BackfillState extends Repository<Epoch, EpochBackfillStateWrapper> {
+  constructor(config: ChainForkConfig, db: DatabaseController<Uint8Array, Uint8Array>) {
+    const bucket = Bucket.backfill_state;
+    super(config, db, bucket, epochBackfillStateSSZ, getBucketNameByValue(bucket));
+  }
+
+  encodeKey(key: Epoch): Uint8Array {
+    if (key === BACKFILL_RANGE_KEY) {
+      throw new Error("Reserved key for backfill range singleton object");
+    }
+    return super.encodeKey(key);
+  }
+
+  decodeKey(data: Uint8Array): number {
+    return bytesToInt(super.decodeKey(data) as unknown as Uint8Array, "be");
+  }
+
+  async _get(epoch: Epoch): Promise<EpochBackfillState | null> {
+    const wrappedValue = await super.get(epoch);
+    if (!wrappedValue) return null;
+    return this.unwrapEpochBackfillState(wrappedValue, epoch);
+  }
+
+  async _put(epoch: Epoch, value: EpochBackfillState): Promise<void> {
+    const wrappedValue = this.wrapEpochBackfillState(value);
+    await super.put(epoch, wrappedValue);
+  }
+
+  private unwrapEpochBackfillState(value: EpochBackfillStateWrapper, epoch: Epoch): EpochBackfillState {
+    const fork = this.config.getForkName(computeStartSlotAtEpoch(epoch));
+    return {
+      hasBlock: value.hasBlock,
+      hasBlobs: this.shouldIncludeBlobs(fork) ? value.hasBlobs : null,
+      columnIndices: this.shouldIncludeCustodyColumns(fork) ? value.columnIndices : null,
+    };
+  }
+
+  private wrapEpochBackfillState(value: EpochBackfillState): EpochBackfillStateWrapper {
+    return {
+      hasBlock: value.hasBlock,
+      // Using default values for fields that don't exist in the fork at the epoch
+      hasBlobs: value.hasBlobs ?? false,
+      columnIndices: value.columnIndices ?? [],
+    };
+  }
+
+  private shouldIncludeBlobs(fork: ForkName): boolean {
+    return fork >= ForkName.deneb;
+  }
+
+  private shouldIncludeCustodyColumns(fork: ForkName): boolean {
+    return fork >= ForkName.fulu;
+  }
+}

packages/beacon-node/src/db/repositories/index.ts

@@ -18,5 +18,5 @@ export {BestLightClientUpdateRepository} from "./lightclientBestUpdate.js";
 export {CheckpointHeaderRepository} from "./lightclientCheckpointHeader.js";
 export {SyncCommitteeRepository} from "./lightclientSyncCommittee.js";
 export {SyncCommitteeWitnessRepository} from "./lightclientSyncCommitteeWitness.js";
-export {BackfilledRanges} from "./backfilledRanges.js";
+export {BackfillState} from "./backfillState.js";
 export {BLSToExecutionChangeRepository} from "./blsToExecutionChange.js";

packages/beacon-node/src/db/single/backfillRange.ts

@@ -0,0 +1,47 @@
+import {ContainerType, Type, ValueOf} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, DbReqOpts, encodeKey as _encodeKey} from "@lodestar/db";
+import {ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export const backfillRangeSSZ = new ContainerType(
+  {
+    beginningEpoch: ssz.Epoch,
+    endingEpoch: ssz.Epoch,
+  },
+  {typeName: "BackfillRange", jsonCase: "eth2"}
+);
+export type BackfillRangeWrapper = ValueOf<typeof backfillRangeSSZ>;
+
+// unique & practically impossible key to store BackfillRange inside 'backfill_state'
+// bucket which stores Epoch -> EpochBackfillState key value pairs
+export const BACKFILL_RANGE_KEY = -1;
+
+export class BackfillRange {
+  private readonly bucket: Bucket;
+  private readonly db: Db;
+  private readonly dbReqOpts: DbReqOpts; // to record metrics
+  private readonly key: Uint8Array;
+  private readonly type: Type<BackfillRangeWrapper>;
+
+  constructor(_config: ChainForkConfig, db: Db) {
+    this.db = db;
+    this.bucket = Bucket.backfill_state;
+    this.key = _encodeKey(this.bucket, BACKFILL_RANGE_KEY);
+    this.type = backfillRangeSSZ;
+    this.dbReqOpts = {bucketId: getBucketNameByValue(this.bucket)};
+  }
+
+  async put(value: BackfillRangeWrapper): Promise<void> {
+    await this.db.put(this.key, this.type.serialize(value), this.dbReqOpts);
+  }
+
+  async get(): Promise<BackfillRangeWrapper | null> {
+    const value = await this.db.get(this.key, this.dbReqOpts);
+    return value ? this.type.deserialize(value) : null;
+  }
+
+  async delete(): Promise<void> {
+    await this.db.delete(this.key, this.dbReqOpts);
+  }
+}

packages/beacon-node/src/db/single/index.ts

@@ -1,2 +1,3 @@
+export {BackfillRange} from "./backfillRange.js";
 export {PreGenesisState} from "./preGenesisState.js";
 export {PreGenesisStateLastProcessedBlock} from "./preGenesisStateLastProcessedBlock.js";