@aztec/archiver 0.16.0 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/archiver",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -34,13 +34,14 @@
     "rootDir": "./src"
   },
   "dependencies": {
-    "@aztec/circuits.js": "0.16.0",
-    "@aztec/ethereum": "0.16.0",
-    "@aztec/foundation": "0.16.0",
-    "@aztec/l1-artifacts": "0.16.0",
-    "@aztec/types": "0.16.0",
+    "@aztec/circuits.js": "0.16.1",
+    "@aztec/ethereum": "0.16.1",
+    "@aztec/foundation": "0.16.1",
+    "@aztec/l1-artifacts": "0.16.1",
+    "@aztec/types": "0.16.1",
     "@types/lodash.omit": "^4.5.7",
     "debug": "^4.3.4",
+    "lmdb": "^2.9.1",
     "lodash.omit": "^4.5.0",
     "tsc-watch": "^6.0.0",
     "tslib": "^2.5.0",

package/src/archiver/archiver.ts

@@ -6,7 +6,6 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { RegistryAbi } from '@aztec/l1-artifacts';
 import {
   ContractData,
   ContractDataSource,
@@ -26,9 +25,9 @@ import {
 } from '@aztec/types';
 
 import omit from 'lodash.omit';
-import { Chain, HttpTransport, PublicClient, createPublicClient, getContract, http } from 'viem';
+import { Chain, HttpTransport, PublicClient, createPublicClient, http } from 'viem';
 
-import { ArchiverDataStore, MemoryArchiverStore } from './archiver_store.js';
+import { ArchiverDataStore } from './archiver_store.js';
 import { ArchiverConfig } from './config.js';
 import {
   retrieveBlocks,
@@ -53,11 +52,6 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
    */
   private nextL2BlockFromL1Block = 0n;
 
-  /**
-   * Last Processed Block Number
-   */
-  private lastProcessedL1BlockNumber = 0n;
-
   /**
    * Use this to track logged block in order to avoid repeating the same message.
    */
@@ -81,22 +75,23 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
     private readonly inboxAddress: EthAddress,
     private readonly registryAddress: EthAddress,
     private readonly contractDeploymentEmitterAddress: EthAddress,
-    searchStartBlock: number,
     private readonly store: ArchiverDataStore,
     private readonly pollingIntervalMs = 10_000,
     private readonly log: DebugLogger = createDebugLogger('aztec:archiver'),
-  ) {
-    this.nextL2BlockFromL1Block = BigInt(searchStartBlock);
-    this.lastProcessedL1BlockNumber = BigInt(searchStartBlock);
-  }
+  ) {}
 
   /**
    * Creates a new instance of the Archiver and blocks until it syncs from chain.
    * @param config - The archiver's desired configuration.
+   * @param archiverStore - The backing store for the archiver.
    * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
    * @returns - An instance of the archiver.
    */
-  public static async createAndSync(config: ArchiverConfig, blockUntilSynced = true): Promise<Archiver> {
+  public static async createAndSync(
+    config: ArchiverConfig,
+    archiverStore: ArchiverDataStore,
+    blockUntilSynced = true,
+  ): Promise<Archiver> {
     const chain = createEthereumChain(config.rpcUrl, config.apiKey);
     const publicClient = createPublicClient({
       chain: chain.chainInfo,
@@ -104,23 +99,12 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
       pollingInterval: config.viemPollingIntervalMS,
     });
 
-    // ask the registry for the block number when the rollup was deployed
-    // this is the block from which archiver has to search from
-    const registryContract = getContract({
-      address: config.l1Contracts.registryAddress.toString(),
-      abi: RegistryAbi,
-      publicClient,
-    });
-    const searchStartBlock = Number((await registryContract.read.getCurrentSnapshot()).blockNumber);
-
-    const archiverStore = new MemoryArchiverStore(config.maxLogs ?? 1000);
     const archiver = new Archiver(
       publicClient,
       config.l1Contracts.rollupAddress,
       config.l1Contracts.inboxAddress,
       config.l1Contracts.registryAddress,
       config.l1Contracts.contractDeploymentEmitterAddress,
-      searchStartBlock,
       archiverStore,
       config.archiverPollingIntervalMS,
     );
@@ -152,7 +136,12 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
    */
   private async sync(blockUntilSynced: boolean) {
     const currentL1BlockNumber = await this.publicClient.getBlockNumber();
-    if (currentL1BlockNumber <= this.lastProcessedL1BlockNumber) {
+    // this makes the archiver more resilient to eventually-consistent eth providers like Infura
+    // it _will_ process the same L1 blocks over and over again until the L2 chain advances
+    // one thing to handle now is that we will process the same L1 to L2 messages over and over again
+    // so the store needs to account for that.
+    const lastProcessedL1BlockNumber = await this.store.getL1BlockNumber();
+    if (currentL1BlockNumber <= lastProcessedL1BlockNumber) {
       // reducing logs, otherwise this gets triggered on every loop (1s)
       if (currentL1BlockNumber !== this.lastLoggedL1BlockNumber) {
         this.log(`No new blocks to process, current block number: ${currentL1BlockNumber}`);
@@ -169,14 +158,14 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
      * to ensure that data is read exactly once.
      *
      * The first is the problem of eventually consistent ETH service providers like Infura.
-     * We are not currently handling this correctly in the case of L1 to L2 messages and we will
-     * want to re-visit L2 Block and contract data retrieval at a later stage. This is not
-     * currently a problem but will need to be addressed before a mainnet release.
+     * We currently read from the last L1 block that we saw emit an L2 block. This could mean
+     * that the archiver ends up looking at the same L1 block multiple times (e.g. if we last saw
+     * an L2 block emitted at L1 block 10, we'd constantly ask for L1 blocks from 11 onwards until
+     * we see another L2 block). For this to work message and block processing need to be idempotent.
+     * We should re-visit this before mainnet launch.
      *
      * The second is that in between the various calls to L1, the block number can move meaning some
      * of the following calls will return data for blocks that were not present during earlier calls.
-     * This is a problem for example when setting the last block number marker for L1 to L2 messages -
-     * this.lastProcessedBlockNumber = currentBlockNumber;
      * It's possible that we actually received messages in block currentBlockNumber + 1 meaning the next time
      * we do this sync we get the same message again. Additionally, the call to get cancelled L1 to L2 messages
      * could read from a block not present when retrieving pending messages. If a message was added and cancelled
@@ -195,14 +184,14 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
       this.publicClient,
       this.inboxAddress,
       blockUntilSynced,
-      this.lastProcessedL1BlockNumber + 1n, // + 1 to prevent re-including messages from the last processed block
+      lastProcessedL1BlockNumber + 1n, // + 1 to prevent re-including messages from the last processed block
       currentL1BlockNumber,
     );
     const retrievedCancelledL1ToL2Messages = await retrieveNewCancelledL1ToL2Messages(
       this.publicClient,
       this.inboxAddress,
       blockUntilSynced,
-      this.lastProcessedL1BlockNumber + 1n,
+      lastProcessedL1BlockNumber + 1n,
       currentL1BlockNumber,
     );
 
@@ -215,8 +204,6 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
     this.log('Removing pending l1 to l2 messages from store where messages were cancelled');
     await this.store.cancelPendingL1ToL2Messages(retrievedCancelledL1ToL2Messages.retrievedData);
 
-    this.lastProcessedL1BlockNumber = currentL1BlockNumber;
-
     // ********** Events that are processed per block **********
 
     // Read all data from chain and then write to our stores at the end
@@ -252,26 +239,22 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
 
     this.log(`Retrieved ${retrievedBlocks.retrievedData.length} block(s) from chain`);
 
-    // store encrypted logs from L2 Blocks that we have retrieved
-    const encryptedLogs = retrievedBlocks.retrievedData.map(block => {
-      return block.newEncryptedLogs!;
-    });
-    await this.store.addLogs(encryptedLogs, LogType.ENCRYPTED);
-
-    // store unencrypted logs from L2 Blocks that we have retrieved
-    const unencryptedLogs = retrievedBlocks.retrievedData.map(block => {
-      return block.newUnencryptedLogs!;
-    });
-    await this.store.addLogs(unencryptedLogs, LogType.UNENCRYPTED);
+    await Promise.all(
+      retrievedBlocks.retrievedData.map(block =>
+        this.store.addLogs(block.newEncryptedLogs, block.newUnencryptedLogs, block.number),
+      ),
+    );
 
     // store contracts for which we have retrieved L2 blocks
     const lastKnownL2BlockNum = retrievedBlocks.retrievedData[retrievedBlocks.retrievedData.length - 1].number;
-    retrievedContracts.retrievedData.forEach(async ([contracts, l2BlockNum], index) => {
-      this.log(`Retrieved extended contract data for l2 block number: ${index}`);
-      if (l2BlockNum <= lastKnownL2BlockNum) {
-        await this.store.addExtendedContractData(contracts, l2BlockNum);
-      }
-    });
+    await Promise.all(
+      retrievedContracts.retrievedData.map(async ([contracts, l2BlockNum]) => {
+        this.log(`Retrieved extended contract data for l2 block number: ${l2BlockNum}`);
+        if (l2BlockNum <= lastKnownL2BlockNum) {
+          await this.store.addExtendedContractData(contracts, l2BlockNum);
+        }
+      }),
+    );
 
     // from retrieved L2Blocks, confirm L1 to L2 messages that have been published
     // from each l2block fetch all messageKeys in a flattened array:
@@ -285,7 +268,11 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
       retrievedBlocks.retrievedData.map(block => {
         // Ensure we pad the L1 to L2 message array to the full size before storing.
         block.newL1ToL2Messages = padArrayEnd(block.newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-        return L2Block.fromFields(omit(block, ['newEncryptedLogs', 'newUnencryptedLogs']), block.getBlockHash());
+        return L2Block.fromFields(
+          omit(block, ['newEncryptedLogs', 'newUnencryptedLogs']),
+          block.getBlockHash(),
+          block.getL1BlockNumber(),
+        );
       }),
     );
 

package/src/archiver/archiver_store.ts

@@ -1,25 +1,20 @@
-import { Fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
+import { Fr } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import {
+  CancelledL1ToL2Message,
   ContractData,
   ExtendedContractData,
-  ExtendedUnencryptedL2Log,
   GetUnencryptedLogsResponse,
-  INITIAL_L2_BLOCK_NUM,
   L1ToL2Message,
   L2Block,
-  L2BlockContext,
   L2BlockL2Logs,
   L2Tx,
   LogFilter,
-  LogId,
   LogType,
+  PendingL1ToL2Message,
   TxHash,
-  UnencryptedL2Log,
 } from '@aztec/types';
 
-import { L1ToL2MessageStore, PendingL1ToL2MessageStore } from './l1_to_l2_message_store.js';
-
 /**
  * Interface describing a data store to be used by the archiver to store all its relevant data
  * (blocks, encrypted logs, aztec contract data extended contract data).
@@ -49,25 +44,30 @@ export interface ArchiverDataStore {
 
   /**
    * Append new logs to the store's list.
-   * @param data - The logs to be added to the store.
-   * @param logType - The type of the logs to be added to the store.
+   * @param encryptedLogs - The encrypted logs to be added to the store.
+   * @param unencryptedLogs - The unencrypted logs to be added to the store.
+   * @param blockNumber - The block for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(data: L2BlockL2Logs[], logType: LogType): Promise<boolean>;
+  addLogs(
+    encryptedLogs: L2BlockL2Logs | undefined,
+    unencryptedLogs: L2BlockL2Logs | undefined,
+    blockNumber: number,
+  ): Promise<boolean>;
 
   /**
    * Append new pending L1 to L2 messages to the store.
    * @param messages - The L1 to L2 messages to be added to the store.
    * @returns True if the operation is successful.
    */
-  addPendingL1ToL2Messages(messages: L1ToL2Message[]): Promise<boolean>;
+  addPendingL1ToL2Messages(messages: PendingL1ToL2Message[]): Promise<boolean>;
 
   /**
    * Remove pending L1 to L2 messages from the store (if they were cancelled).
-   * @param messageKeys - The message keys to be removed from the store.
+   * @param message - The message keys to be removed from the store.
    * @returns True if the operation is successful.
    */
-  cancelPendingL1ToL2Messages(messageKeys: Fr[]): Promise<boolean>;
+  cancelPendingL1ToL2Messages(message: CancelledL1ToL2Message[]): Promise<boolean>;
 
   /**
    * Messages that have been published in an L2 block are confirmed.
@@ -150,366 +150,9 @@ export interface ArchiverDataStore {
    * @returns The number of the latest L2 block processed.
    */
   getBlockNumber(): Promise<number>;
-}
-
-/**
- * Simple, in-memory implementation of an archiver data store.
- */
-export class MemoryArchiverStore implements ArchiverDataStore {
-  /**
-   * An array containing all the L2 blocks that have been fetched so far.
-   */
-  private l2BlockContexts: L2BlockContext[] = [];
-
-  /**
-   * An array containing all the L2 Txs in the L2 blocks that have been fetched so far.
-   */
-  private l2Txs: L2Tx[] = [];
-
-  /**
-   * An array containing all the encrypted logs that have been fetched so far.
-   * Note: Index in the "outer" array equals to (corresponding L2 block's number - INITIAL_L2_BLOCK_NUM).
-   */
-  private encryptedLogsPerBlock: L2BlockL2Logs[] = [];
-
-  /**
-   * An array containing all the unencrypted logs that have been fetched so far.
-   * Note: Index in the "outer" array equals to (corresponding L2 block's number - INITIAL_L2_BLOCK_NUM).
-   */
-  private unencryptedLogsPerBlock: L2BlockL2Logs[] = [];
-
-  /**
-   * A sparse array containing all the extended contract data that have been fetched so far.
-   */
-  private extendedContractDataByBlock: (ExtendedContractData[] | undefined)[] = [];
-
-  /**
-   * A mapping of contract address to extended contract data.
-   */
-  private extendedContractData: Map<string, ExtendedContractData> = new Map();
-
-  /**
-   * Contains all the confirmed L1 to L2 messages (i.e. messages that were consumed in an L2 block)
-   * It is a map of entryKey to the corresponding L1 to L2 message and the number of times it has appeared
-   */
-  private confirmedL1ToL2Messages: L1ToL2MessageStore = new L1ToL2MessageStore();
-
-  /**
-   * Contains all the pending L1 to L2 messages (accounts for duplication of messages)
-   */
-  private pendingL1ToL2Messages: PendingL1ToL2MessageStore = new PendingL1ToL2MessageStore();
-
-  constructor(
-    /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
-    public readonly maxLogs: number,
-  ) {}
-
-  /**
-   * 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 (always in this implementation).
-   */
-  public addBlocks(blocks: L2Block[]): Promise<boolean> {
-    this.l2BlockContexts.push(...blocks.map(block => new L2BlockContext(block)));
-    this.l2Txs.push(...blocks.flatMap(b => b.getTxs()));
-    return Promise.resolve(true);
-  }
 
   /**
-   * Append new logs to the store's list.
-   * @param data - The logs to be added to the store.
-   * @param logType - The type of the logs to be added to the store.
-   * @returns True if the operation is successful.
-   */
-  addLogs(data: L2BlockL2Logs[], logType: LogType): Promise<boolean> {
-    logType === LogType.ENCRYPTED
-      ? this.encryptedLogsPerBlock.push(...data)
-      : this.unencryptedLogsPerBlock.push(...data);
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Append new pending L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  public addPendingL1ToL2Messages(messages: L1ToL2Message[]): Promise<boolean> {
-    for (const msg of messages) {
-      this.pendingL1ToL2Messages.addMessage(msg.entryKey!, msg);
-    }
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Remove pending L1 to L2 messages from the store (if they were cancelled).
-   * @param messageKeys - The message keys to be removed from the store.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  public cancelPendingL1ToL2Messages(messageKeys: Fr[]): Promise<boolean> {
-    messageKeys.forEach(messageKey => {
-      this.pendingL1ToL2Messages.removeMessage(messageKey);
-    });
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Messages that have been published in an L2 block are confirmed.
-   * Add them to the confirmed store, also remove them from the pending store.
-   * @param messageKeys - The message keys to be removed from the store.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  public confirmL1ToL2Messages(messageKeys: Fr[]): Promise<boolean> {
-    messageKeys.forEach(messageKey => {
-      this.confirmedL1ToL2Messages.addMessage(messageKey, this.pendingL1ToL2Messages.getMessage(messageKey)!);
-      this.pendingL1ToL2Messages.removeMessage(messageKey);
-    });
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Store new extended contract data from an L2 block to the store's list.
-   * @param data - List of contracts' data to be added.
-   * @param blockNum - Number of the L2 block the contract data was deployed in.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  public addExtendedContractData(data: ExtendedContractData[], blockNum: number): Promise<boolean> {
-    // Add to the contracts mapping
-    for (const contractData of data) {
-      const key = contractData.contractData.contractAddress.toString();
-      this.extendedContractData.set(key, contractData);
-    }
-
-    // Add the index per block
-    if (this.extendedContractDataByBlock[blockNum]?.length) {
-      this.extendedContractDataByBlock[blockNum]?.push(...data);
-    } else {
-      this.extendedContractDataByBlock[blockNum] = [...data];
-    }
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param from - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks.
-   * @remarks When "from" is smaller than genesis block number, blocks from the beginning are returned.
-   */
-  public getBlocks(from: number, limit: number): Promise<L2Block[]> {
-    // Return an empty array if we are outside of range
-    if (limit < 1) {
-      throw new Error(`Invalid limit: ${limit}`);
-    }
-
-    const fromIndex = Math.max(from - INITIAL_L2_BLOCK_NUM, 0);
-    if (fromIndex >= this.l2BlockContexts.length) {
-      return Promise.resolve([]);
-    }
-
-    const toIndex = fromIndex + limit;
-    return Promise.resolve(this.l2BlockContexts.slice(fromIndex, toIndex).map(blockContext => blockContext.block));
-  }
-
-  /**
-   * Gets an l2 tx.
-   * @param txHash - The txHash of the l2 tx.
-   * @returns The requested L2 tx.
-   */
-  public getL2Tx(txHash: TxHash): Promise<L2Tx | undefined> {
-    const l2Tx = this.l2Txs.find(tx => tx.txHash.equals(txHash));
-    return Promise.resolve(l2Tx);
-  }
-
-  /**
-   * Gets up to `limit` amount of pending L1 to L2 messages, sorted by fee
-   * @param limit - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
-   * @returns The requested L1 to L2 message keys.
-   */
-  public getPendingL1ToL2MessageKeys(limit: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP): Promise<Fr[]> {
-    return Promise.resolve(this.pendingL1ToL2Messages.getMessageKeys(limit));
-  }
-
-  /**
-   * Gets the confirmed L1 to L2 message corresponding to the given message key.
-   * @param messageKey - The message key to look up.
-   * @returns The requested L1 to L2 message or throws if not found.
-   */
-  public getConfirmedL1ToL2Message(messageKey: Fr): Promise<L1ToL2Message> {
-    const message = this.confirmedL1ToL2Messages.getMessage(messageKey);
-    if (!message) {
-      throw new Error(`L1 to L2 Message with key ${messageKey.toString()} not found in the confirmed messages store`);
-    }
-    return Promise.resolve(message);
-  }
-
-  /**
-   * Gets up to `limit` amount of logs starting from `from`.
-   * @param from - Number of the L2 block to which corresponds the first logs to be returned.
-   * @param limit - The number of logs to return.
-   * @param logType - Specifies whether to return encrypted or unencrypted logs.
-   * @returns The requested logs.
-   */
-  getLogs(from: number, limit: number, logType: LogType): Promise<L2BlockL2Logs[]> {
-    if (from < INITIAL_L2_BLOCK_NUM || limit < 1) {
-      throw new Error(`Invalid limit: ${limit}`);
-    }
-    const logs = logType === LogType.ENCRYPTED ? this.encryptedLogsPerBlock : this.unencryptedLogsPerBlock;
-    if (from > logs.length) {
-      return Promise.resolve([]);
-    }
-    const startIndex = from - INITIAL_L2_BLOCK_NUM;
-    const endIndex = startIndex + limit;
-    return Promise.resolve(logs.slice(startIndex, endIndex));
-  }
-
-  /**
-   * Gets unencrypted logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   * @remarks Works by doing an intersection of all params in the filter.
-   */
-  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
-    let txHash: TxHash | undefined;
-    let fromBlockIndex = 0;
-    let toBlockIndex = this.unencryptedLogsPerBlock.length;
-    let txIndexInBlock = 0;
-    let logIndexInTx = 0;
-
-    if (filter.afterLog) {
-      // Continuation parameter is set --> tx hash is ignored
-      if (filter.fromBlock == undefined || filter.fromBlock <= filter.afterLog.blockNumber) {
-        fromBlockIndex = filter.afterLog.blockNumber - INITIAL_L2_BLOCK_NUM;
-        txIndexInBlock = filter.afterLog.txIndex;
-        logIndexInTx = filter.afterLog.logIndex + 1; // We want to start from the next log
-      } else {
-        fromBlockIndex = filter.fromBlock - INITIAL_L2_BLOCK_NUM;
-      }
-    } else {
-      txHash = filter.txHash;
-
-      if (filter.fromBlock !== undefined) {
-        fromBlockIndex = filter.fromBlock - INITIAL_L2_BLOCK_NUM;
-      }
-    }
-
-    if (filter.toBlock !== undefined) {
-      toBlockIndex = filter.toBlock - INITIAL_L2_BLOCK_NUM;
-    }
-
-    // Ensure the indices are within block array bounds
-    fromBlockIndex = Math.max(fromBlockIndex, 0);
-    toBlockIndex = Math.min(toBlockIndex, this.unencryptedLogsPerBlock.length);
-
-    if (fromBlockIndex > this.unencryptedLogsPerBlock.length || toBlockIndex < fromBlockIndex || toBlockIndex <= 0) {
-      return Promise.resolve({
-        logs: [],
-        maxLogsHit: false,
-      });
-    }
-
-    const contractAddress = filter.contractAddress;
-    const selector = filter.selector;
-
-    const logs: ExtendedUnencryptedL2Log[] = [];
-
-    for (; fromBlockIndex < toBlockIndex; fromBlockIndex++) {
-      const blockContext = this.l2BlockContexts[fromBlockIndex];
-      const blockLogs = this.unencryptedLogsPerBlock[fromBlockIndex];
-      for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
-        const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs().map(log => UnencryptedL2Log.fromBuffer(log));
-        for (; logIndexInTx < txLogs.length; logIndexInTx++) {
-          const log = txLogs[logIndexInTx];
-          if (
-            (!txHash || blockContext.getTxHash(txIndexInBlock).equals(txHash)) &&
-            (!contractAddress || log.contractAddress.equals(contractAddress)) &&
-            (!selector || log.selector.equals(selector))
-          ) {
-            logs.push(
-              new ExtendedUnencryptedL2Log(new LogId(blockContext.block.number, txIndexInBlock, logIndexInTx), log),
-            );
-            if (logs.length === this.maxLogs) {
-              return Promise.resolve({
-                logs,
-                maxLogsHit: true,
-              });
-            }
-          }
-        }
-        logIndexInTx = 0;
-      }
-      txIndexInBlock = 0;
-    }
-
-    return Promise.resolve({
-      logs,
-      maxLogsHit: false,
-    });
-  }
-
-  /**
-   * Get the extended contract data for this contract.
-   * @param contractAddress - The contract data address.
-   * @returns The extended contract data or undefined if not found.
-   */
-  getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined> {
-    const result = this.extendedContractData.get(contractAddress.toString());
-    return Promise.resolve(result);
-  }
-
-  /**
-   * Lookup all contract data in an L2 block.
-   * @param blockNum - The block number to get all contract data from.
-   * @returns All extended contract data in the block (if found).
-   */
-  public getExtendedContractDataInBlock(blockNum: number): Promise<ExtendedContractData[]> {
-    if (blockNum > this.l2BlockContexts.length) {
-      return Promise.resolve([]);
-    }
-    return Promise.resolve(this.extendedContractDataByBlock[blockNum] || []);
-  }
-
-  /**
-   * Get basic info for an L2 contract.
-   * Contains contract address & the ethereum portal address.
-   * @param contractAddress - The contract data address.
-   * @returns ContractData with the portal address (if we didn't throw an error).
-   */
-  public getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
-    if (contractAddress.isZero()) {
-      return Promise.resolve(undefined);
-    }
-    for (const blockContext of this.l2BlockContexts) {
-      for (const contractData of blockContext.block.newContractData) {
-        if (contractData.contractAddress.equals(contractAddress)) {
-          return Promise.resolve(contractData);
-        }
-      }
-    }
-    return Promise.resolve(undefined);
-  }
-
-  /**
-   * Get basic info for an all L2 contracts deployed in a block.
-   * Contains contract address & the ethereum portal address.
-   * @param l2BlockNum - Number of the L2 block where contracts were deployed.
-   * @returns ContractData with the portal address (if we didn't throw an error).
-   */
-  public getContractDataInBlock(l2BlockNum: number): Promise<ContractData[] | undefined> {
-    if (l2BlockNum > this.l2BlockContexts.length) {
-      return Promise.resolve([]);
-    }
-    const block = this.l2BlockContexts[l2BlockNum].block;
-    return Promise.resolve(block.newContractData);
-  }
-
-  /**
-   * Gets the number of the latest L2 block processed.
-   * @returns The number of the latest L2 block processed.
+   * Gets the number of the latest L1 block processed.
    */
-  public getBlockNumber(): Promise<number> {
-    if (this.l2BlockContexts.length === 0) {
-      return Promise.resolve(INITIAL_L2_BLOCK_NUM - 1);
-    }
-    return Promise.resolve(this.l2BlockContexts[this.l2BlockContexts.length - 1].block.number);
-  }
+  getL1BlockNumber(): Promise<bigint>;
 }