@lodestar/beacon-node 1.39.0-dev.aceb5b7416 → 1.39.0-dev.b37f2bd1bd

package/src/chain/interface.ts

@@ -25,6 +25,7 @@ import {
   phase0,
 } from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
+import {IEth1ForBlockProduction} from "../eth1/index.js";
 import {IExecutionBuilder, IExecutionEngine} from "../execution/index.js";
 import {Metrics} from "../metrics/metrics.js";
 import {BufferPool} from "../util/bufferPool.js";
@@ -87,6 +88,7 @@ export interface IBeaconChain {
   readonly genesisTime: UintNum64;
   readonly genesisValidatorsRoot: Root;
   readonly earliestAvailableSlot: Slot;
+  readonly eth1: IEth1ForBlockProduction;
   readonly executionEngine: IExecutionEngine;
   readonly executionBuilder?: IExecutionBuilder;
   // Expose config for convenience in modularized functions

package/src/chain/prepareNextSlot.ts

@@ -1,8 +1,9 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
-import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostElectra} from "@lodestar/params";
 import {
+  BeaconStateElectra,
   CachedBeaconStateAllForks,
   CachedBeaconStateExecutions,
   StateHashTreeRootSource,
@@ -221,6 +222,9 @@ export class PrepareNextSlotScheduler {
         }
         this.metrics?.precomputeNextEpochTransition.hits.set(previousHits ?? 0);
 
+        // Check if we can stop polling eth1 data
+        this.stopEth1Polling();
+
         this.logger.verbose("Completed PrepareNextSlotScheduler epoch transition", {
           nextEpoch,
           headSlot,
@@ -248,4 +252,27 @@ export class PrepareNextSlotScheduler {
     state.hashTreeRoot();
     hashTreeRootTimer?.();
   }
+
+  /**
+   * Stop eth1 data polling after eth1_deposit_index has reached deposit_requests_start_index in Electra as described in EIP-6110
+   */
+  stopEth1Polling(): void {
+    // Only continue if eth1 is still polling and finalized checkpoint is in Electra. State regen is expensive
+    if (this.chain.eth1.isPollingEth1Data()) {
+      const finalizedCheckpoint = this.chain.forkChoice.getFinalizedCheckpoint();
+      const checkpointFork = this.config.getForkInfoAtEpoch(finalizedCheckpoint.epoch).name;
+
+      if (isForkPostElectra(checkpointFork)) {
+        const finalizedState = this.chain.getStateByCheckpoint(finalizedCheckpoint)?.state;
+
+        if (
+          finalizedState !== undefined &&
+          finalizedState.eth1DepositIndex === Number((finalizedState as BeaconStateElectra).depositRequestsStartIndex)
+        ) {
+          // Signal eth1 to stop polling eth1Data
+          this.chain.eth1.stopPollingEth1Data();
+        }
+      }
+    }
+  }
 }

package/src/chain/produceBlock/produceBlockBody.ts

@@ -45,7 +45,7 @@ import {
 } from "@lodestar/types";
 import {Logger, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
-import {numToQuantity} from "../../execution/engine/utils.js";
+import {numToQuantity} from "../../eth1/provider/utils.js";
 import {
   IExecutionBuilder,
   IExecutionEngine,
@@ -78,6 +78,7 @@ export enum BlockProductionStep {
   voluntaryExits = "voluntaryExits",
   blsToExecutionChanges = "blsToExecutionChanges",
   attestations = "attestations",
+  eth1DataAndDeposits = "eth1DataAndDeposits",
   syncAggregate = "syncAggregate",
   executionPayload = "executionPayload",
 }
@@ -666,17 +667,20 @@ export async function produceCommonBlockBody<T extends BlockType>(
     step: BlockProductionStep.attestations,
   });
 
+  const endEth1DataAndDeposits = stepsMetrics?.startTimer();
+  const {eth1Data, deposits} = await this.eth1.getEth1DataAndDeposits(currentState);
+  endEth1DataAndDeposits?.({
+    step: BlockProductionStep.eth1DataAndDeposits,
+  });
+
   const blockBody: Omit<CommonBlockBody, "blsToExecutionChanges" | "syncAggregate"> = {
     randaoReveal,
     graffiti,
-    // Eth1 data voting is no longer required since electra
-    eth1Data: currentState.eth1Data,
+    eth1Data,
     proposerSlashings,
     attesterSlashings,
     attestations,
-    // Since electra, deposits are processed by the execution layer,
-    // we no longer support handling deposits from earlier forks.
-    deposits: [],
+    deposits,
     voluntaryExits,
   };
 

package/src/db/beacon.ts

@@ -14,12 +14,16 @@ import {
   CheckpointHeaderRepository,
   DataColumnSidecarArchiveRepository,
   DataColumnSidecarRepository,
+  DepositDataRootRepository,
+  DepositEventRepository,
+  Eth1DataRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
   SyncCommitteeWitnessRepository,
   VoluntaryExitRepository,
 } from "./repositories/index.js";
+import {PreGenesisState, PreGenesisStateLastProcessedBlock} from "./single/index.js";
 
 export type BeaconDbModules = {
   config: ChainForkConfig;
@@ -41,8 +45,14 @@ export class BeaconDb implements IBeaconDb {
   voluntaryExit: VoluntaryExitRepository;
   proposerSlashing: ProposerSlashingRepository;
   attesterSlashing: AttesterSlashingRepository;
+  depositEvent: DepositEventRepository;
   blsToExecutionChange: BLSToExecutionChangeRepository;
 
+  depositDataRoot: DepositDataRootRepository;
+  eth1Data: Eth1DataRepository;
+  preGenesisState: PreGenesisState;
+  preGenesisStateLastProcessedBlock: PreGenesisStateLastProcessedBlock;
+
   // lightclient
   bestLightClientUpdate: BestLightClientUpdateRepository;
   checkpointHeader: CheckpointHeaderRepository;
@@ -70,6 +80,11 @@ export class BeaconDb implements IBeaconDb {
     this.blsToExecutionChange = new BLSToExecutionChangeRepository(config, db);
     this.proposerSlashing = new ProposerSlashingRepository(config, db);
     this.attesterSlashing = new AttesterSlashingRepository(config, db);
+    this.depositEvent = new DepositEventRepository(config, db);
+    this.depositDataRoot = new DepositDataRootRepository(config, db);
+    this.eth1Data = new Eth1DataRepository(config, db);
+    this.preGenesisState = new PreGenesisState(config, db);
+    this.preGenesisStateLastProcessedBlock = new PreGenesisStateLastProcessedBlock(config, db);
 
     // lightclient
     this.bestLightClientUpdate = new BestLightClientUpdateRepository(config, db);

package/src/db/buckets.ts

@@ -16,13 +16,14 @@ export enum Bucket {
   index_mainChain = 6, // Slot -> Root<BeaconBlock>
   // justified, finalized state and block hashes
   index_chainInfo = 7, // Key -> Number64 | stateHash | blockHash
-  // phase0_eth1Data = 8, // DEPRECATED - eth1 deposit tracking is not required since electra
-  // index_depositDataRoot = 9, // DEPRECATED - eth1 deposit tracking is not required since electra
+  // eth1 processing
+  phase0_eth1Data = 8, // timestamp -> Eth1Data
+  index_depositDataRoot = 9, // depositIndex -> Root<DepositData>
 
   // op pool
   // phase0_attestation = 10, // DEPRECATED on v0.25.0
   // phase0_aggregateAndProof = 11, // Root -> AggregateAndProof, DEPRECATED on v.27.0
-  // phase0_depositData = 12, // DEPRECATED - eth1 deposit tracking is not required since electra
+  phase0_depositData = 12, // [DEPRECATED] index -> DepositData
   phase0_exit = 13, // ValidatorIndex -> VoluntaryExit
   phase0_proposerSlashing = 14, // ValidatorIndex -> ProposerSlashing
   allForks_attesterSlashing = 15, // Root -> AttesterSlashing
@@ -31,15 +32,15 @@ export enum Bucket {
   allForks_checkpointState = 17, // Root -> BeaconState
 
   // allForks_pendingBlock = 25, // Root -> SignedBeaconBlock // DEPRECATED on v0.30.0
-  // phase0_depositEvent = 19, // DEPRECATED - eth1 deposit tracking is not required since electra
+  phase0_depositEvent = 19, // depositIndex -> DepositEvent
 
   index_stateArchiveRootIndex = 26, // State Root -> slot
 
   deneb_blobSidecars = 27, // DENEB BeaconBlockRoot -> BlobSidecars
   deneb_blobSidecarsArchive = 28, // DENEB BeaconBlockSlot -> BlobSidecars
 
-  // phase0_preGenesisState = 30, // DEPRECATED - genesis from eth1 is no longer supported
-  // phase0_preGenesisStateLastProcessedBlock = 31, // DEPRECATED - genesis from eth1 is no longer supported
+  phase0_preGenesisState = 30, // Single = phase0.BeaconState
+  phase0_preGenesisStateLastProcessedBlock = 31, // Single = Uint8
 
   // Lightclient server
   // altair_bestUpdatePerCommitteePeriod = 30, // DEPRECATED on v0.32.0

package/src/db/interface.ts

@@ -12,12 +12,16 @@ import {
   CheckpointHeaderRepository,
   DataColumnSidecarArchiveRepository,
   DataColumnSidecarRepository,
+  DepositDataRootRepository,
+  DepositEventRepository,
+  Eth1DataRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
   SyncCommitteeWitnessRepository,
   VoluntaryExitRepository,
 } from "./repositories/index.js";
+import {PreGenesisState, PreGenesisStateLastProcessedBlock} from "./single/index.js";
 
 /**
  * The DB service manages the data layer of the beacon chain
@@ -44,8 +48,17 @@ export interface IBeaconDb {
   voluntaryExit: VoluntaryExitRepository;
   proposerSlashing: ProposerSlashingRepository;
   attesterSlashing: AttesterSlashingRepository;
+  depositEvent: DepositEventRepository;
   blsToExecutionChange: BLSToExecutionChangeRepository;
 
+  // eth1 processing
+  preGenesisState: PreGenesisState;
+  preGenesisStateLastProcessedBlock: PreGenesisStateLastProcessedBlock;
+
+  // all deposit data roots and merkle tree
+  depositDataRoot: DepositDataRootRepository;
+  eth1Data: Eth1DataRepository;
+
   // lightclient
   bestLightClientUpdate: BestLightClientUpdateRepository;
   checkpointHeader: CheckpointHeaderRepository;

package/src/db/repositories/depositDataRoot.ts

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

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

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

@@ -8,6 +8,9 @@ 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";

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;
+  }
+}