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

package/src/db/repositories/lightclientSyncCommitteeWitness.ts

@@ -0,0 +1,77 @@
+import {ContainerType, VectorCompositeType} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {DatabaseController, Repository} from "@lodestar/db";
+import {ssz} from "@lodestar/types";
+import {SyncCommitteeWitness} from "../../chain/lightClient/types.js";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+// We add a 1-byte prefix where 0 means pre-electra and 1 means post-electra
+enum PrefixByte {
+  PRE_ELECTRA = 0,
+  POST_ELECTRA = 1,
+}
+
+export const NUM_WITNESS = 4;
+export const NUM_WITNESS_ELECTRA = 5;
+
+/**
+ * Historical sync committees witness by block root
+ *
+ * Used to prepare lightclient updates and initial snapshots
+ */
+export class SyncCommitteeWitnessRepository extends Repository<Uint8Array, SyncCommitteeWitness> {
+  constructor(config: ChainForkConfig, db: DatabaseController<Uint8Array, Uint8Array>) {
+    const bucket = Bucket.lightClient_syncCommitteeWitness;
+    // Pick some type but won't be used. Witness can be 4 or 5 so need to handle dynamically
+    const type = new ContainerType({
+      witness: new VectorCompositeType(ssz.Root, NUM_WITNESS),
+      currentSyncCommitteeRoot: ssz.Root,
+      nextSyncCommitteeRoot: ssz.Root,
+    });
+
+    super(config, db, bucket, type, getBucketNameByValue(bucket));
+  }
+
+  // Overrides for multi-fork
+  encodeValue(value: SyncCommitteeWitness): Uint8Array {
+    const numWitness = value.witness.length;
+
+    if (numWitness !== NUM_WITNESS && numWitness !== NUM_WITNESS_ELECTRA) {
+      throw Error(`Number of witness can only be 4 pre-electra or 5 post-electra numWitness=${numWitness}`);
+    }
+
+    const type = new ContainerType({
+      witness: new VectorCompositeType(ssz.Root, numWitness),
+      currentSyncCommitteeRoot: ssz.Root,
+      nextSyncCommitteeRoot: ssz.Root,
+    });
+
+    const valueBytes = type.serialize(value);
+
+    // We need to differentiate between post-electra and pre-electra witness
+    // such that we can deserialize correctly
+    const isPostElectra = numWitness === NUM_WITNESS_ELECTRA;
+    const prefixByte = new Uint8Array(1);
+    prefixByte[0] = isPostElectra ? PrefixByte.POST_ELECTRA : PrefixByte.PRE_ELECTRA;
+
+    const prefixedData = new Uint8Array(1 + valueBytes.length);
+    prefixedData.set(prefixByte, 0);
+    prefixedData.set(valueBytes, 1);
+
+    return prefixedData;
+  }
+
+  decodeValue(data: Uint8Array): SyncCommitteeWitness {
+    // First byte is written
+    const prefix = data.subarray(0, 1);
+    const isPostElectra = prefix[0] === PrefixByte.POST_ELECTRA;
+
+    const type = new ContainerType({
+      witness: new VectorCompositeType(ssz.Root, isPostElectra ? NUM_WITNESS_ELECTRA : NUM_WITNESS),
+      currentSyncCommitteeRoot: ssz.Root,
+      nextSyncCommitteeRoot: ssz.Root,
+    });
+
+    return type.deserialize(data.subarray(1));
+  }
+}

package/src/db/repositories/proposerSlashing.ts

@@ -0,0 +1,15 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {ValidatorIndex, phase0, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export class ProposerSlashingRepository extends Repository<ValidatorIndex, phase0.ProposerSlashing> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.phase0_proposerSlashing;
+    super(config, db, bucket, ssz.phase0.ProposerSlashing, getBucketNameByValue(bucket));
+  }
+
+  getId(value: phase0.ProposerSlashing): ValidatorIndex {
+    return value.signedHeader1.message.proposerIndex;
+  }
+}

package/src/db/repositories/stateArchive.ts

@@ -0,0 +1,69 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {BeaconStateAllForks} from "@lodestar/state-transition";
+import {Epoch, Root, RootHex, Slot, ssz} from "@lodestar/types";
+import {bytesToInt, toHex} from "@lodestar/utils";
+import {getStateTypeFromBytes} from "../../util/multifork.js";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+import {getRootIndex, getRootIndexKey, storeRootIndex} from "./stateArchiveIndex.js";
+
+export class StateArchiveRepository extends Repository<Slot, BeaconStateAllForks> {
+  constructor(config: ChainForkConfig, db: Db) {
+    // Pick some type but won't be used. Casted to any because no type can match `BeaconStateAllForks`
+    // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+    const type = ssz.phase0.BeaconState as any;
+    const bucket = Bucket.allForks_stateArchive;
+    super(config, db, bucket, type, getBucketNameByValue(bucket));
+  }
+
+  // Overrides for multi-fork
+
+  encodeValue(value: BeaconStateAllForks): Uint8Array {
+    return value.serialize();
+  }
+
+  decodeValue(data: Uint8Array): BeaconStateAllForks {
+    return getStateTypeFromBytes(this.config, data).deserializeToViewDU(data);
+  }
+
+  // Handle key as slot
+
+  async put(key: Slot, value: BeaconStateAllForks): Promise<void> {
+    await Promise.all([super.put(key, value), storeRootIndex(this.db, key, value.hashTreeRoot())]);
+  }
+
+  getId(state: BeaconStateAllForks): Epoch {
+    return state.slot;
+  }
+
+  decodeKey(data: Uint8Array): number {
+    return bytesToInt(super.decodeKey(data) as unknown as Uint8Array, "be");
+  }
+
+  // Index Root -> Slot
+
+  async getByRoot(stateRoot: Root): Promise<BeaconStateAllForks | null> {
+    const slot = await this.getSlotByRoot(stateRoot);
+    if (slot !== null && Number.isInteger(slot)) {
+      return this.get(slot);
+    }
+    return null;
+  }
+
+  async dumpRootIndexEntries(): Promise<{root: RootHex; slot: Slot}[]> {
+    const entries = await this.db.entries({
+      lte: getRootIndexKey(Buffer.alloc(32, 0xff)),
+      gte: getRootIndexKey(Buffer.alloc(32, 0x00)),
+      bucketId: this.bucketId,
+    });
+    return entries.map((entry) => ({
+      root: toHex(entry.key),
+      slot: bytesToInt(entry.value, "be"),
+    }));
+  }
+
+  private async getSlotByRoot(root: Root): Promise<Slot | null> {
+    const value = await getRootIndex(this.db, root);
+    return value && bytesToInt(value, "be");
+  }
+}

package/src/db/repositories/stateArchiveIndex.ts

@@ -0,0 +1,18 @@
+import {Db, encodeKey} from "@lodestar/db";
+import {Root, Slot} from "@lodestar/types";
+import {intToBytes} from "@lodestar/utils";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+const bucketId = getBucketNameByValue(Bucket.index_stateArchiveRootIndex);
+
+export function getRootIndex(db: Db, stateRoot: Root): Promise<Uint8Array | null> {
+  return db.get(getRootIndexKey(stateRoot), {bucketId});
+}
+
+export function storeRootIndex(db: Db, slot: Slot, stateRoot: Root): Promise<void> {
+  return db.put(getRootIndexKey(stateRoot), intToBytes(slot, 8, "be"), {bucketId});
+}
+
+export function getRootIndexKey(root: Root): Uint8Array {
+  return encodeKey(Bucket.index_stateArchiveRootIndex, root);
+}

package/src/db/repositories/voluntaryExit.ts

@@ -0,0 +1,15 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {ValidatorIndex, phase0, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export class VoluntaryExitRepository extends Repository<ValidatorIndex, phase0.SignedVoluntaryExit> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.phase0_exit;
+    super(config, db, bucket, ssz.phase0.SignedVoluntaryExit, getBucketNameByValue(bucket));
+  }
+
+  getId(value: phase0.SignedVoluntaryExit): ValidatorIndex {
+    return value.message.validatorIndex;
+  }
+}

package/src/db/single/index.ts

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

package/src/db/single/preGenesisState.ts

@@ -0,0 +1,37 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, DbReqOpts} from "@lodestar/db";
+import {ForkAll, GENESIS_SLOT} from "@lodestar/params";
+import {BeaconStateAllForks} from "@lodestar/state-transition";
+import {SSZTypesFor} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export class PreGenesisState {
+  private readonly config: ChainForkConfig;
+  private readonly bucket: Bucket;
+  private readonly db: Db;
+  private readonly key: Uint8Array;
+  private readonly type: SSZTypesFor<ForkAll, "BeaconState">;
+  private readonly dbReqOpts: DbReqOpts;
+
+  constructor(config: ChainForkConfig, db: Db) {
+    this.config = config;
+    this.db = db;
+    this.bucket = Bucket.phase0_preGenesisState;
+    this.key = new Uint8Array([this.bucket]);
+    this.type = this.config.getForkTypes(GENESIS_SLOT).BeaconState;
+    this.dbReqOpts = {bucketId: getBucketNameByValue(this.bucket)};
+  }
+
+  async put(value: BeaconStateAllForks): Promise<void> {
+    await this.db.put(this.key, value.serialize(), this.dbReqOpts);
+  }
+
+  async get(): Promise<BeaconStateAllForks | null> {
+    const value = await this.db.get(this.key, this.dbReqOpts);
+    return value ? this.type.deserializeToViewDU(value) : null;
+  }
+
+  async delete(): Promise<void> {
+    await this.db.delete(this.key, this.dbReqOpts);
+  }
+}

package/src/db/single/preGenesisStateLastProcessedBlock.ts

@@ -0,0 +1,34 @@
+import {UintNumberType} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, DbReqOpts} from "@lodestar/db";
+import {ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export class PreGenesisStateLastProcessedBlock {
+  private readonly bucket: Bucket;
+  private readonly type: UintNumberType;
+  private readonly db: Db;
+  private readonly key: Uint8Array;
+  private readonly dbReqOpts: DbReqOpts;
+
+  constructor(_config: ChainForkConfig, db: Db) {
+    this.db = db;
+    this.type = ssz.UintNum64;
+    this.bucket = Bucket.phase0_preGenesisStateLastProcessedBlock;
+    this.key = new Uint8Array([this.bucket]);
+    this.dbReqOpts = {bucketId: getBucketNameByValue(this.bucket)};
+  }
+
+  async put(value: number): Promise<void> {
+    await this.db.put(this.key, this.type.serialize(value), this.dbReqOpts);
+  }
+
+  async get(): Promise<number | 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);
+  }
+}

package/src/eth1/errors.ts

@@ -0,0 +1,40 @@
+import {LodestarError} from "@lodestar/utils";
+
+export enum Eth1ErrorCode {
+  /** Deposit index too high */
+  DEPOSIT_INDEX_TOO_HIGH = "ETH1_ERROR_DEPOSIT_INDEX_TOO_HIGH",
+  /** Not enough deposits in DB */
+  NOT_ENOUGH_DEPOSITS = "ETH1_ERROR_NOT_ENOUGH_DEPOSITS",
+  /** Too many deposits returned by DB */
+  TOO_MANY_DEPOSITS = "ETH1_ERROR_TOO_MANY_DEPOSITS",
+  /** Deposit root tree does not match current eth1Data */
+  WRONG_DEPOSIT_ROOT = "ETH1_ERROR_WRONG_DEPOSIT_ROOT",
+
+  /** No deposits found for block range */
+  NO_DEPOSITS_FOR_BLOCK_RANGE = "ETH1_ERROR_NO_DEPOSITS_FOR_BLOCK_RANGE",
+  /** No depositRoot for depositCount */
+  NO_DEPOSIT_ROOT = "ETH1_ERROR_NO_DEPOSIT_ROOT",
+  /** Not enough deposit roots for index */
+  NOT_ENOUGH_DEPOSIT_ROOTS = "ETH1_ERROR_NOT_ENOUGH_DEPOSIT_ROOTS",
+
+  /** Attempted to insert a duplicate log for same index into the Eth1DepositsCache */
+  DUPLICATE_DISTINCT_LOG = "ETH1_ERROR_DUPLICATE_DISTINCT_LOG",
+  /** Attempted to insert a log with index != prev + 1 into the Eth1DepositsCache */
+  NON_CONSECUTIVE_LOGS = "ETH1_ERROR_NON_CONSECUTIVE_LOGS",
+  /** Expected a deposit log in the db for the index, missing log implies a corrupted db */
+  MISSING_DEPOSIT_LOG = "ETH1_ERROR_MISSING_DEPOSIT_LOG",
+}
+
+export type Eth1ErrorType =
+  | {code: Eth1ErrorCode.DEPOSIT_INDEX_TOO_HIGH; depositIndex: number; depositCount: number}
+  | {code: Eth1ErrorCode.NOT_ENOUGH_DEPOSITS; len: number; expectedLen: number}
+  | {code: Eth1ErrorCode.TOO_MANY_DEPOSITS; len: number; expectedLen: number}
+  | {code: Eth1ErrorCode.WRONG_DEPOSIT_ROOT; root: string; expectedRoot: string}
+  | {code: Eth1ErrorCode.NO_DEPOSITS_FOR_BLOCK_RANGE; fromBlock: number; toBlock: number}
+  | {code: Eth1ErrorCode.NO_DEPOSIT_ROOT; depositCount: number}
+  | {code: Eth1ErrorCode.NOT_ENOUGH_DEPOSIT_ROOTS; index: number; treeLength: number}
+  | {code: Eth1ErrorCode.DUPLICATE_DISTINCT_LOG; newIndex: number; lastLogIndex: number}
+  | {code: Eth1ErrorCode.NON_CONSECUTIVE_LOGS; newIndex: number; lastLogIndex: number}
+  | {code: Eth1ErrorCode.MISSING_DEPOSIT_LOG; newIndex: number; lastLogIndex: number};
+
+export class Eth1Error extends LodestarError<Eth1ErrorType> {}

package/src/eth1/eth1DataCache.ts

@@ -0,0 +1,26 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {phase0} from "@lodestar/types";
+import {IBeaconDb} from "../db/index.js";
+
+export class Eth1DataCache {
+  db: IBeaconDb;
+  config: ChainForkConfig;
+
+  constructor(config: ChainForkConfig, db: IBeaconDb) {
+    this.config = config;
+    this.db = db;
+  }
+
+  async get({timestampRange}: {timestampRange: {gte: number; lte: number}}): Promise<phase0.Eth1DataOrdered[]> {
+    return this.db.eth1Data.values(timestampRange);
+  }
+
+  async add(eth1Datas: (phase0.Eth1DataOrdered & {timestamp: number})[]): Promise<void> {
+    await this.db.eth1Data.batchPutValues(eth1Datas);
+  }
+
+  async getHighestCachedBlockNumber(): Promise<number | null> {
+    const highestEth1Data = await this.db.eth1Data.lastValue();
+    return highestEth1Data?.blockNumber ?? null;
+  }
+}