@lodestar/beacon-node 1.38.0 → 1.39.0-dev.39dac0f03d

package/src/chain/genesis/genesis.ts

@@ -1,190 +0,0 @@
-import {Tree, toGindex} from "@chainsafe/persistent-merkle-tree";
-import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
-import {GENESIS_EPOCH, GENESIS_SLOT} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  CachedBeaconStateAllForks,
-  applyDeposits,
-  applyEth1BlockHash,
-  applyTimestamp,
-  createCachedBeaconState,
-  createEmptyEpochCacheImmutableData,
-  getActiveValidatorIndices,
-  getGenesisBeaconState,
-  getTemporaryBlockHeader,
-} from "@lodestar/state-transition";
-import {phase0, ssz} from "@lodestar/types";
-import {Logger} from "@lodestar/utils";
-import {DepositTree} from "../../db/repositories/depositDataRoot.js";
-import {IEth1Provider} from "../../eth1/index.js";
-import {IEth1StreamParams} from "../../eth1/interface.js";
-import {getDepositsAndBlockStreamForGenesis, getDepositsStream} from "../../eth1/stream.js";
-import {GenesisResult, IGenesisBuilder} from "./interface.js";
-
-export type GenesisBuilderKwargs = {
-  config: ChainForkConfig;
-  eth1Provider: IEth1Provider;
-  logger: Logger;
-
-  /** Use to restore pending progress */
-  pendingStatus?: {
-    state: BeaconStateAllForks;
-    depositTree: DepositTree;
-    lastProcessedBlockNumber: number;
-  };
-
-  signal?: AbortSignal;
-  maxBlocksPerPoll?: number;
-};
-
-export class GenesisBuilder implements IGenesisBuilder {
-  // Expose state to persist on error
-  readonly state: CachedBeaconStateAllForks;
-  readonly depositTree: DepositTree;
-  /** Is null if no block has been processed yet */
-  lastProcessedBlockNumber: number | null = null;
-
-  private readonly config: BeaconConfig;
-  private readonly eth1Provider: IEth1Provider;
-  private readonly logger: Logger;
-  private readonly signal?: AbortSignal;
-  private readonly eth1Params: IEth1StreamParams;
-  private readonly depositCache = new Set<number>();
-  private readonly fromBlock: number;
-  private readonly logEvery = 30 * 1000;
-  private lastLog = 0;
-  /** Current count of active validators in the state */
-  private activatedValidatorCount: number;
-
-  constructor({config, eth1Provider, logger, signal, pendingStatus, maxBlocksPerPoll}: GenesisBuilderKwargs) {
-    // at genesis builder, there is no genesis validator so we don't have a real BeaconConfig
-    // but we need BeaconConfig to temporarily create CachedBeaconState, the cast here is safe since we don't use any getDomain here
-    // the use of state as CachedBeaconState is just for convenient, GenesisResult returns TreeView anyway
-    this.eth1Provider = eth1Provider;
-    this.logger = logger;
-    this.signal = signal;
-    this.eth1Params = {
-      ...config,
-      maxBlocksPerPoll: maxBlocksPerPoll ?? 10000,
-    };
-
-    let stateView: BeaconStateAllForks;
-
-    if (pendingStatus) {
-      this.logger.info("Restoring pending genesis state", {block: pendingStatus.lastProcessedBlockNumber});
-      stateView = pendingStatus.state;
-      this.depositTree = pendingStatus.depositTree;
-      this.fromBlock = Math.max(pendingStatus.lastProcessedBlockNumber + 1, this.eth1Provider.deployBlock);
-    } else {
-      stateView = getGenesisBeaconState(
-        config,
-        ssz.phase0.Eth1Data.defaultValue(),
-        getTemporaryBlockHeader(config, config.getForkTypes(GENESIS_SLOT).BeaconBlock.defaultValue())
-      );
-      this.depositTree = ssz.phase0.DepositDataRootList.defaultViewDU();
-      this.fromBlock = this.eth1Provider.deployBlock;
-    }
-
-    // TODO - PENDING: Ensure EpochCacheImmutableData is created only once
-    this.state = createCachedBeaconState(stateView, createEmptyEpochCacheImmutableData(config, stateView));
-    this.config = this.state.config;
-    this.activatedValidatorCount = getActiveValidatorIndices(stateView, GENESIS_EPOCH).length;
-  }
-
-  /**
-   * Get eth1 deposit events and blocks and apply to this.state until we found genesis.
-   */
-  async waitForGenesis(): Promise<GenesisResult> {
-    await this.eth1Provider.validateContract();
-
-    // Load data from data from this.db.depositData, this.db.depositDataRoot
-    // And start from a more recent fromBlock
-    const blockNumberValidatorGenesis = await this.waitForGenesisValidators();
-
-    const depositsAndBlocksStream = getDepositsAndBlockStreamForGenesis(
-      blockNumberValidatorGenesis,
-      this.eth1Provider,
-      this.eth1Params,
-      this.signal
-    );
-
-    for await (const [depositEvents, block] of depositsAndBlocksStream) {
-      this.applyDeposits(depositEvents);
-      applyTimestamp(this.config, this.state, block.timestamp);
-      applyEth1BlockHash(this.state, block.blockHash);
-      this.lastProcessedBlockNumber = block.blockNumber;
-
-      if (
-        this.state.genesisTime >= this.config.MIN_GENESIS_TIME &&
-        this.activatedValidatorCount >= this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
-      ) {
-        this.logger.info("Found genesis state", {blockNumber: block.blockNumber});
-        return {
-          state: this.state,
-          depositTree: this.depositTree,
-          block,
-        };
-      }
-
-      this.throttledLog(`Waiting for min genesis time ${block.timestamp} / ${this.config.MIN_GENESIS_TIME}`);
-    }
-
-    throw Error("depositsStream stopped without a valid genesis state");
-  }
-
-  /**
-   * First phase of waiting for genesis.
-   * Stream deposits events in batches as big as possible without querying block data
-   * @returns Block number at which there are enough active validators is state for genesis
-   */
-  private async waitForGenesisValidators(): Promise<number> {
-    const depositsStream = getDepositsStream(this.fromBlock, this.eth1Provider, this.eth1Params, this.signal);
-
-    for await (const {depositEvents, blockNumber} of depositsStream) {
-      this.applyDeposits(depositEvents);
-      this.lastProcessedBlockNumber = blockNumber;
-
-      if (this.activatedValidatorCount >= this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT) {
-        this.logger.info("Found enough genesis validators", {blockNumber});
-        return blockNumber;
-      }
-
-      this.throttledLog(
-        `Found ${this.state.validators.length} / ${this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT} validators to genesis`
-      );
-    }
-
-    throw Error("depositsStream stopped without a valid genesis state");
-  }
-
-  private applyDeposits(depositEvents: phase0.DepositEvent[]): void {
-    const newDeposits = depositEvents
-      .filter((depositEvent) => !this.depositCache.has(depositEvent.index))
-      .map((depositEvent) => {
-        this.depositCache.add(depositEvent.index);
-        this.depositTree.push(ssz.phase0.DepositData.hashTreeRoot(depositEvent.depositData));
-        const gindex = toGindex(this.depositTree.type.depth, BigInt(depositEvent.index));
-
-        // Apply changes from the push above
-        this.depositTree.commit();
-        const depositTreeNode = this.depositTree.node;
-        return {
-          proof: new Tree(depositTreeNode).getSingleProof(gindex),
-          data: depositEvent.depositData,
-        };
-      });
-
-    const {activatedValidatorCount} = applyDeposits(this.config, this.state, newDeposits, this.depositTree);
-    this.activatedValidatorCount += activatedValidatorCount;
-
-    // TODO: If necessary persist deposits here to this.db.depositData, this.db.depositDataRoot
-  }
-
-  /** Throttle genesis generation status log to prevent spamming */
-  private throttledLog(message: string): void {
-    if (Date.now() - this.lastLog > this.logEvery) {
-      this.lastLog = Date.now();
-      this.logger.info(message);
-    }
-  }
-}

package/src/chain/genesis/interface.ts

@@ -1,14 +0,0 @@
-import {CompositeViewDU, VectorCompositeType} from "@chainsafe/ssz";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {ssz} from "@lodestar/types";
-import {Eth1Block} from "../../eth1/interface.js";
-
-export type GenesisResult = {
-  state: CachedBeaconStateAllForks;
-  depositTree: CompositeViewDU<VectorCompositeType<typeof ssz.Root>>;
-  block: Eth1Block;
-};
-
-export interface IGenesisBuilder {
-  waitForGenesis: () => Promise<GenesisResult>;
-}

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/single/index.ts

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

package/src/db/single/preGenesisState.ts

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

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

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

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