@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,283 +0,0 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { toArray } from '@aztec/foundation/iterable';
-import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton, Range } from '@aztec/kv-store';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Body, type InBlock, L2Block, L2BlockHash } from '@aztec/stdlib/block';
-import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { BlockHeader, TxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
-
-import type { L1Published, L1PublishedData } from '../structs/published.js';
-
-export { type TxEffect, type TxHash, TxReceipt } from '@aztec/stdlib/tx';
-
-type BlockIndexValue = [blockNumber: number, index: number];
-
-type BlockStorage = {
-  header: Buffer;
-  archive: Buffer;
-  l1: L1PublishedData;
-};
-
-/**
- * LMDB implementation of the ArchiverDataStore interface.
- */
-export class BlockStore {
-  /** Map block number to block data */
-  #blocks: AztecAsyncMap<number, BlockStorage>;
-
-  /** Map block hash to block body */
-  #blockBodies: AztecAsyncMap<string, Buffer>;
-
-  /** Stores L1 block number in which the last processed L2 block was included */
-  #lastSynchedL1Block: AztecAsyncSingleton<bigint>;
-
-  /** Stores l2 block number of the last proven block */
-  #lastProvenL2Block: AztecAsyncSingleton<number>;
-
-  /** Stores l2 epoch number of the last proven epoch */
-  #lastProvenL2Epoch: AztecAsyncSingleton<number>;
-
-  /** Index mapping transaction hash (as a string) to its location in a block */
-  #txIndex: AztecAsyncMap<string, BlockIndexValue>;
-
-  /** Index mapping a contract's address (as a string) to its location in a block */
-  #contractIndex: AztecAsyncMap<string, BlockIndexValue>;
-
-  #log = createLogger('archiver:block_store');
-
-  constructor(private db: AztecAsyncKVStore) {
-    this.#blocks = db.openMap('archiver_blocks');
-    this.#blockBodies = db.openMap('archiver_block_bodies');
-    this.#txIndex = db.openMap('archiver_tx_index');
-    this.#contractIndex = db.openMap('archiver_contract_index');
-    this.#lastSynchedL1Block = db.openSingleton('archiver_last_synched_l1_block');
-    this.#lastProvenL2Block = db.openSingleton('archiver_last_proven_l2_block');
-    this.#lastProvenL2Epoch = db.openSingleton('archiver_last_proven_l2_epoch');
-  }
-
-  /**
-   * Append new blocks to the store's list.
-   * @param blocks - The L2 blocks to be added to the store.
-   * @returns True if the operation is successful.
-   */
-  async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
-    if (blocks.length === 0) {
-      return true;
-    }
-
-    return await this.db.transactionAsync(async () => {
-      for (const block of blocks) {
-        await this.#blocks.set(block.data.number, {
-          header: block.data.header.toBuffer(),
-          archive: block.data.archive.toBuffer(),
-          l1: block.l1,
-        });
-
-        for (let i = 0; i < block.data.body.txEffects.length; i++) {
-          const txEffect = block.data.body.txEffects[i];
-          await this.#txIndex.set(txEffect.txHash.toString(), [block.data.number, i]);
-        }
-
-        await this.#blockBodies.set((await block.data.hash()).toString(), block.data.body.toBuffer());
-      }
-
-      await this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
-      return true;
-    });
-  }
-
-  /**
-   * Unwinds blocks from the database
-   * @param from -  The tip of the chain, passed for verification purposes,
-   *                ensuring that we don't end up deleting something we did not intend
-   * @param blocksToUnwind - The number of blocks we are to unwind
-   * @returns True if the operation is successful
-   */
-  async unwindBlocks(from: number, blocksToUnwind: number) {
-    return await this.db.transactionAsync(async () => {
-      const last = await this.getSynchedL2BlockNumber();
-      if (from !== last) {
-        throw new Error(`Can only unwind blocks from the tip (requested ${from} but current tip is ${last})`);
-      }
-
-      for (let i = 0; i < blocksToUnwind; i++) {
-        const blockNumber = from - i;
-        const block = await this.getBlock(blockNumber);
-
-        if (block === undefined) {
-          this.#log.warn(`Cannot remove block ${blockNumber} from the store since we don't have it`);
-          continue;
-        }
-        await this.#blocks.delete(block.data.number);
-        await Promise.all(block.data.body.txEffects.map(tx => this.#txIndex.delete(tx.txHash.toString())));
-        const blockHash = (await block.data.hash()).toString();
-        await this.#blockBodies.delete(blockHash);
-        this.#log.debug(`Unwound block ${blockNumber} ${blockHash}`);
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param start - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks
-   */
-  async *getBlocks(start: number, limit: number): AsyncIterableIterator<L1Published<L2Block>> {
-    for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
-      const block = await this.getBlockFromBlockStorage(blockStorage);
-      yield block;
-    }
-  }
-
-  /**
-   * Gets an L2 block.
-   * @param blockNumber - The number of the block to return.
-   * @returns The requested L2 block.
-   */
-  async getBlock(blockNumber: number): Promise<L1Published<L2Block> | undefined> {
-    const blockStorage = await this.#blocks.getAsync(blockNumber);
-    if (!blockStorage || !blockStorage.header) {
-      return Promise.resolve(undefined);
-    }
-
-    return this.getBlockFromBlockStorage(blockStorage);
-  }
-
-  /**
-   * Gets the headers for a sequence of L2 blocks.
-   * @param start - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 block headers
-   */
-  async *getBlockHeaders(start: number, limit: number): AsyncIterableIterator<BlockHeader> {
-    for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
-      yield BlockHeader.fromBuffer(blockStorage.header);
-    }
-  }
-
-  private async getBlockFromBlockStorage(blockStorage: BlockStorage) {
-    const header = BlockHeader.fromBuffer(blockStorage.header);
-    const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
-    const blockHash = (await header.hash()).toString();
-    const blockBodyBuffer = await this.#blockBodies.getAsync(blockHash);
-    if (blockBodyBuffer === undefined) {
-      throw new Error(
-        `Could not retrieve body for block ${header.globalVariables.blockNumber.toNumber()} ${blockHash}`,
-      );
-    }
-    const body = Body.fromBuffer(blockBodyBuffer);
-
-    const l2Block = new L2Block(archive, header, body);
-    return { data: l2Block, l1: blockStorage.l1 };
-  }
-
-  /**
-   * Gets a tx effect.
-   * @param txHash - The txHash of the tx corresponding to the tx effect.
-   * @returns The requested tx effect (or undefined if not found).
-   */
-  async getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined> {
-    const [blockNumber, txIndex] = (await this.getTxLocation(txHash)) ?? [];
-    if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
-      return undefined;
-    }
-
-    const block = await this.getBlock(blockNumber);
-    if (!block) {
-      return undefined;
-    }
-
-    return {
-      data: block.data.body.txEffects[txIndex],
-      l2BlockNumber: block.data.number,
-      l2BlockHash: (await block.data.hash()).toString(),
-    };
-  }
-
-  /**
-   * Gets a receipt of a settled tx.
-   * @param txHash - The hash of a tx we try to get the receipt for.
-   * @returns The requested tx receipt (or undefined if not found).
-   */
-  async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
-    const [blockNumber, txIndex] = (await this.getTxLocation(txHash)) ?? [];
-    if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
-      return undefined;
-    }
-
-    const block = (await this.getBlock(blockNumber))!;
-    const tx = block.data.body.txEffects[txIndex];
-
-    return new TxReceipt(
-      txHash,
-      TxReceipt.statusFromRevertCode(tx.revertCode),
-      '',
-      tx.transactionFee.toBigInt(),
-      L2BlockHash.fromField(await block.data.hash()),
-      block.data.number,
-    );
-  }
-
-  /**
-   * Looks up which block included the requested tx effect.
-   * @param txHash - The txHash of the tx.
-   * @returns The block number and index of the tx.
-   */
-  getTxLocation(txHash: TxHash): Promise<[blockNumber: number, txIndex: number] | undefined> {
-    return this.#txIndex.getAsync(txHash.toString());
-  }
-
-  /**
-   * Looks up which block deployed a particular contract.
-   * @param contractAddress - The address of the contract to look up.
-   * @returns The block number and index of the contract.
-   */
-  getContractLocation(contractAddress: AztecAddress): Promise<[blockNumber: number, index: number] | undefined> {
-    return this.#contractIndex.getAsync(contractAddress.toString());
-  }
-
-  /**
-   * Gets the number of the latest L2 block processed.
-   * @returns The number of the latest L2 block processed.
-   */
-  async getSynchedL2BlockNumber(): Promise<number> {
-    const [lastBlockNumber] = await toArray(this.#blocks.keysAsync({ reverse: true, limit: 1 }));
-    return typeof lastBlockNumber === 'number' ? lastBlockNumber : INITIAL_L2_BLOCK_NUM - 1;
-  }
-
-  /**
-   * Gets the most recent L1 block processed.
-   * @returns The L1 block that published the latest L2 block
-   */
-  getSynchedL1BlockNumber(): Promise<bigint | undefined> {
-    return this.#lastSynchedL1Block.getAsync();
-  }
-
-  setSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    return this.#lastSynchedL1Block.set(l1BlockNumber);
-  }
-
-  async getProvenL2BlockNumber(): Promise<number> {
-    return (await this.#lastProvenL2Block.getAsync()) ?? 0;
-  }
-
-  setProvenL2BlockNumber(blockNumber: number) {
-    return this.#lastProvenL2Block.set(blockNumber);
-  }
-
-  #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'limit'>> {
-    if (limit < 1) {
-      throw new Error(`Invalid limit: ${limit}`);
-    }
-
-    if (start < INITIAL_L2_BLOCK_NUM) {
-      throw new Error(`Invalid start: ${start}`);
-    }
-
-    return { start, limit };
-  }
-}

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,358 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { toArray } from '@aztec/foundation/iterable';
-import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, StoreSize } from '@aztec/kv-store';
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { InBlock, L2Block } from '@aztec/stdlib/block';
-import type {
-  ContractClassPublic,
-  ContractInstanceUpdateWithAddress,
-  ContractInstanceWithAddress,
-  ExecutablePrivateFunctionWithMembershipProof,
-  UnconstrainedFunctionWithMembershipProof,
-} from '@aztec/stdlib/contract';
-import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
-import { type LogFilter, PrivateLog, type TxScopedL2Log } from '@aztec/stdlib/logs';
-import type { InboxLeaf } from '@aztec/stdlib/messaging';
-import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
-
-import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
-import type { DataRetrieval } from '../structs/data_retrieval.js';
-import type { L1Published } from '../structs/published.js';
-import { BlockStore } from './block_store.js';
-import { ContractClassStore } from './contract_class_store.js';
-import { ContractInstanceStore } from './contract_instance_store.js';
-import { LogStore } from './log_store.js';
-import { MessageStore } from './message_store.js';
-import { NullifierStore } from './nullifier_store.js';
-
-/**
- * LMDB implementation of the ArchiverDataStore interface.
- */
-export class KVArchiverDataStore implements ArchiverDataStore {
-  public static readonly SCHEMA_VERSION = 1;
-
-  #blockStore: BlockStore;
-  #logStore: LogStore;
-  #nullifierStore: NullifierStore;
-  #messageStore: MessageStore;
-  #contractClassStore: ContractClassStore;
-  #contractInstanceStore: ContractInstanceStore;
-  private functionNames = new Map<string, string>();
-
-  #log = createLogger('archiver:data-store');
-
-  constructor(private db: AztecAsyncKVStore, logsMaxPageSize: number = 1000) {
-    this.#blockStore = new BlockStore(db);
-    this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
-    this.#messageStore = new MessageStore(db);
-    this.#contractClassStore = new ContractClassStore(db);
-    this.#contractInstanceStore = new ContractInstanceStore(db);
-    this.#nullifierStore = new NullifierStore(db);
-  }
-
-  // TODO:  These function names are in memory only as they are for development/debugging. They require the full contract
-  //        artifact supplied to the node out of band. This should be reviewed and potentially removed as part of
-  //        the node api cleanup process.
-  getContractFunctionName(_address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    return Promise.resolve(this.functionNames.get(selector.toString()));
-  }
-
-  async registerContractFunctionSignatures(_address: AztecAddress, signatures: string[]): Promise<void> {
-    for (const sig of signatures) {
-      try {
-        const selector = await FunctionSelector.fromSignature(sig);
-        this.functionNames.set(selector.toString(), sig.slice(0, sig.indexOf('(')));
-      } catch {
-        this.#log.warn(`Failed to parse signature: ${sig}. Ignoring`);
-      }
-    }
-  }
-
-  getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    return this.#contractClassStore.getContractClass(id);
-  }
-
-  getContractClassIds(): Promise<Fr[]> {
-    return this.#contractClassStore.getContractClassIds();
-  }
-
-  async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    const contract = this.#contractInstanceStore.getContractInstance(address, await this.getSynchedL2BlockNumber());
-    return contract;
-  }
-
-  async addContractClasses(
-    data: ContractClassPublic[],
-    bytecodeCommitments: Fr[],
-    blockNumber: number,
-  ): Promise<boolean> {
-    return (
-      await Promise.all(
-        data.map((c, i) => this.#contractClassStore.addContractClass(c, bytecodeCommitments[i], blockNumber)),
-      )
-    ).every(Boolean);
-  }
-
-  async deleteContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
-    return (await Promise.all(data.map(c => this.#contractClassStore.deleteContractClasses(c, blockNumber)))).every(
-      Boolean,
-    );
-  }
-
-  getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
-    return this.#contractClassStore.getBytecodeCommitment(contractClassId);
-  }
-
-  addFunctions(
-    contractClassId: Fr,
-    privateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
-    unconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[],
-  ): Promise<boolean> {
-    return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, unconstrainedFunctions);
-  }
-
-  async addContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
-    return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
-  }
-
-  async deleteContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
-    return (await Promise.all(data.map(c => this.#contractInstanceStore.deleteContractInstance(c)))).every(Boolean);
-  }
-
-  async addContractInstanceUpdates(data: ContractInstanceUpdateWithAddress[], blockNumber: number): Promise<boolean> {
-    return (
-      await Promise.all(
-        data.map((update, logIndex) =>
-          this.#contractInstanceStore.addContractInstanceUpdate(update, blockNumber, logIndex),
-        ),
-      )
-    ).every(Boolean);
-  }
-  async deleteContractInstanceUpdates(
-    data: ContractInstanceUpdateWithAddress[],
-    blockNumber: number,
-  ): Promise<boolean> {
-    return (
-      await Promise.all(
-        data.map((update, logIndex) =>
-          this.#contractInstanceStore.deleteContractInstanceUpdate(update, blockNumber, logIndex),
-        ),
-      )
-    ).every(Boolean);
-  }
-
-  /**
-   * Append new blocks to the store's list.
-   * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
-   * @returns True if the operation is successful.
-   */
-  addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
-    return this.#blockStore.addBlocks(blocks);
-  }
-
-  /**
-   * Unwinds blocks from the database
-   * @param from -  The tip of the chain, passed for verification purposes,
-   *                ensuring that we don't end up deleting something we did not intend
-   * @param blocksToUnwind - The number of blocks we are to unwind
-   * @returns True if the operation is successful
-   */
-  unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean> {
-    return this.#blockStore.unwindBlocks(from, blocksToUnwind);
-  }
-
-  /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   *
-   * @param start - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks
-   */
-  getBlocks(start: number, limit: number): Promise<L1Published<L2Block>[]> {
-    return toArray(this.#blockStore.getBlocks(start, limit));
-  }
-
-  /**
-   * Gets up to `limit` amount of L2 blocks headers starting from `from`.
-   *
-   * @param start - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks
-   */
-  getBlockHeaders(start: number, limit: number): Promise<BlockHeader[]> {
-    return toArray(this.#blockStore.getBlockHeaders(start, limit));
-  }
-
-  /**
-   * Gets a tx effect.
-   * @param txHash - The txHash of the tx corresponding to the tx effect.
-   * @returns The requested tx effect (or undefined if not found).
-   */
-  getTxEffect(txHash: TxHash) {
-    return this.#blockStore.getTxEffect(txHash);
-  }
-
-  /**
-   * Gets a receipt of a settled tx.
-   * @param txHash - The hash of a tx we try to get the receipt for.
-   * @returns The requested tx receipt (or undefined if not found).
-   */
-  getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
-    return this.#blockStore.getSettledTxReceipt(txHash);
-  }
-
-  /**
-   * Append new logs to the store's list.
-   * @param blocks - The blocks for which to add the logs.
-   * @returns True if the operation is successful.
-   */
-  addLogs(blocks: L2Block[]): Promise<boolean> {
-    return this.#logStore.addLogs(blocks);
-  }
-
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
-    return this.#logStore.deleteLogs(blocks);
-  }
-
-  /**
-   * Append new nullifiers to the store's list.
-   * @param blocks - The blocks for which to add the nullifiers.
-   * @returns True if the operation is successful.
-   */
-  addNullifiers(blocks: L2Block[]): Promise<boolean> {
-    return this.#nullifierStore.addNullifiers(blocks);
-  }
-
-  deleteNullifiers(blocks: L2Block[]): Promise<boolean> {
-    return this.#nullifierStore.deleteNullifiers(blocks);
-  }
-
-  findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]> {
-    return this.#nullifierStore.findNullifiersIndexesWithBlock(blockNumber, nullifiers);
-  }
-
-  getTotalL1ToL2MessageCount(): Promise<bigint> {
-    return this.#messageStore.getTotalL1ToL2MessageCount();
-  }
-
-  /**
-   * Append L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store and the last processed L1 block.
-   * @returns True if the operation is successful.
-   */
-  addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
-    return this.#messageStore.addL1ToL2Messages(messages);
-  }
-
-  /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
-   * @param l1ToL2Message - The L1 to L2 message.
-   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
-   */
-  getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
-    return this.#messageStore.getL1ToL2MessageIndex(l1ToL2Message);
-  }
-
-  /**
-   * Gets L1 to L2 message (to be) included in a given block.
-   * @param blockNumber - L2 block number to get messages for.
-   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
-   */
-  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
-    return this.#messageStore.getL1ToL2Messages(blockNumber);
-  }
-
-  /**
-   * Retrieves all private logs from up to `limit` blocks, starting from the block number `from`.
-   * @param from - The block number from which to begin retrieving logs.
-   * @param limit - The maximum number of blocks to retrieve logs from.
-   * @returns An array of private logs from the specified range of blocks.
-   */
-  getPrivateLogs(from: number, limit: number): Promise<PrivateLog[]> {
-    return this.#logStore.getPrivateLogs(from, limit);
-  }
-
-  /**
-   * Gets all logs that match any of the received tags (i.e. logs with their first field equal to a tag).
-   * @param tags - The tags to filter the logs by.
-   * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
-   * that tag.
-   */
-  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
-    try {
-      return this.#logStore.getLogsByTags(tags);
-    } catch (err) {
-      return Promise.reject(err);
-    }
-  }
-
-  /**
-   * Gets public logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */
-  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
-    try {
-      return this.#logStore.getPublicLogs(filter);
-    } catch (err) {
-      return Promise.reject(err);
-    }
-  }
-
-  /**
-   * Gets contract class logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */
-  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
-    try {
-      return this.#logStore.getContractClassLogs(filter);
-    } catch (err) {
-      return Promise.reject(err);
-    }
-  }
-
-  /**
-   * Gets the number of the latest L2 block processed.
-   * @returns The number of the latest L2 block processed.
-   */
-  getSynchedL2BlockNumber(): Promise<number> {
-    return this.#blockStore.getSynchedL2BlockNumber();
-  }
-
-  getProvenL2BlockNumber(): Promise<number> {
-    return this.#blockStore.getProvenL2BlockNumber();
-  }
-
-  async setProvenL2BlockNumber(blockNumber: number) {
-    await this.#blockStore.setProvenL2BlockNumber(blockNumber);
-  }
-
-  async setBlockSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
-  }
-
-  async setMessageSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    await this.#messageStore.setSynchedL1BlockNumber(l1BlockNumber);
-  }
-
-  /**
-   * Gets the last L1 block number processed by the archiver
-   */
-  async getSynchPoint(): Promise<ArchiverL1SynchPoint> {
-    const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
-      this.#blockStore.getSynchedL1BlockNumber(),
-      this.#messageStore.getSynchedL1BlockNumber(),
-    ]);
-    return {
-      blocksSynchedTo,
-      messagesSynchedTo,
-    };
-  }
-
-  public estimateSize(): Promise<StoreSize> {
-    return this.db.estimateSize();
-  }
-}