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

package/src/chain/GetBlobsTracker.ts

@@ -1,115 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {Logger} from "@lodestar/utils";
-import {BLOB_AND_PROOF_V2_RPC_BYTES} from "../execution/engine/types.js";
-import {IExecutionEngine} from "../execution/index.js";
-import {Metrics} from "../metrics/metrics.js";
-import {callInNextEventLoop} from "../util/eventLoop.js";
-import {
-  DataColumnEngineResult,
-  getBlobSidecarsFromExecution,
-  getDataColumnSidecarsFromExecution,
-} from "../util/execution.js";
-import {IBlockInput, isBlockInputBlobs} from "./blocks/blockInput/index.js";
-import {ChainEventEmitter} from "./emitter.js";
-
-export type GetBlobsTrackerInit = {
-  logger: Logger;
-  executionEngine: IExecutionEngine;
-  emitter: ChainEventEmitter;
-  metrics: Metrics | null;
-  config: ChainForkConfig;
-};
-
-/**
- * Tracks getBlobsV2 calls to the execution engine to avoid duplicate and multiple in-flight calls
- */
-export class GetBlobsTracker {
-  logger: Logger;
-  executionEngine: IExecutionEngine;
-  emitter: ChainEventEmitter;
-  metrics: Metrics | null;
-  config: ChainForkConfig;
-  activeReconstructions = new Set<string>();
-  // Preallocate buffers for getBlobsV2 RPC calls
-  // See https://github.com/ChainSafe/lodestar/pull/8282 for context
-  blobsAndProofsBuffers: {buffers: Uint8Array[]; inUse: boolean}[] = [];
-
-  constructor(init: GetBlobsTrackerInit) {
-    this.logger = init.logger;
-    this.executionEngine = init.executionEngine;
-    this.emitter = init.emitter;
-    this.metrics = init.metrics;
-    this.config = init.config;
-  }
-
-  triggerGetBlobs(blockInput: IBlockInput): void {
-    if (this.activeReconstructions.has(blockInput.blockRootHex)) {
-      return;
-    }
-
-    if (isBlockInputBlobs(blockInput)) {
-      // there is not preallocation for blob sidecars like there is for columns sidecars so no need to
-      // store the index for the preallocated buffers
-      this.activeReconstructions.add(blockInput.blockRootHex);
-      callInNextEventLoop(() => {
-        const logCtx = {slot: blockInput.slot, root: blockInput.blockRootHex};
-        this.logger.verbose("Trigger getBlobsV1 for block", logCtx);
-        getBlobSidecarsFromExecution(this.config, this.executionEngine, this.metrics, this.emitter, blockInput).finally(
-          () => {
-            this.logger.verbose("Completed getBlobsV1 for block", logCtx);
-            this.activeReconstructions.delete(blockInput.blockRootHex);
-          }
-        );
-      });
-
-      return;
-    }
-
-    let freeIndex = this.blobsAndProofsBuffers.findIndex(({inUse}) => !inUse);
-    if (freeIndex === -1) {
-      freeIndex = this.blobsAndProofsBuffers.length;
-      this.blobsAndProofsBuffers[freeIndex] = {inUse: false, buffers: []};
-    }
-
-    const maxBlobs = this.config.getMaxBlobsPerBlock(computeEpochAtSlot(blockInput.slot));
-    // double check that there is enough pre-allocated space (blob schedule may have changed since the last use)
-    const timer = this.metrics?.peerDas.getBlobsV2PreAllocationTime.startTimer();
-    for (let i = 0; i < maxBlobs; i++) {
-      if (this.blobsAndProofsBuffers[freeIndex].buffers[i] === undefined) {
-        this.blobsAndProofsBuffers[freeIndex].buffers[i] = new Uint8Array(BLOB_AND_PROOF_V2_RPC_BYTES);
-      }
-    }
-    timer?.();
-
-    // We don't care about the outcome of this call,
-    // just that it has been triggered for this block root.
-    this.activeReconstructions.add(blockInput.blockRootHex);
-    this.blobsAndProofsBuffers[freeIndex].inUse = true;
-    callInNextEventLoop(() => {
-      const logCtx = {slot: blockInput.slot, root: blockInput.blockRootHex};
-      this.logger.verbose("Trigger getBlobsV2 for block", logCtx);
-      getDataColumnSidecarsFromExecution(
-        this.config,
-        this.executionEngine,
-        this.emitter,
-        blockInput,
-        this.metrics,
-        this.blobsAndProofsBuffers[freeIndex].buffers
-      )
-        .then((result) => {
-          this.logger.debug("getBlobsV2 result for block", {...logCtx, result});
-          this.metrics?.dataColumns.dataColumnEngineResult.inc({result});
-        })
-        .catch((error) => {
-          this.logger.debug("Error during getBlobsV2 for block", logCtx, error as Error);
-          this.metrics?.dataColumns.dataColumnEngineResult.inc({result: DataColumnEngineResult.Failed});
-        })
-        .finally(() => {
-          this.logger.verbose("Completed getBlobsV2 for block", logCtx);
-          this.activeReconstructions.delete(blockInput.blockRootHex);
-          this.blobsAndProofsBuffers[freeIndex].inUse = false;
-        });
-    });
-  }
-}

package/src/chain/archiveStore/archiveStore.ts

@@ -1,222 +0,0 @@
-import {CheckpointWithHex} from "@lodestar/fork-choice";
-import {LoggerNode} from "@lodestar/logger/node";
-import {Checkpoint} from "@lodestar/types/phase0";
-import {callFnWhenAwait} from "@lodestar/utils";
-import {IBeaconDb} from "../../db/index.js";
-import {Metrics} from "../../metrics/metrics.js";
-import {isOptimisticBlock} from "../../util/forkChoice.js";
-import {JobItemQueue} from "../../util/queue/index.js";
-import {ChainEvent} from "../emitter.js";
-import {IBeaconChain} from "../interface.js";
-import {PROCESS_FINALIZED_CHECKPOINT_QUEUE_LENGTH} from "./constants.js";
-import {HistoricalStateRegen} from "./historicalState/historicalStateRegen.js";
-import {ArchiveMode, ArchiveStoreOpts, StateArchiveStrategy} from "./interface.js";
-import {FrequencyStateArchiveStrategy} from "./strategies/frequencyStateArchiveStrategy.js";
-import {archiveBlocks} from "./utils/archiveBlocks.js";
-import {pruneHistory} from "./utils/pruneHistory.js";
-import {updateBackfillRange} from "./utils/updateBackfillRange.js";
-
-type ArchiveStoreModules = {
-  chain: IBeaconChain;
-  db: IBeaconDb;
-  logger: LoggerNode;
-  metrics: Metrics | null;
-};
-
-type ArchiveStoreInitOpts = ArchiveStoreOpts & {dbName: string; anchorState: {finalizedCheckpoint: Checkpoint}};
-
-/**
- * Used for running tasks that depends on some events or are executed
- * periodically.
- */
-export class ArchiveStore {
-  private archiveMode: ArchiveMode;
-  private jobQueue: JobItemQueue<[CheckpointWithHex], void>;
-
-  private archiveDataEpochs?: number;
-  private readonly statesArchiverStrategy: StateArchiveStrategy;
-  private readonly chain: IBeaconChain;
-  private readonly db: IBeaconDb;
-  private readonly logger: LoggerNode;
-  private readonly metrics: Metrics | null;
-  private readonly opts: ArchiveStoreInitOpts;
-  private readonly signal: AbortSignal;
-
-  private historicalStateRegen?: HistoricalStateRegen;
-
-  constructor(modules: ArchiveStoreModules, opts: ArchiveStoreInitOpts, signal: AbortSignal) {
-    this.chain = modules.chain;
-    this.db = modules.db;
-    this.logger = modules.logger;
-    this.metrics = modules.metrics;
-    this.opts = opts;
-    this.signal = signal;
-    this.archiveMode = opts.archiveMode;
-    this.archiveDataEpochs = opts.archiveDataEpochs;
-
-    this.jobQueue = new JobItemQueue<[CheckpointWithHex], void>(this.processFinalizedCheckpoint, {
-      maxLength: PROCESS_FINALIZED_CHECKPOINT_QUEUE_LENGTH,
-      signal,
-    });
-
-    if (opts.archiveMode === ArchiveMode.Frequency) {
-      this.statesArchiverStrategy = new FrequencyStateArchiveStrategy(
-        this.chain.regen,
-        this.db,
-        this.logger,
-        opts,
-        this.chain.bufferPool
-      );
-    } else {
-      throw new Error(`State archive strategy "${opts.archiveMode}" currently not supported.`);
-    }
-
-    if (!opts.disableArchiveOnCheckpoint) {
-      this.chain.emitter.on(ChainEvent.forkChoiceFinalized, this.onFinalizedCheckpoint);
-      this.chain.emitter.on(ChainEvent.checkpoint, this.onCheckpoint);
-
-      this.signal.addEventListener(
-        "abort",
-        () => {
-          this.chain.emitter.off(ChainEvent.forkChoiceFinalized, this.onFinalizedCheckpoint);
-          this.chain.emitter.off(ChainEvent.checkpoint, this.onCheckpoint);
-        },
-        {once: true}
-      );
-    }
-  }
-
-  async init(): Promise<void> {
-    if (this.opts.pruneHistory) {
-      // prune ALL stale data before starting
-      this.logger.info("Pruning historical data");
-      await callFnWhenAwait(
-        pruneHistory(
-          this.chain.config,
-          this.db,
-          this.logger,
-          this.metrics,
-          this.opts.anchorState.finalizedCheckpoint.epoch,
-          this.chain.clock.currentEpoch
-        ),
-        () => this.logger.info("Still pruning historical data, please wait..."),
-        30_000,
-        this.signal
-      );
-    }
-
-    if (this.opts.serveHistoricalState) {
-      this.historicalStateRegen = await HistoricalStateRegen.init({
-        opts: {
-          genesisTime: this.chain.clock.genesisTime,
-          dbLocation: this.opts.dbName,
-        },
-        config: this.chain.config,
-        metrics: this.metrics,
-        logger: this.logger,
-        signal: this.signal,
-      });
-    }
-  }
-
-  async close(): Promise<void> {
-    await this.historicalStateRegen?.close();
-  }
-
-  async scrapeMetrics(): Promise<string> {
-    return this.historicalStateRegen?.scrapeMetrics() ?? "";
-  }
-
-  async getHistoricalStateBySlot(
-    slot: number
-  ): Promise<{state: Uint8Array; executionOptimistic: boolean; finalized: boolean} | null> {
-    const finalizedBlock = this.chain.forkChoice.getFinalizedBlock();
-
-    if (slot >= finalizedBlock.slot) {
-      return null;
-    }
-
-    // request for finalized state using historical state regen
-    const stateSerialized = await this.historicalStateRegen?.getHistoricalState(slot);
-    if (!stateSerialized) {
-      return null;
-    }
-
-    return {state: stateSerialized, executionOptimistic: isOptimisticBlock(finalizedBlock), finalized: true};
-  }
-
-  /**
-   * Archive latest finalized state
-   * */
-  async persistToDisk(): Promise<void> {
-    return this.statesArchiverStrategy.archiveState(this.chain.forkChoice.getFinalizedCheckpoint());
-  }
-
-  //-------------------------------------------------------------------------
-  // Event handlers
-  //-------------------------------------------------------------------------
-  private onFinalizedCheckpoint = async (finalized: CheckpointWithHex): Promise<void> => {
-    return this.jobQueue.push(finalized);
-  };
-
-  private onCheckpoint = (): void => {
-    const headStateRoot = this.chain.forkChoice.getHead().stateRoot;
-    this.chain.regen.pruneOnCheckpoint(
-      this.chain.forkChoice.getFinalizedCheckpoint().epoch,
-      this.chain.forkChoice.getJustifiedCheckpoint().epoch,
-      headStateRoot
-    );
-
-    this.statesArchiverStrategy.onCheckpoint(headStateRoot, this.metrics).catch((err) => {
-      this.logger.error("Error during state archive", {archiveMode: this.archiveMode}, err);
-    });
-  };
-
-  private processFinalizedCheckpoint = async (finalized: CheckpointWithHex): Promise<void> => {
-    try {
-      const finalizedEpoch = finalized.epoch;
-      this.logger.verbose("Start processing finalized checkpoint", {epoch: finalizedEpoch, rootHex: finalized.rootHex});
-      await archiveBlocks(
-        this.chain.config,
-        this.db,
-        this.chain.forkChoice,
-        this.chain.lightClientServer,
-        this.logger,
-        finalized,
-        this.chain.clock.currentEpoch,
-        this.archiveDataEpochs,
-        this.chain.opts.persistOrphanedBlocks,
-        this.chain.opts.persistOrphanedBlocksDir
-      );
-      if (this.opts.pruneHistory) {
-        await pruneHistory(
-          this.chain.config,
-          this.db,
-          this.logger,
-          this.metrics,
-          finalizedEpoch,
-          this.chain.clock.currentEpoch
-        );
-      }
-
-      await this.statesArchiverStrategy.onFinalizedCheckpoint(finalized, this.metrics);
-
-      // should be after ArchiveBlocksTask to handle restart cleanly
-      await this.statesArchiverStrategy.maybeArchiveState(finalized, this.metrics);
-
-      this.chain.regen.pruneOnFinalized(finalizedEpoch);
-
-      // tasks rely on extended fork choice
-      const prunedBlocks = this.chain.forkChoice.prune(finalized.rootHex);
-      await updateBackfillRange({chain: this.chain, db: this.db, logger: this.logger}, finalized);
-
-      this.logger.verbose("Finish processing finalized checkpoint", {
-        epoch: finalizedEpoch,
-        rootHex: finalized.rootHex,
-        prunedBlocks: prunedBlocks.length,
-      });
-    } catch (e) {
-      this.logger.error("Error processing finalized checkpoint", {epoch: finalized.epoch}, e as Error);
-    }
-  };
-}

package/src/chain/archiveStore/constants.ts

@@ -1,5 +0,0 @@
-import {ArchiveMode} from "./interface.js";
-
-export const DEFAULT_ARCHIVE_MODE = ArchiveMode.Frequency;
-
-export const PROCESS_FINALIZED_CHECKPOINT_QUEUE_LENGTH = 256;

package/src/chain/archiveStore/historicalState/getHistoricalState.ts

@@ -1,116 +0,0 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
-import {BeaconConfig} from "@lodestar/config";
-import {
-  BeaconStateAllForks,
-  CachedBeaconStateAllForks,
-  DataAvailabilityStatus,
-  ExecutionPayloadStatus,
-  createCachedBeaconState,
-  stateTransition,
-} from "@lodestar/state-transition";
-import {IBeaconDb} from "../../../db/index.js";
-import {HistoricalStateRegenMetrics} from "./metrics.js";
-import {RegenErrorType} from "./types.js";
-
-/**
- * Populate a PubkeyIndexMap with any new entries based on a BeaconState
- */
-export function syncPubkeyCache(state: BeaconStateAllForks, pubkey2index: PubkeyIndexMap): void {
-  // Get the validators sub tree once for all the loop
-  const validators = state.validators;
-
-  const newCount = state.validators.length;
-  for (let i = pubkey2index.size; i < newCount; i++) {
-    const pubkey = validators.getReadonly(i).pubkey;
-    pubkey2index.set(pubkey, i);
-  }
-}
-
-/**
- * Get the nearest BeaconState at or before a slot
- */
-export async function getNearestState(
-  slot: number,
-  config: BeaconConfig,
-  db: IBeaconDb,
-  pubkey2index: PubkeyIndexMap
-): Promise<CachedBeaconStateAllForks> {
-  const states = await db.stateArchive.values({limit: 1, lte: slot, reverse: true});
-  if (!states.length) {
-    throw new Error("No near state found in the database");
-  }
-
-  const state = states[0];
-  syncPubkeyCache(state, pubkey2index);
-
-  return createCachedBeaconState(
-    state,
-    {
-      config,
-      pubkey2index,
-      index2pubkey: [],
-    },
-    {
-      skipSyncPubkeys: true,
-    }
-  );
-}
-
-/**
- * Get and regenerate a historical state
- */
-export async function getHistoricalState(
-  slot: number,
-  config: BeaconConfig,
-  db: IBeaconDb,
-  pubkey2index: PubkeyIndexMap,
-  metrics?: HistoricalStateRegenMetrics
-): Promise<Uint8Array> {
-  const regenTimer = metrics?.regenTime.startTimer();
-
-  const loadStateTimer = metrics?.loadStateTime.startTimer();
-  let state = await getNearestState(slot, config, db, pubkey2index).catch((e) => {
-    metrics?.regenErrorCount.inc({reason: RegenErrorType.loadState});
-    throw e;
-  });
-  loadStateTimer?.();
-
-  const transitionTimer = metrics?.stateTransitionTime.startTimer();
-  let blockCount = 0;
-  for await (const block of db.blockArchive.valuesStream({gt: state.slot, lte: slot})) {
-    try {
-      state = stateTransition(
-        state,
-        block,
-        {
-          verifyProposer: false,
-          verifySignatures: false,
-          verifyStateRoot: false,
-          executionPayloadStatus: ExecutionPayloadStatus.valid,
-          dataAvailabilityStatus: DataAvailabilityStatus.Available,
-        },
-        {metrics}
-      );
-    } catch (e) {
-      metrics?.regenErrorCount.inc({reason: RegenErrorType.blockProcessing});
-      throw e;
-    }
-    blockCount++;
-    if (Buffer.compare(state.hashTreeRoot(), block.message.stateRoot) !== 0) {
-      metrics?.regenErrorCount.inc({reason: RegenErrorType.invalidStateRoot});
-    }
-  }
-  metrics?.stateTransitionBlocks.observe(blockCount);
-  transitionTimer?.();
-
-  if (state.slot !== slot) {
-    throw Error(`Failed to generate historical state for slot ${slot}`);
-  }
-
-  const serializeTimer = metrics?.stateSerializationTime.startTimer();
-  const stateBytes = state.serialize();
-  serializeTimer?.();
-
-  regenTimer?.();
-  return stateBytes;
-}

package/src/chain/archiveStore/historicalState/historicalStateRegen.ts

@@ -1,68 +0,0 @@
-import path from "node:path";
-import {ModuleThread, Thread, Worker, spawn} from "@chainsafe/threads";
-import {chainConfigToJson} from "@lodestar/config";
-import {LoggerNode} from "@lodestar/logger/node";
-import {
-  HistoricalStateRegenInitModules,
-  HistoricalStateRegenModules,
-  HistoricalStateWorkerApi,
-  HistoricalStateWorkerData,
-} from "./types.js";
-
-// Worker constructor consider the path relative to the current working directory
-const WORKER_DIR = process.env.NODE_ENV === "test" ? "../../../../lib/chain/archiveStore/historicalState" : "./";
-
-/**
- * HistoricalStateRegen limits the damage from recreating historical states
- * by running regen in a separate worker thread.
- */
-export class HistoricalStateRegen implements HistoricalStateWorkerApi {
-  private readonly api: ModuleThread<HistoricalStateWorkerApi>;
-  private readonly logger: LoggerNode;
-
-  constructor(modules: HistoricalStateRegenModules) {
-    this.api = modules.api;
-    this.logger = modules.logger;
-    modules.signal?.addEventListener("abort", () => this.close(), {once: true});
-  }
-  static async init(modules: HistoricalStateRegenInitModules): Promise<HistoricalStateRegen> {
-    const workerData: HistoricalStateWorkerData = {
-      chainConfigJson: chainConfigToJson(modules.config),
-      genesisValidatorsRoot: modules.config.genesisValidatorsRoot,
-      genesisTime: modules.opts.genesisTime,
-      maxConcurrency: 1,
-      maxLength: 50,
-      dbLocation: modules.opts.dbLocation,
-      metricsEnabled: Boolean(modules.metrics),
-      loggerOpts: modules.logger.toOpts(),
-    };
-
-    const worker = new Worker(path.join(WORKER_DIR, "worker.js"), {
-      suppressTranspileTS: Boolean(globalThis.Bun),
-      workerData,
-    } as ConstructorParameters<typeof Worker>[1]);
-
-    const api = await spawn<HistoricalStateWorkerApi>(worker, {
-      // A Lodestar Node may do very expensive task at start blocking the event loop and causing
-      // the initialization to timeout. The number below is big enough to almost disable the timeout
-      timeout: 5 * 60 * 1000,
-    });
-
-    return new HistoricalStateRegen({...modules, api});
-  }
-
-  async scrapeMetrics(): Promise<string> {
-    return this.api.scrapeMetrics();
-  }
-
-  async close(): Promise<void> {
-    await this.api.close();
-    this.logger.debug("Terminating historical state worker");
-    await Thread.terminate(this.api);
-    this.logger.debug("Terminated historical state worker");
-  }
-
-  async getHistoricalState(slot: number): Promise<Uint8Array> {
-    return this.api.getHistoricalState(slot);
-  }
-}