@lodestar/beacon-node 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/db/repositories/blockArchive.ts

@@ -1,170 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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));
-  }
-}