@lodestar/beacon-node 1.40.0-dev.3715a82f3f → 1.40.0-dev.45b04262dc

package/src/chain/stateCache/inMemoryCheckpointsCache.ts

@@ -1,192 +0,0 @@
-import {routes} from "@lodestar/api";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {Epoch, RootHex, phase0} from "@lodestar/types";
-import {MapDef, toRootHex} from "@lodestar/utils";
-import {Metrics} from "../../metrics/index.js";
-import {MapTracker} from "./mapMetrics.js";
-import {CacheItemType, CheckpointStateCache} from "./types.js";
-
-export type CheckpointHex = {epoch: Epoch; rootHex: RootHex};
-const MAX_EPOCHS = 10;
-
-/**
- * In memory cache of CachedBeaconState
- * belonging to checkpoint
- *
- * Similar API to Repository
- */
-export class InMemoryCheckpointStateCache implements CheckpointStateCache {
-  private readonly cache: MapTracker<string, CachedBeaconStateAllForks>;
-  /** Epoch -> Set<blockRoot> */
-  private readonly epochIndex = new MapDef<Epoch, Set<string>>(() => new Set<string>());
-  /**
-   * Max number of epochs allowed in the cache
-   */
-  private readonly maxEpochs: number;
-  private readonly metrics: Metrics["cpStateCache"] | null | undefined;
-  private preComputedCheckpoint: string | null = null;
-  private preComputedCheckpointHits: number | null = null;
-
-  constructor({metrics = null}: {metrics?: Metrics | null}, {maxEpochs = MAX_EPOCHS}: {maxEpochs?: number} = {}) {
-    this.cache = new MapTracker(metrics?.cpStateCache);
-    if (metrics) {
-      this.metrics = metrics.cpStateCache;
-      metrics.cpStateCache.size.addCollect(() =>
-        metrics.cpStateCache.size.set({type: CacheItemType.inMemory}, this.cache.size)
-      );
-      metrics.cpStateCache.epochSize.addCollect(() =>
-        metrics.cpStateCache.epochSize.set({type: CacheItemType.inMemory}, this.epochIndex.size)
-      );
-    }
-    this.maxEpochs = maxEpochs;
-  }
-
-  async getOrReload(cp: CheckpointHex): Promise<CachedBeaconStateAllForks | null> {
-    return this.get(cp);
-  }
-
-  async getStateOrBytes(cp: CheckpointHex): Promise<Uint8Array | CachedBeaconStateAllForks | null> {
-    return this.get(cp);
-  }
-
-  async getOrReloadLatest(rootHex: string, maxEpoch: number): Promise<CachedBeaconStateAllForks | null> {
-    return this.getLatest(rootHex, maxEpoch);
-  }
-
-  async processState(): Promise<number> {
-    // do nothing, this class does not support prunning
-    return 0;
-  }
-
-  get(cp: CheckpointHex): CachedBeaconStateAllForks | null {
-    this.metrics?.lookups.inc();
-    const cpKey = toCheckpointKey(cp);
-    const item = this.cache.get(cpKey);
-
-    if (!item) {
-      return null;
-    }
-
-    this.metrics?.hits.inc();
-
-    if (cpKey === this.preComputedCheckpoint) {
-      this.preComputedCheckpointHits = (this.preComputedCheckpointHits ?? 0) + 1;
-    }
-
-    this.metrics?.stateClonedCount.observe(item.clonedCount);
-
-    return item;
-  }
-
-  add(cp: phase0.Checkpoint, item: CachedBeaconStateAllForks): void {
-    const cpHex = toCheckpointHex(cp);
-    const key = toCheckpointKey(cpHex);
-    if (this.cache.has(key)) {
-      return;
-    }
-    this.metrics?.adds.inc();
-    this.cache.set(key, item);
-    this.epochIndex.getOrDefault(cp.epoch).add(cpHex.rootHex);
-  }
-
-  /**
-   * Searches for the latest cached state with a `root`, starting with `epoch` and descending
-   */
-  getLatest(rootHex: RootHex, maxEpoch: Epoch): CachedBeaconStateAllForks | null {
-    // sort epochs in descending order, only consider epochs lte `epoch`
-    const epochs = Array.from(this.epochIndex.keys())
-      .sort((a, b) => b - a)
-      .filter((e) => e <= maxEpoch);
-    for (const epoch of epochs) {
-      if (this.epochIndex.get(epoch)?.has(rootHex)) {
-        return this.get({rootHex, epoch});
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Update the precomputed checkpoint and return the number of his for the
-   * previous one (if any).
-   */
-  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null {
-    const previousHits = this.preComputedCheckpointHits;
-    this.preComputedCheckpoint = toCheckpointKey({rootHex, epoch});
-    this.preComputedCheckpointHits = 0;
-    return previousHits;
-  }
-
-  pruneFinalized(finalizedEpoch: Epoch): void {
-    for (const epoch of this.epochIndex.keys()) {
-      if (epoch < finalizedEpoch) {
-        this.deleteAllEpochItems(epoch);
-      }
-    }
-  }
-
-  prune(finalizedEpoch: Epoch, justifiedEpoch: Epoch): void {
-    const epochs = Array.from(this.epochIndex.keys()).filter(
-      (epoch) => epoch !== finalizedEpoch && epoch !== justifiedEpoch
-    );
-    if (epochs.length > this.maxEpochs) {
-      for (const epoch of epochs.slice(0, epochs.length - this.maxEpochs)) {
-        this.deleteAllEpochItems(epoch);
-      }
-    }
-  }
-
-  delete(cp: phase0.Checkpoint): void {
-    this.cache.delete(toCheckpointKey(toCheckpointHex(cp)));
-    const epochKey = toRootHex(cp.root);
-    const value = this.epochIndex.get(cp.epoch);
-    if (value) {
-      value.delete(epochKey);
-      if (value.size === 0) {
-        this.epochIndex.delete(cp.epoch);
-      }
-    }
-  }
-
-  deleteAllEpochItems(epoch: Epoch): void {
-    for (const rootHex of this.epochIndex.get(epoch) || []) {
-      this.cache.delete(toCheckpointKey({rootHex, epoch}));
-    }
-    this.epochIndex.delete(epoch);
-  }
-
-  clear(): void {
-    this.cache.clear();
-    this.epochIndex.clear();
-  }
-
-  /** ONLY FOR DEBUGGING PURPOSES. For lodestar debug API */
-  dumpSummary(): routes.lodestar.StateCacheItem[] {
-    return Array.from(this.cache.entries()).map(([key, state]) => ({
-      slot: state.slot,
-      root: toRootHex(state.hashTreeRoot()),
-      reads: this.cache.readCount.get(key) ?? 0,
-      lastRead: this.cache.lastRead.get(key) ?? 0,
-      checkpointState: true,
-    }));
-  }
-
-  getStates(): IterableIterator<CachedBeaconStateAllForks> {
-    return this.cache.values();
-  }
-
-  /** ONLY FOR DEBUGGING PURPOSES. For spec tests on error */
-  dumpCheckpointKeys(): string[] {
-    return Array.from(this.cache.keys());
-  }
-}
-
-export function toCheckpointHex(checkpoint: phase0.Checkpoint): CheckpointHex {
-  return {
-    epoch: checkpoint.epoch,
-    rootHex: toRootHex(checkpoint.root),
-  };
-}
-
-export function toCheckpointKey(cp: CheckpointHex): string {
-  return `${cp.rootHex}:${cp.epoch}`;
-}

package/src/util/bytes.ts

@@ -1,11 +0,0 @@
-import {Root} from "@lodestar/types";
-
-export function byteArrayEquals(a: Uint8Array | Root, b: Uint8Array | Root): boolean {
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}