@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/db/repositories/blockArchive.ts

@@ -0,0 +1,170 @@
+import all from "it-all";
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, FilterOptions, KeyValue, Repository} from "@lodestar/db";
+import {Root, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
+import {getSignedBlockTypeFromBytes} from "../../util/multifork.js";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+import {
+  deleteParentRootIndex,
+  deleteRootIndex,
+  getParentRootIndex,
+  getRootIndex,
+  storeParentRootIndex,
+  storeRootIndex,
+} from "./blockArchiveIndex.js";
+
+export interface BlockFilterOptions extends FilterOptions<Slot> {
+  step?: number;
+}
+
+export type BlockArchiveBatchPutBinaryItem = KeyValue<Slot, Uint8Array> & {
+  slot: Slot;
+  blockRoot: Root;
+  parentRoot: Root;
+};
+
+/**
+ * Stores finalized blocks. Block slot is identifier.
+ */
+export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.allForks_blockArchive;
+    const type = ssz.phase0.SignedBeaconBlock; // Pick some type but won't be used
+    super(config, db, bucket, type, getBucketNameByValue(bucket));
+  }
+
+  // Overrides for multi-fork
+
+  encodeValue(value: SignedBeaconBlock): Uint8Array {
+    return this.config.getForkTypes(value.message.slot).SignedBeaconBlock.serialize(value);
+  }
+
+  decodeValue(data: Uint8Array): SignedBeaconBlock {
+    return getSignedBlockTypeFromBytes(this.config, data).deserialize(data);
+  }
+
+  // Handle key as slot
+
+  getId(value: SignedBeaconBlock): Slot {
+    return value.message.slot;
+  }
+
+  decodeKey(data: Uint8Array): number {
+    return bytesToInt(super.decodeKey(data) as unknown as Uint8Array, "be");
+  }
+
+  // Overrides to index
+
+  async put(key: Slot, value: SignedBeaconBlock): Promise<void> {
+    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 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 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> {
+    await Promise.all([
+      super.remove(value),
+      deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).SignedBeaconBlock, value),
+      deleteParentRootIndex(this.db, value),
+    ]);
+  }
+
+  async batchRemove(values: SignedBeaconBlock[]): Promise<void> {
+    await Promise.all([
+      super.batchRemove(values),
+      Array.from(values).map((value) =>
+        deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).SignedBeaconBlock, value)
+      ),
+      Array.from(values).map((value) => deleteParentRootIndex(this.db, value)),
+    ]);
+  }
+
+  async *valuesStream(opts?: BlockFilterOptions): AsyncIterable<SignedBeaconBlock> {
+    const firstSlot = this.getFirstSlot(opts);
+    const valuesStream = super.valuesStream(opts);
+    const step = opts?.step ?? 1;
+
+    for await (const value of valuesStream) {
+      if ((value.message.slot - firstSlot) % step === 0) {
+        yield value;
+      }
+    }
+  }
+
+  async values(opts?: BlockFilterOptions): Promise<SignedBeaconBlock[]> {
+    return all(this.valuesStream(opts));
+  }
+
+  // INDEX
+
+  async getByRoot(root: Root): Promise<SignedBeaconBlock | null> {
+    const slot = await this.getSlotByRoot(root);
+    return slot !== null ? this.get(slot) : null;
+  }
+
+  async getBinaryEntryByRoot(root: Root): Promise<KeyValue<Slot, Buffer> | null> {
+    const slot = await this.getSlotByRoot(root);
+    return slot !== null ? ({key: slot, value: await this.getBinary(slot)} as KeyValue<Slot, Buffer>) : null;
+  }
+
+  async getByParentRoot(root: Root): Promise<SignedBeaconBlock | null> {
+    const slot = await this.getSlotByParentRoot(root);
+    return slot !== null ? this.get(slot) : null;
+  }
+
+  async getSlotByRoot(root: Root): Promise<Slot | null> {
+    return this.parseSlot(await getRootIndex(this.db, root));
+  }
+
+  async getSlotByParentRoot(root: Root): Promise<Slot | null> {
+    return this.parseSlot(await getParentRootIndex(this.db, root));
+  }
+
+  private parseSlot(slotBytes: Uint8Array | null): Slot | null {
+    if (!slotBytes) return null;
+    const slot = bytesToInt(slotBytes, "be");
+    // TODO: Is this necessary? How can bytesToInt return a non-integer?
+    return Number.isInteger(slot) ? slot : null;
+  }
+
+  private getFirstSlot(opts?: BlockFilterOptions): Slot {
+    const dbFilterOpts = this.dbFilterOptions(opts);
+    const firstSlot = dbFilterOpts.gt
+      ? this.decodeKey(dbFilterOpts.gt) + 1
+      : dbFilterOpts.gte
+        ? this.decodeKey(dbFilterOpts.gte)
+        : null;
+    if (firstSlot === null) throw Error("specify opts.gt or opts.gte");
+
+    return firstSlot;
+  }
+}

package/src/db/repositories/blockArchiveIndex.ts

@@ -0,0 +1,45 @@
+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);
+export const parentRootIndexBucketId = getBucketNameByValue(Bucket.index_blockArchiveParentRootIndex);
+
+export async function getRootIndex(db: Db, blockRoot: Root): Promise<Uint8Array | null> {
+  return db.get(getRootIndexKey(blockRoot), {bucketId: rootIndexBucketId});
+}
+
+export async function getParentRootIndex(db: Db, parentRoot: Root): Promise<Uint8Array | null> {
+  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">,
+  block: SignedBeaconBlock
+): Promise<void> {
+  const beaconBlockType = (signedBeaconBlockType as typeof ssz.phase0.SignedBeaconBlock).fields.message;
+  return db.delete(getRootIndexKey(beaconBlockType.hashTreeRoot(block.message)), {bucketId: rootIndexBucketId});
+}
+
+export async function deleteParentRootIndex(db: Db, block: SignedBeaconBlock): Promise<void> {
+  return db.delete(getParentRootIndexKey(block.message.parentRoot), {bucketId: parentRootIndexBucketId});
+}
+
+export function getParentRootIndexKey(parentRoot: Root): Uint8Array {
+  return encodeKey(Bucket.index_blockArchiveParentRootIndex, parentRoot);
+}
+
+export function getRootIndexKey(root: Root): Uint8Array {
+  return encodeKey(Bucket.index_blockArchiveRootIndex, root);
+}

package/src/db/repositories/blsToExecutionChange.ts

@@ -0,0 +1,16 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {ValidatorIndex} from "@lodestar/types";
+import {SignedBLSToExecutionChangeVersioned, signedBLSToExecutionChangeVersionedType} from "../../util/types.js";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export class BLSToExecutionChangeRepository extends Repository<ValidatorIndex, SignedBLSToExecutionChangeVersioned> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.capella_blsToExecutionChange;
+    super(config, db, bucket, signedBLSToExecutionChangeVersionedType, getBucketNameByValue(bucket));
+  }
+
+  getId(value: SignedBLSToExecutionChangeVersioned): ValidatorIndex {
+    return value.data.message.validatorIndex;
+  }
+}

package/src/db/repositories/checkpointState.ts

@@ -0,0 +1,31 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {BeaconStateAllForks} from "@lodestar/state-transition";
+import {ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+/**
+ * Store temporary checkpoint states.
+ * We should only put/get binary data from this repository, consumer will load it into an existing state ViewDU object.
+ */
+export class CheckpointStateRepository extends Repository<Uint8Array, BeaconStateAllForks> {
+  constructor(config: ChainForkConfig, db: Db) {
+    // Pick some type but won't be used. Casted to any because no type can match `BeaconStateAllForks`
+    const type = ssz.phase0.BeaconState;
+    const bucket = Bucket.allForks_checkpointState;
+    // biome-ignore lint/suspicious/noExplicitAny: The type is complex to specify a proper override
+    super(config, db, bucket, type as any, getBucketNameByValue(bucket));
+  }
+
+  getId(): Uint8Array {
+    throw Error("CheckpointStateRepository does not work with value");
+  }
+
+  encodeValue(): Uint8Array {
+    throw Error("CheckpointStateRepository does not work with value");
+  }
+
+  decodeValue(): BeaconStateAllForks {
+    throw Error("CheckpointStateRepository does not work with value");
+  }
+}

package/src/db/repositories/dataColumnSidecar.ts

@@ -0,0 +1,49 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, PrefixedRepository, decodeNumberForDbKey, encodeNumberForDbKey} from "@lodestar/db";
+import {NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {ColumnIndex, Root, fulu, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+const COLUMN_INDEX_BYTE_SIZE = 2;
+const BLOCK_ROOT_BYTE_SIZE = 32;
+
+type BlockRoot = Root;
+
+/**
+ * DataColumnSidecarsRepository
+ * Used to store `unfinalized` DataColumnSidecars
+ *
+ * Indexed data by `blockRoot` + `columnIndex`
+ */
+export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, ColumnIndex, fulu.DataColumnSidecar> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.fulu_dataColumnSidecars;
+    super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
+  }
+
+  /**
+   * Id is hashTreeRoot of unsigned BeaconBlock
+   */
+  getId(value: fulu.DataColumnSidecar): ColumnIndex {
+    return value.index;
+  }
+
+  encodeKeyRaw(prefix: BlockRoot, id: ColumnIndex): Uint8Array {
+    return Buffer.concat([prefix, encodeNumberForDbKey(id, COLUMN_INDEX_BYTE_SIZE)]);
+  }
+
+  decodeKeyRaw(raw: Uint8Array): {prefix: BlockRoot; id: ColumnIndex} {
+    return {
+      prefix: raw.slice(0, BLOCK_ROOT_BYTE_SIZE) as BlockRoot,
+      id: decodeNumberForDbKey(raw.slice(BLOCK_ROOT_BYTE_SIZE), COLUMN_INDEX_BYTE_SIZE) as ColumnIndex,
+    };
+  }
+
+  getMaxKeyRaw(prefix: BlockRoot): Uint8Array {
+    return Buffer.concat([prefix, encodeNumberForDbKey(NUMBER_OF_COLUMNS - 1, COLUMN_INDEX_BYTE_SIZE)]);
+  }
+
+  getMinKeyRaw(prefix: BlockRoot): Uint8Array {
+    return Buffer.concat([prefix, encodeNumberForDbKey(0, COLUMN_INDEX_BYTE_SIZE)]);
+  }
+}

package/src/db/repositories/dataColumnSidecarArchive.ts

@@ -0,0 +1,56 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, PrefixedRepository, decodeNumberForDbKey, encodeNumberForDbKey} from "@lodestar/db";
+import {NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {ColumnIndex, Slot, fulu, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+const COLUMN_INDEX_BYTE_SIZE = 2;
+const SLOT_BYTE_SIZE = 8;
+
+/**
+ * DataColumnSidecarsRepository
+ * Used to store `finalized` DataColumnSidecars
+ *
+ * Indexed data by `slot` + `columnIndex`
+ */
+export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot, ColumnIndex, fulu.DataColumnSidecar> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.fulu_dataColumnSidecarsArchive;
+    super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
+  }
+
+  /**
+   * Id is hashTreeRoot of unsigned BeaconBlock
+   */
+  getId(value: fulu.DataColumnSidecar): ColumnIndex {
+    return value.index;
+  }
+
+  encodeKeyRaw(prefix: Slot, id: ColumnIndex): Uint8Array {
+    return Buffer.concat([
+      encodeNumberForDbKey(prefix, SLOT_BYTE_SIZE),
+      encodeNumberForDbKey(id, COLUMN_INDEX_BYTE_SIZE),
+    ]);
+  }
+
+  decodeKeyRaw(raw: Uint8Array): {prefix: Slot; id: ColumnIndex} {
+    return {
+      prefix: decodeNumberForDbKey(raw, SLOT_BYTE_SIZE) as Slot,
+      id: decodeNumberForDbKey(raw.slice(SLOT_BYTE_SIZE), COLUMN_INDEX_BYTE_SIZE) as ColumnIndex,
+    };
+  }
+
+  getMaxKeyRaw(prefix: Slot): Uint8Array {
+    return Buffer.concat([
+      encodeNumberForDbKey(prefix, SLOT_BYTE_SIZE),
+      encodeNumberForDbKey(NUMBER_OF_COLUMNS - 1, COLUMN_INDEX_BYTE_SIZE),
+    ]);
+  }
+
+  getMinKeyRaw(prefix: Slot): Uint8Array {
+    return Buffer.concat([
+      encodeNumberForDbKey(prefix, SLOT_BYTE_SIZE),
+      encodeNumberForDbKey(0, COLUMN_INDEX_BYTE_SIZE),
+    ]);
+  }
+}

package/src/db/repositories/depositDataRoot.ts

@@ -0,0 +1,80 @@
+import {ByteVectorType, CompositeViewDU, ListCompositeType} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, KeyValue, Repository} from "@lodestar/db";
+import {Root, ssz} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+// TODO: Review where is best to put this type
+export type DepositTree = CompositeViewDU<ListCompositeType<ByteVectorType>>;
+
+export class DepositDataRootRepository extends Repository<number, Root> {
+  private depositRootTree?: DepositTree;
+
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.index_depositDataRoot;
+    super(config, db, bucket, ssz.Root, getBucketNameByValue(bucket));
+  }
+
+  decodeKey(data: Buffer): number {
+    return bytesToInt(super.decodeKey(data) as unknown as Uint8Array, "be");
+  }
+
+  // depositDataRoots stored by depositData index
+  getId(_value: Root): number {
+    throw new Error("Unable to create depositIndex from root");
+  }
+
+  async put(index: number, value: Root): Promise<void> {
+    await super.put(index, value);
+    await this.depositRootTreeSet(index, value);
+  }
+
+  async batchPut(items: KeyValue<number, Root>[]): Promise<void> {
+    await super.batchPut(items);
+    for (const {key, value} of items) {
+      await this.depositRootTreeSet(key, value);
+    }
+  }
+
+  async putList(roots: Root[]): Promise<void> {
+    await this.batchPut(roots.map((root, index) => ({key: index, value: root})));
+  }
+
+  async batchPutValues(values: {index: number; root: Root}[]): Promise<void> {
+    await this.batchPut(
+      values.map(({index, root}) => ({
+        key: index,
+        value: root,
+      }))
+    );
+  }
+
+  async getDepositRootTree(): Promise<DepositTree> {
+    if (!this.depositRootTree) {
+      const values = await this.values();
+      this.depositRootTree = ssz.phase0.DepositDataRootList.toViewDU(values);
+    }
+    return this.depositRootTree;
+  }
+
+  async getDepositRootTreeAtIndex(depositIndex: number): Promise<DepositTree> {
+    const depositRootTree = await this.getDepositRootTree();
+    return depositRootTree.sliceTo(depositIndex);
+  }
+
+  private async depositRootTreeSet(index: number, value: Uint8Array): Promise<void> {
+    const depositRootTree = await this.getDepositRootTree();
+
+    // TODO: Review and fix properly
+    if (index > depositRootTree.length) {
+      throw Error(`Error setting depositRootTree index ${index} > length ${depositRootTree.length}`);
+    }
+
+    if (index === depositRootTree.length) {
+      depositRootTree.push(value);
+    } else {
+      depositRootTree.set(index, value);
+    }
+  }
+}

package/src/db/repositories/depositEvent.ts

@@ -0,0 +1,32 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {phase0, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+/**
+ * DepositData indexed by deposit index
+ * Removed when included on chain or old
+ */
+export class DepositEventRepository extends Repository<number, phase0.DepositEvent> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.phase0_depositEvent;
+    super(config, db, bucket, ssz.phase0.DepositEvent, getBucketNameByValue(bucket));
+  }
+
+  async deleteOld(depositCount: number): Promise<void> {
+    const firstDepositIndex = await this.firstKey();
+    if (firstDepositIndex === null) {
+      return;
+    }
+    await this.batchDelete(Array.from({length: depositCount - firstDepositIndex}, (_, i) => i + firstDepositIndex));
+  }
+
+  async batchPutValues(depositEvents: phase0.DepositEvent[]): Promise<void> {
+    await this.batchPut(
+      depositEvents.map((depositEvent) => ({
+        key: depositEvent.index,
+        value: depositEvent,
+      }))
+    );
+  }
+}

package/src/db/repositories/eth1Data.ts

@@ -0,0 +1,33 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {phase0, ssz} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export class Eth1DataRepository extends Repository<number, phase0.Eth1DataOrdered> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.phase0_eth1Data;
+    super(config, db, bucket, ssz.phase0.Eth1DataOrdered, getBucketNameByValue(bucket));
+  }
+
+  decodeKey(data: Buffer): number {
+    return bytesToInt(super.decodeKey(data) as unknown as Uint8Array, "be");
+  }
+
+  getId(_value: phase0.Eth1Data): number {
+    throw new Error("Unable to create timestamp from block hash");
+  }
+
+  async batchPutValues(eth1Datas: (phase0.Eth1DataOrdered & {timestamp: number})[]): Promise<void> {
+    await this.batchPut(
+      eth1Datas.map((eth1Data) => ({
+        key: eth1Data.timestamp,
+        value: eth1Data,
+      }))
+    );
+  }
+
+  async deleteOld(timestamp: number): Promise<void> {
+    await this.batchDelete(await this.keys({lt: timestamp}));
+  }
+}

package/src/db/repositories/index.ts

@@ -0,0 +1,20 @@
+export {AttesterSlashingRepository} from "./attesterSlashing.js";
+export {BackfilledRanges} from "./backfilledRanges.js";
+export {BlobSidecarsRepository} from "./blobSidecars.js";
+export {BlobSidecarsArchiveRepository} from "./blobSidecarsArchive.js";
+export {BlockRepository} from "./block.js";
+export type {BlockArchiveBatchPutBinaryItem, BlockFilterOptions} from "./blockArchive.js";
+export {BlockArchiveRepository} from "./blockArchive.js";
+export {BLSToExecutionChangeRepository} from "./blsToExecutionChange.js";
+export {DataColumnSidecarRepository} from "./dataColumnSidecar.js";
+export {DataColumnSidecarArchiveRepository} from "./dataColumnSidecarArchive.js";
+export {DepositDataRootRepository} from "./depositDataRoot.js";
+export {DepositEventRepository} from "./depositEvent.js";
+export {Eth1DataRepository} from "./eth1Data.js";
+export {BestLightClientUpdateRepository} from "./lightclientBestUpdate.js";
+export {CheckpointHeaderRepository} from "./lightclientCheckpointHeader.js";
+export {SyncCommitteeRepository} from "./lightclientSyncCommittee.js";
+export {SyncCommitteeWitnessRepository} from "./lightclientSyncCommitteeWitness.js";
+export {ProposerSlashingRepository} from "./proposerSlashing.js";
+export {StateArchiveRepository} from "./stateArchive.js";
+export {VoluntaryExitRepository} from "./voluntaryExit.js";

package/src/db/repositories/lightclientBestUpdate.ts

@@ -0,0 +1,41 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {DatabaseController, Repository} from "@lodestar/db";
+import {LightClientUpdate, SyncPeriod, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+const SLOT_BYTE_COUNT = 8;
+
+/**
+ * Best PartialLightClientUpdate in each SyncPeriod
+ *
+ * Used to prepare light client updates
+ */
+export class BestLightClientUpdateRepository extends Repository<SyncPeriod, LightClientUpdate> {
+  constructor(config: ChainForkConfig, db: DatabaseController<Uint8Array, Uint8Array>) {
+    // Pick some type but won't be used
+    const bucket = Bucket.lightClient_bestLightClientUpdate;
+    super(config, db, bucket, ssz.altair.LightClientUpdate, getBucketNameByValue(bucket));
+  }
+
+  // Overrides for multi-fork
+  encodeValue(value: LightClientUpdate): Uint8Array {
+    // Not easy to have a fixed slot position for all forks in attested header, so lets
+    // prefix by attestedHeader's slot bytes
+    const slotBytes = ssz.Slot.serialize(value.attestedHeader.beacon.slot);
+    const valueBytes = this.config
+      .getPostAltairForkTypes(value.attestedHeader.beacon.slot)
+      .LightClientUpdate.serialize(value);
+
+    const prefixedData = new Uint8Array(SLOT_BYTE_COUNT + valueBytes.length);
+    prefixedData.set(slotBytes, 0);
+    prefixedData.set(valueBytes, SLOT_BYTE_COUNT);
+
+    return prefixedData;
+  }
+
+  decodeValue(data: Uint8Array): LightClientUpdate {
+    // First slot is written
+    const slot = ssz.Slot.deserialize(data.subarray(0, SLOT_BYTE_COUNT));
+    return this.config.getPostAltairForkTypes(slot).LightClientUpdate.deserialize(data.subarray(SLOT_BYTE_COUNT));
+  }
+}

package/src/db/repositories/lightclientCheckpointHeader.ts

@@ -0,0 +1,32 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {DatabaseController, Repository} from "@lodestar/db";
+import {LightClientHeader, ssz} from "@lodestar/types";
+import {getLightClientHeaderTypeFromBytes} from "../../util/multifork.js";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+/**
+ * Block headers by block root. Until finality includes all headers seen by this node. After finality,
+ * all non-checkpoint headers are pruned from this repository.
+ *
+ * Used to prepare light client updates
+ */
+export class CheckpointHeaderRepository extends Repository<Uint8Array, LightClientHeader> {
+  constructor(config: ChainForkConfig, db: DatabaseController<Uint8Array, Uint8Array>) {
+    // Pick some type but won't be used
+    const bucket = Bucket.lightClient_checkpointHeader;
+    super(config, db, bucket, ssz.altair.LightClientHeader, getBucketNameByValue(bucket));
+  }
+
+  // Overrides for multi-fork
+  encodeValue(value: LightClientHeader): Uint8Array {
+    return this.config.getPostAltairForkTypes(value.beacon.slot).LightClientHeader.serialize(value);
+  }
+
+  decodeValue(data: Uint8Array): LightClientHeader {
+    return getLightClientHeaderTypeFromBytes(this.config, data).deserialize(data);
+  }
+
+  getId(value: LightClientHeader): Uint8Array {
+    return this.config.getPostAltairForkTypes(value.beacon.slot).LightClientHeader.hashTreeRoot(value);
+  }
+}

package/src/db/repositories/lightclientSyncCommittee.ts

@@ -0,0 +1,16 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {DatabaseController, Repository} from "@lodestar/db";
+import {altair, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+/**
+ * Historical sync committees by SyncCommittee hash tree root
+ *
+ * Used to prepare lightclient updates and initial snapshots
+ */
+export class SyncCommitteeRepository extends Repository<Uint8Array, altair.SyncCommittee> {
+  constructor(config: ChainForkConfig, db: DatabaseController<Uint8Array, Uint8Array>) {
+    const bucket = Bucket.lightClient_syncCommittee;
+    super(config, db, bucket, ssz.altair.SyncCommittee, getBucketNameByValue(bucket));
+  }
+}