@aztec/archiver 0.0.1-commit.03f7ef2 → 0.0.1-commit.04d373f

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -1,176 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { toArray } from '@aztec/foundation/iterable';
-import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import type {
-  ContractClassPublic,
-  ContractClassPublicWithBlockNumber,
-  ExecutablePrivateFunctionWithMembershipProof,
-  UtilityFunctionWithMembershipProof,
-} from '@aztec/stdlib/contract';
-import { Vector } from '@aztec/stdlib/types';
-
-/**
- * LMDB implementation of the ArchiverDataStore interface.
- */
-export class ContractClassStore {
-  #contractClasses: AztecAsyncMap<string, Buffer>;
-  #bytecodeCommitments: AztecAsyncMap<string, Buffer>;
-
-  constructor(private db: AztecAsyncKVStore) {
-    this.#contractClasses = db.openMap('archiver_contract_classes');
-    this.#bytecodeCommitments = db.openMap('archiver_bytecode_commitments');
-  }
-
-  async addContractClass(
-    contractClass: ContractClassPublic,
-    bytecodeCommitment: Fr,
-    blockNumber: number,
-  ): Promise<void> {
-    await this.#contractClasses.setIfNotExists(
-      contractClass.id.toString(),
-      serializeContractClassPublic({ ...contractClass, l2BlockNumber: blockNumber }),
-    );
-    await this.#bytecodeCommitments.setIfNotExists(contractClass.id.toString(), bytecodeCommitment.toBuffer());
-  }
-
-  async deleteContractClasses(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
-    const restoredContractClass = await this.#contractClasses.getAsync(contractClass.id.toString());
-    if (restoredContractClass && deserializeContractClassPublic(restoredContractClass).l2BlockNumber >= blockNumber) {
-      await this.#contractClasses.delete(contractClass.id.toString());
-      await this.#bytecodeCommitments.delete(contractClass.id.toString());
-    }
-  }
-
-  async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    const contractClass = await this.#contractClasses.getAsync(id.toString());
-    return contractClass && { ...deserializeContractClassPublic(contractClass), id };
-  }
-
-  async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
-    const value = await this.#bytecodeCommitments.getAsync(id.toString());
-    return value === undefined ? undefined : Fr.fromBuffer(value);
-  }
-
-  async getContractClassIds(): Promise<Fr[]> {
-    return (await toArray(this.#contractClasses.keysAsync())).map(key => Fr.fromHexString(key));
-  }
-
-  async addFunctions(
-    contractClassId: Fr,
-    newPrivateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
-    newUtilityFunctions: UtilityFunctionWithMembershipProof[],
-  ): Promise<boolean> {
-    await this.db.transactionAsync(async () => {
-      const existingClassBuffer = await this.#contractClasses.getAsync(contractClassId.toString());
-      if (!existingClassBuffer) {
-        throw new Error(`Unknown contract class ${contractClassId} when adding private functions to store`);
-      }
-
-      const existingClass = deserializeContractClassPublic(existingClassBuffer);
-      const { privateFunctions: existingPrivateFns, utilityFunctions: existingUtilityFns } = existingClass;
-
-      const updatedClass: Omit<ContractClassPublicWithBlockNumber, 'id'> = {
-        ...existingClass,
-        privateFunctions: [
-          ...existingPrivateFns,
-          ...newPrivateFunctions.filter(newFn => !existingPrivateFns.some(f => f.selector.equals(newFn.selector))),
-        ],
-        utilityFunctions: [
-          ...existingUtilityFns,
-          ...newUtilityFunctions.filter(newFn => !existingUtilityFns.some(f => f.selector.equals(newFn.selector))),
-        ],
-      };
-      await this.#contractClasses.set(contractClassId.toString(), serializeContractClassPublic(updatedClass));
-    });
-
-    return true;
-  }
-}
-
-function serializeContractClassPublic(contractClass: Omit<ContractClassPublicWithBlockNumber, 'id'>): Buffer {
-  return serializeToBuffer(
-    contractClass.l2BlockNumber,
-    numToUInt8(contractClass.version),
-    contractClass.artifactHash,
-    contractClass.privateFunctions.length,
-    contractClass.privateFunctions.map(serializePrivateFunction),
-    contractClass.utilityFunctions.length,
-    contractClass.utilityFunctions.map(serializeUtilityFunction),
-    contractClass.packedBytecode.length,
-    contractClass.packedBytecode,
-    contractClass.privateFunctionsRoot,
-  );
-}
-
-function serializePrivateFunction(fn: ExecutablePrivateFunctionWithMembershipProof): Buffer {
-  return serializeToBuffer(
-    fn.selector,
-    fn.vkHash,
-    fn.bytecode.length,
-    fn.bytecode,
-    fn.functionMetadataHash,
-    fn.artifactMetadataHash,
-    fn.utilityFunctionsTreeRoot,
-    new Vector(fn.privateFunctionTreeSiblingPath),
-    fn.privateFunctionTreeLeafIndex,
-    new Vector(fn.artifactTreeSiblingPath),
-    fn.artifactTreeLeafIndex,
-  );
-}
-
-function serializeUtilityFunction(fn: UtilityFunctionWithMembershipProof): Buffer {
-  return serializeToBuffer(
-    fn.selector,
-    fn.bytecode.length,
-    fn.bytecode,
-    fn.functionMetadataHash,
-    fn.artifactMetadataHash,
-    fn.privateFunctionsArtifactTreeRoot,
-    new Vector(fn.artifactTreeSiblingPath),
-    fn.artifactTreeLeafIndex,
-  );
-}
-
-function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublicWithBlockNumber, 'id'> {
-  const reader = BufferReader.asReader(buffer);
-  return {
-    l2BlockNumber: reader.readNumber(),
-    version: reader.readUInt8() as 1,
-    artifactHash: reader.readObject(Fr),
-    privateFunctions: reader.readVector({ fromBuffer: deserializePrivateFunction }),
-    utilityFunctions: reader.readVector({ fromBuffer: deserializeUtilityFunction }),
-    packedBytecode: reader.readBuffer(),
-    privateFunctionsRoot: reader.readObject(Fr),
-  };
-}
-
-function deserializePrivateFunction(buffer: Buffer | BufferReader): ExecutablePrivateFunctionWithMembershipProof {
-  const reader = BufferReader.asReader(buffer);
-  return {
-    selector: reader.readObject(FunctionSelector),
-    vkHash: reader.readObject(Fr),
-    bytecode: reader.readBuffer(),
-    functionMetadataHash: reader.readObject(Fr),
-    artifactMetadataHash: reader.readObject(Fr),
-    utilityFunctionsTreeRoot: reader.readObject(Fr),
-    privateFunctionTreeSiblingPath: reader.readVector(Fr),
-    privateFunctionTreeLeafIndex: reader.readNumber(),
-    artifactTreeSiblingPath: reader.readVector(Fr),
-    artifactTreeLeafIndex: reader.readNumber(),
-  };
-}
-
-function deserializeUtilityFunction(buffer: Buffer | BufferReader): UtilityFunctionWithMembershipProof {
-  const reader = BufferReader.asReader(buffer);
-  return {
-    selector: reader.readObject(FunctionSelector),
-    bytecode: reader.readBuffer(),
-    functionMetadataHash: reader.readObject(Fr),
-    artifactMetadataHash: reader.readObject(Fr),
-    privateFunctionsArtifactTreeRoot: reader.readObject(Fr),
-    artifactTreeSiblingPath: reader.readVector(Fr),
-    artifactTreeLeafIndex: reader.readNumber(),
-  };
-}

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,438 +0,0 @@
-import type { L1BlockId } from '@aztec/ethereum/l1-types';
-import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import { toArray } from '@aztec/foundation/iterable';
-import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, CustomRange, StoreSize } from '@aztec/kv-store';
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateBlockResult } from '@aztec/stdlib/block';
-import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import type {
-  ContractClassPublic,
-  ContractDataSource,
-  ContractInstanceUpdateWithAddress,
-  ContractInstanceWithAddress,
-  ExecutablePrivateFunctionWithMembershipProof,
-  UtilityFunctionWithMembershipProof,
-} from '@aztec/stdlib/contract';
-import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
-import type { LogFilter, SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
-import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
-
-import { join } from 'path';
-
-import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
-import type { InboxMessage } from '../structs/inbox_message.js';
-import { BlockStore, type CheckpointData } 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';
-
-export const ARCHIVER_DB_VERSION = 5;
-export const MAX_FUNCTION_SIGNATURES = 1000;
-export const MAX_FUNCTION_NAME_LEN = 256;
-
-/**
- * LMDB implementation of the ArchiverDataStore interface.
- */
-export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSource {
-  public static readonly SCHEMA_VERSION = ARCHIVER_DB_VERSION;
-
-  #blockStore: BlockStore;
-  #logStore: LogStore;
-  #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);
-  }
-
-  public transactionAsync<T>(callback: () => Promise<T>): Promise<T> {
-    return this.db.transactionAsync(callback);
-  }
-
-  public getBlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getLatestL2BlockNumber();
-  }
-
-  public async getContract(
-    address: AztecAddress,
-    maybeTimestamp?: UInt64,
-  ): Promise<ContractInstanceWithAddress | undefined> {
-    const [header] = await this.getBlockHeaders(await this.getBlockNumber(), 1);
-    const timestamp = maybeTimestamp ?? header!.globalVariables.timestamp;
-    return this.getContractInstance(address, timestamp);
-  }
-
-  public async backupTo(path: string, compress = true): Promise<string> {
-    await this.db.backupTo(path, compress);
-    return join(path, 'data.mdb');
-  }
-
-  public close() {
-    return this.db.close();
-  }
-
-  getDebugFunctionName(_address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    return Promise.resolve(this.functionNames.get(selector.toString()));
-  }
-
-  async registerContractFunctionSignatures(signatures: string[]): Promise<void> {
-    for (const sig of signatures) {
-      if (this.functionNames.size > MAX_FUNCTION_SIGNATURES) {
-        return;
-      }
-      try {
-        const selector = await FunctionSelector.fromSignature(sig);
-        this.functionNames.set(selector.toString(), sig.slice(0, sig.indexOf('(')).slice(0, MAX_FUNCTION_NAME_LEN));
-      } 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();
-  }
-
-  getContractInstance(address: AztecAddress, timestamp: UInt64): Promise<ContractInstanceWithAddress | undefined> {
-    return this.#contractInstanceStore.getContractInstance(address, timestamp);
-  }
-
-  getContractInstanceDeploymentBlockNumber(address: AztecAddress): Promise<number | undefined> {
-    return this.#contractInstanceStore.getContractInstanceDeploymentBlockNumber(address);
-  }
-
-  async addContractClasses(
-    data: ContractClassPublic[],
-    bytecodeCommitments: Fr[],
-    blockNumber: BlockNumber,
-  ): Promise<boolean> {
-    return (
-      await Promise.all(
-        data.map((c, i) => this.#contractClassStore.addContractClass(c, bytecodeCommitments[i], blockNumber)),
-      )
-    ).every(Boolean);
-  }
-
-  async deleteContractClasses(data: ContractClassPublic[], blockNumber: BlockNumber): 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[],
-    utilityFunctions: UtilityFunctionWithMembershipProof[],
-  ): Promise<boolean> {
-    return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, utilityFunctions);
-  }
-
-  async addContractInstances(data: ContractInstanceWithAddress[], blockNumber: BlockNumber): Promise<boolean> {
-    return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c, blockNumber)))).every(
-      Boolean,
-    );
-  }
-
-  async deleteContractInstances(data: ContractInstanceWithAddress[], _blockNumber: BlockNumber): Promise<boolean> {
-    return (await Promise.all(data.map(c => this.#contractInstanceStore.deleteContractInstance(c)))).every(Boolean);
-  }
-
-  async addContractInstanceUpdates(data: ContractInstanceUpdateWithAddress[], timestamp: UInt64): Promise<boolean> {
-    return (
-      await Promise.all(
-        data.map((update, logIndex) =>
-          this.#contractInstanceStore.addContractInstanceUpdate(update, timestamp, logIndex),
-        ),
-      )
-    ).every(Boolean);
-  }
-  async deleteContractInstanceUpdates(data: ContractInstanceUpdateWithAddress[], timestamp: UInt64): Promise<boolean> {
-    return (
-      await Promise.all(
-        data.map((update, logIndex) =>
-          this.#contractInstanceStore.deleteContractInstanceUpdate(update, timestamp, 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: L2BlockNew[], opts: { force?: boolean; checkpointNumber?: number } = {}): Promise<boolean> {
-    return this.#blockStore.addBlocks(blocks, opts);
-  }
-
-  getRangeOfCheckpoints(from: CheckpointNumber, limit: number): Promise<CheckpointData[]> {
-    return this.#blockStore.getRangeOfCheckpoints(from, limit);
-  }
-  getLatestBlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getLatestBlockNumber();
-  }
-
-  /**
-   * Unwinds checkpoints 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 checkpointsToUnwind - The number of checkpoints we are to unwind
-   * @returns True if the operation is successful
-   */
-  unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
-    return this.#blockStore.unwindCheckpoints(from, checkpointsToUnwind);
-  }
-
-  addCheckpoints(checkpoints: PublishedCheckpoint[]): Promise<boolean> {
-    return this.#blockStore.addCheckpoints(checkpoints);
-  }
-
-  getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
-    return this.#blockStore.getCheckpointedBlock(number);
-  }
-  getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
-    return this.#blockStore.getCheckpointedBlockByHash(blockHash);
-  }
-  getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
-    return this.#blockStore.getCheckpointedBlockByArchive(archive);
-  }
-  getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
-    return this.#blockStore.getBlock(number);
-  }
-  getBlockByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
-    return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
-  }
-  getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
-    return this.#blockStore.getBlockByArchive(archive);
-  }
-  getBlocks(from: BlockNumber, limit: BlockNumber): Promise<L2BlockNew[]> {
-    return toArray(this.#blockStore.getBlocks(from, 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: BlockNumber, limit: number): Promise<BlockHeader[]> {
-    return toArray(this.#blockStore.getBlockHeaders(start, limit));
-  }
-
-  getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
-    return this.#blockStore.getBlockHeaderByHash(L2BlockHash.fromField(blockHash));
-  }
-
-  getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
-    return this.#blockStore.getBlockHeaderByArchive(archive);
-  }
-
-  /**
-   * Gets a tx effect.
-   * @param txHash - The hash of the tx corresponding to the tx effect.
-   * @returns The requested tx effect with block info (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: L2BlockNew[]): Promise<boolean> {
-    return this.#logStore.addLogs(blocks);
-  }
-
-  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
-    return this.#logStore.deleteLogs(blocks);
-  }
-
-  getTotalL1ToL2MessageCount(): Promise<bigint> {
-    return this.#messageStore.getTotalL1ToL2MessageCount();
-  }
-
-  getLastL1ToL2Message(): Promise<InboxMessage | undefined> {
-    return this.#messageStore.getLastMessage();
-  }
-
-  /**
-   * Append L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store.
-   */
-  addL1ToL2Messages(messages: InboxMessage[]): Promise<void> {
-    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 checkpoint.
-   * @param checkpointNumber - Checkpoint number to get messages for.
-   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
-   */
-  getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
-    return this.#messageStore.getL1ToL2Messages(checkpointNumber);
-  }
-
-  getPrivateLogsByTags(tags: SiloedTag[]): Promise<TxScopedL2Log[][]> {
-    try {
-      return this.#logStore.getPrivateLogsByTags(tags);
-    } catch (err) {
-      return Promise.reject(err);
-    }
-  }
-
-  getPublicLogsByTagsFromContract(contractAddress: AztecAddress, tags: Tag[]): Promise<TxScopedL2Log[][]> {
-    try {
-      return this.#logStore.getPublicLogsByTagsFromContract(contractAddress, 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);
-    }
-  }
-
-  getProvenCheckpointNumber(): Promise<CheckpointNumber> {
-    return this.#blockStore.getProvenCheckpointNumber();
-  }
-
-  async setProvenCheckpointNumber(checkpointNumber: CheckpointNumber) {
-    await this.#blockStore.setProvenCheckpointNumber(checkpointNumber);
-  }
-
-  async setBlockSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
-  }
-
-  async setMessageSynchedL1Block(l1Block: L1BlockId) {
-    await this.#messageStore.setSynchedL1Block(l1Block);
-  }
-
-  getProvenBlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getProvenBlockNumber();
-  }
-
-  /**
-   * 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.getSynchedL1Block(),
-    ]);
-    return {
-      blocksSynchedTo,
-      messagesSynchedTo,
-    };
-  }
-
-  public estimateSize(): Promise<StoreSize> {
-    return this.db.estimateSize();
-  }
-
-  public rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber: CheckpointNumber): Promise<void> {
-    return this.#messageStore.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
-  }
-
-  public iterateL1ToL2Messages(range: CustomRange<bigint> = {}): AsyncIterableIterator<InboxMessage> {
-    return this.#messageStore.iterateL1ToL2Messages(range);
-  }
-
-  public removeL1ToL2Messages(startIndex: bigint): Promise<void> {
-    return this.#messageStore.removeL1ToL2Messages(startIndex);
-  }
-
-  public getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined> {
-    return this.#blockStore.getPendingChainValidationStatus();
-  }
-
-  public setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
-    return this.#blockStore.setPendingChainValidationStatus(status);
-  }
-
-  public getCheckpointedL2BlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getCheckpointedL2BlockNumber();
-  }
-  public getSynchedCheckpointNumber(): Promise<CheckpointNumber> {
-    return this.#blockStore.getLatestCheckpointNumber();
-  }
-  async setCheckpointSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void> {
-    await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
-  }
-
-  getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2BlockNew[] | undefined> {
-    return this.#blockStore.getBlocksForCheckpoint(checkpointNumber);
-  }
-
-  getCheckpointData(checkpointNumber: CheckpointNumber): Promise<CheckpointData | undefined> {
-    return this.#blockStore.getCheckpointData(checkpointNumber);
-  }
-}