@aztec/archiver 0.62.0 → 0.63.0

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,6 +1,7 @@
 import {
+  type Body,
+  ContractClass2BlockL2Logs,
   EncryptedL2BlockL2Logs,
-  EncryptedL2NoteLog,
   EncryptedNoteL2BlockL2Logs,
   ExtendedUnencryptedL2Log,
   type FromLogType,
@@ -10,13 +11,14 @@ import {
   type LogFilter,
   LogId,
   LogType,
+  TxScopedL2Log,
   UnencryptedL2BlockL2Logs,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
+import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/circuits.js/constants';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap, type AztecMultiMap } from '@aztec/kv-store';
+import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
 
 import { type BlockStore } from './block_store.js';
 
@@ -25,58 +27,123 @@ import { type BlockStore } from './block_store.js';
  */
 export class LogStore {
   #noteEncryptedLogsByBlock: AztecMap<number, Buffer>;
-  #noteEncryptedLogsByHash: AztecMap<string, Buffer>;
-  #noteEncryptedLogHashesByTag: AztecMultiMap<string, string>;
-  #noteEncryptedLogTagsByBlock: AztecMultiMap<number, string>;
+  #logsByTag: AztecMap<string, Buffer[]>;
+  #logTagsByBlock: AztecMap<number, string[]>;
   #encryptedLogsByBlock: AztecMap<number, Buffer>;
   #unencryptedLogsByBlock: AztecMap<number, Buffer>;
+  #contractClassLogsByBlock: AztecMap<number, Buffer>;
   #logsMaxPageSize: number;
   #log = createDebugLogger('aztec:archiver:log_store');
 
   constructor(private db: AztecKVStore, private blockStore: BlockStore, logsMaxPageSize: number = 1000) {
     this.#noteEncryptedLogsByBlock = db.openMap('archiver_note_encrypted_logs_by_block');
-    this.#noteEncryptedLogsByHash = db.openMap('archiver_note_encrypted_logs_by_hash');
-    this.#noteEncryptedLogHashesByTag = db.openMultiMap('archiver_tagged_note_encrypted_log_hashes_by_tag');
-    this.#noteEncryptedLogTagsByBlock = db.openMultiMap('archiver_note_encrypted_log_tags_by_block');
+    this.#logsByTag = db.openMap('archiver_tagged_logs_by_tag');
+    this.#logTagsByBlock = db.openMap('archiver_log_tags_by_block');
     this.#encryptedLogsByBlock = db.openMap('archiver_encrypted_logs_by_block');
     this.#unencryptedLogsByBlock = db.openMap('archiver_unencrypted_logs_by_block');
+    this.#contractClassLogsByBlock = db.openMap('archiver_contract_class_logs_by_block');
 
     this.#logsMaxPageSize = logsMaxPageSize;
   }
 
+  #extractTaggedLogs(block: L2Block, logType: keyof Pick<Body, 'noteEncryptedLogs' | 'unencryptedLogs'>) {
+    const taggedLogs = new Map<string, Buffer[]>();
+    const dataStartIndexForBlock =
+      block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
+      block.body.numberOfTxsIncludingPadded * MAX_NOTE_HASHES_PER_TX;
+    block.body[logType].txLogs.forEach((txLogs, txIndex) => {
+      const txHash = block.body.txEffects[txIndex].txHash;
+      const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
+      const logs = txLogs.unrollLogs();
+      logs.forEach(log => {
+        if (
+          (logType == 'noteEncryptedLogs' && log.data.length < 32) ||
+          // TODO remove when #9835 and #9836 are fixed
+          (logType === 'unencryptedLogs' && log.data.length < 32 * 33)
+        ) {
+          this.#log.warn(`Skipping log (${logType}) with invalid data length: ${log.data.length}`);
+          return;
+        }
+        try {
+          let tag = Fr.ZERO;
+          // TODO remove when #9835 and #9836 are fixed. The partial note logs are emitted as bytes, but encoded as Fields.
+          // This means that for every 32 bytes of payload, we only have 1 byte of data.
+          // Also, the tag is not stored in the first 32 bytes of the log, (that's the length of public fields now) but in the next 32.
+          if (logType === 'unencryptedLogs') {
+            const correctedBuffer = Buffer.alloc(32);
+            const initialOffset = 32;
+            for (let i = 0; i < 32; i++) {
+              const byte = Fr.fromBuffer(
+                log.data.subarray(i * 32 + initialOffset, i * 32 + 32 + initialOffset),
+              ).toNumber();
+              correctedBuffer.writeUInt8(byte, i);
+            }
+            tag = new Fr(correctedBuffer);
+          } else {
+            tag = new Fr(log.data.subarray(0, 32));
+          }
+          this.#log.verbose(`Found tagged (${logType}) log with tag ${tag.toString()} in block ${block.number}`);
+          const currentLogs = taggedLogs.get(tag.toString()) ?? [];
+          currentLogs.push(
+            new TxScopedL2Log(
+              txHash,
+              dataStartIndexForTx,
+              block.number,
+              logType === 'unencryptedLogs',
+              log.data,
+            ).toBuffer(),
+          );
+          taggedLogs.set(tag.toString(), currentLogs);
+        } catch (err) {
+          this.#log.warn(`Failed to add tagged log to store: ${err}`);
+        }
+      });
+    });
+    return taggedLogs;
+  }
+
   /**
    * 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> {
+  async addLogs(blocks: L2Block[]): Promise<boolean> {
+    const taggedLogsToAdd = blocks
+      .flatMap(block => [
+        this.#extractTaggedLogs(block, 'noteEncryptedLogs'),
+        this.#extractTaggedLogs(block, 'unencryptedLogs'),
+      ])
+      .reduce((acc, val) => {
+        for (const [tag, logs] of val.entries()) {
+          const currentLogs = acc.get(tag) ?? [];
+          acc.set(tag, currentLogs.concat(logs));
+        }
+        return acc;
+      });
+    const tagsToUpdate = Array.from(taggedLogsToAdd.keys());
+    const currentTaggedLogs = await this.db.transaction(() =>
+      tagsToUpdate.map(tag => ({ tag, logBuffers: this.#logsByTag.get(tag) })),
+    );
+    currentTaggedLogs.forEach(taggedLogBuffer => {
+      if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+        taggedLogsToAdd.set(
+          taggedLogBuffer.tag,
+          taggedLogBuffer.logBuffers!.concat(taggedLogsToAdd.get(taggedLogBuffer.tag)!),
+        );
+      }
+    });
     return this.db.transaction(() => {
       blocks.forEach(block => {
+        const tagsInBlock = [];
+        for (const [tag, logs] of taggedLogsToAdd.entries()) {
+          void this.#logsByTag.set(tag, logs);
+          tagsInBlock.push(tag);
+        }
+        void this.#logTagsByBlock.set(block.number, tagsInBlock);
         void this.#noteEncryptedLogsByBlock.set(block.number, block.body.noteEncryptedLogs.toBuffer());
-        block.body.noteEncryptedLogs.txLogs.forEach(txLogs => {
-          const noteLogs = txLogs.unrollLogs();
-          noteLogs.forEach(noteLog => {
-            if (noteLog.data.length < 32) {
-              this.#log.warn(`Skipping note log with invalid data length: ${noteLog.data.length}`);
-              return;
-            }
-            try {
-              const tag = new Fr(noteLog.data.subarray(0, 32));
-              const hexHash = noteLog.hash().toString('hex');
-              // Ideally we'd store all of the logs for a matching tag in an AztecMultiMap, but this type doesn't doesn't
-              // handle storing buffers well. The 'ordered-binary' encoding returns an error trying to decode buffers
-              // ('the number <> cannot be converted to a BigInt because it is not an integer'). We therefore store
-              // instead the hashes of the logs.
-              void this.#noteEncryptedLogHashesByTag.set(tag.toString(), hexHash);
-              void this.#noteEncryptedLogsByHash.set(hexHash, noteLog.toBuffer());
-              void this.#noteEncryptedLogTagsByBlock.set(block.number, tag.toString());
-            } catch (err) {
-              this.#log.warn(`Failed to add tagged note log to store: ${err}`);
-            }
-          });
-        });
         void this.#encryptedLogsByBlock.set(block.number, block.body.encryptedLogs.toBuffer());
         void this.#unencryptedLogsByBlock.set(block.number, block.body.unencryptedLogs.toBuffer());
+        void this.#contractClassLogsByBlock.set(block.number, block.body.contractClassLogs.toBuffer());
       });
 
       return true;
@@ -84,26 +151,19 @@ export class LogStore {
   }
 
   async deleteLogs(blocks: L2Block[]): Promise<boolean> {
-    const noteTagsToDelete = await this.db.transaction(() => {
-      return blocks.flatMap(block => Array.from(this.#noteEncryptedLogTagsByBlock.getValues(block.number)));
-    });
-    const noteLogHashesToDelete = await this.db.transaction(() => {
-      return noteTagsToDelete.flatMap(tag => Array.from(this.#noteEncryptedLogHashesByTag.getValues(tag)));
+    const tagsToDelete = await this.db.transaction(() => {
+      return blocks.flatMap(block => this.#logTagsByBlock.get(block.number)?.map(tag => tag.toString()) ?? []);
     });
     return this.db.transaction(() => {
       blocks.forEach(block => {
         void this.#noteEncryptedLogsByBlock.delete(block.number);
         void this.#encryptedLogsByBlock.delete(block.number);
         void this.#unencryptedLogsByBlock.delete(block.number);
-        void this.#noteEncryptedLogTagsByBlock.delete(block.number);
-      });
-
-      noteTagsToDelete.forEach(tag => {
-        void this.#noteEncryptedLogHashesByTag.delete(tag.toString());
+        void this.#logTagsByBlock.delete(block.number);
       });
 
-      noteLogHashesToDelete.forEach(hash => {
-        void this.#noteEncryptedLogsByHash.delete(hash);
+      tagsToDelete.forEach(tag => {
+        void this.#logsByTag.delete(tag.toString());
       });
 
       return true;
@@ -156,20 +216,12 @@ export class LogStore {
    * @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<EncryptedL2NoteLog[][]> {
-    return this.db.transaction(() => {
-      return tags.map(tag => {
-        const logHashes = Array.from(this.#noteEncryptedLogHashesByTag.getValues(tag.toString()));
-        return (
-          logHashes
-            .map(hash => this.#noteEncryptedLogsByHash.get(hash))
-            // addLogs should ensure that we never have undefined logs, but we filter them out regardless to protect
-            // ourselves from database corruption
-            .filter(noteLogBuffer => noteLogBuffer != undefined)
-            .map(noteLogBuffer => EncryptedL2NoteLog.fromBuffer(noteLogBuffer!))
-        );
-      });
-    });
+  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
+    return this.db.transaction(() =>
+      tags
+        .map(tag => this.#logsByTag.get(tag.toString()))
+        .map(noteLogBuffers => noteLogBuffers?.map(noteLogBuffer => TxScopedL2Log.fromBuffer(noteLogBuffer)) ?? []),
+    );
   }
 
   /**
@@ -236,6 +288,72 @@ export class LogStore {
     return { logs, maxLogsHit };
   }
 
+  /**
+   * 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): GetUnencryptedLogsResponse {
+    if (filter.afterLog) {
+      return this.#filterContractClassLogsBetweenBlocks(filter);
+    } else if (filter.txHash) {
+      return this.#filterContractClassLogsOfTx(filter);
+    } else {
+      return this.#filterContractClassLogsBetweenBlocks(filter);
+    }
+  }
+
+  #filterContractClassLogsOfTx(filter: LogFilter): GetUnencryptedLogsResponse {
+    if (!filter.txHash) {
+      throw new Error('Missing txHash');
+    }
+
+    const [blockNumber, txIndex] = this.blockStore.getTxLocation(filter.txHash) ?? [];
+    if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+      return { logs: [], maxLogsHit: false };
+    }
+    const contractClassLogsBuffer = this.#contractClassLogsByBlock.get(blockNumber);
+    const contractClassLogsInBlock = contractClassLogsBuffer
+      ? ContractClass2BlockL2Logs.fromBuffer(contractClassLogsBuffer)
+      : new ContractClass2BlockL2Logs([]);
+    const txLogs = contractClassLogsInBlock.txLogs[txIndex].unrollLogs();
+
+    const logs: ExtendedUnencryptedL2Log[] = [];
+    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+
+    return { logs, maxLogsHit };
+  }
+
+  #filterContractClassLogsBetweenBlocks(filter: LogFilter): GetUnencryptedLogsResponse {
+    const start =
+      filter.afterLog?.blockNumber ?? Math.max(filter.fromBlock ?? INITIAL_L2_BLOCK_NUM, INITIAL_L2_BLOCK_NUM);
+    const end = filter.toBlock;
+
+    if (typeof end === 'number' && end < start) {
+      return {
+        logs: [],
+        maxLogsHit: true,
+      };
+    }
+
+    const logs: ExtendedUnencryptedL2Log[] = [];
+
+    let maxLogsHit = false;
+    loopOverBlocks: for (const [blockNumber, logBuffer] of this.#contractClassLogsByBlock.entries({ start, end })) {
+      const contractClassLogsInBlock = ContractClass2BlockL2Logs.fromBuffer(logBuffer);
+      for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < contractClassLogsInBlock.txLogs.length; txIndex++) {
+        const txLogs = contractClassLogsInBlock.txLogs[txIndex].unrollLogs();
+        maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        if (maxLogsHit) {
+          this.#log.debug(`Max logs hit at block ${blockNumber}`);
+          break loopOverBlocks;
+        }
+      }
+    }
+
+    return { logs, maxLogsHit };
+  }
+
   #accumulateLogs(
     results: ExtendedUnencryptedL2Log[],
     blockNumber: number,

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,6 +1,7 @@
 import {
+  type Body,
+  type ContractClass2BlockL2Logs,
   type EncryptedL2BlockL2Logs,
-  type EncryptedL2NoteLog,
   type EncryptedNoteL2BlockL2Logs,
   ExtendedUnencryptedL2Log,
   type FromLogType,
@@ -14,6 +15,7 @@ import {
   type TxEffect,
   type TxHash,
   TxReceipt,
+  TxScopedL2Log,
   type UnencryptedL2BlockL2Logs,
 } from '@aztec/circuit-types';
 import {
@@ -24,6 +26,7 @@ import {
   Fr,
   type Header,
   INITIAL_L2_BLOCK_NUM,
+  MAX_NOTE_HASHES_PER_TX,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/circuits.js';
 import { type ContractArtifact } from '@aztec/foundation/abi';
@@ -51,14 +54,16 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private noteEncryptedLogsPerBlock: Map<number, EncryptedNoteL2BlockL2Logs> = new Map();
 
-  private taggedNoteEncryptedLogs: Map<string, EncryptedL2NoteLog[]> = new Map();
+  private taggedLogs: Map<string, TxScopedL2Log[]> = new Map();
 
-  private noteEncryptedLogTagsPerBlock: Map<number, Fr[]> = new Map();
+  private logTagsPerBlock: Map<number, Fr[]> = new Map();
 
   private encryptedLogsPerBlock: Map<number, EncryptedL2BlockL2Logs> = new Map();
 
   private unencryptedLogsPerBlock: Map<number, UnencryptedL2BlockL2Logs> = new Map();
 
+  private contractClassLogsPerBlock: Map<number, ContractClass2BlockL2Logs> = new Map();
+
   /**
    * Contains all L1 to L2 messages.
    */
@@ -206,6 +211,56 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
+  #storeTaggedLogs(block: L2Block, logType: keyof Pick<Body, 'noteEncryptedLogs' | 'unencryptedLogs'>): void {
+    const dataStartIndexForBlock =
+      block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
+      block.body.numberOfTxsIncludingPadded * MAX_NOTE_HASHES_PER_TX;
+    block.body[logType].txLogs.forEach((txLogs, txIndex) => {
+      const txHash = block.body.txEffects[txIndex].txHash;
+      const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
+      const logs = txLogs.unrollLogs();
+      logs.forEach(log => {
+        if (
+          (logType == 'noteEncryptedLogs' && log.data.length < 32) ||
+          // TODO remove when #9835 and #9836 are fixed
+          (logType === 'unencryptedLogs' && log.data.length < 32 * 33)
+        ) {
+          this.#log.warn(`Skipping log (${logType}) with invalid data length: ${log.data.length}`);
+          return;
+        }
+        try {
+          let tag = Fr.ZERO;
+          // TODO remove when #9835 and #9836 are fixed. The partial note logs are emitted as bytes, but encoded as Fields.
+          // This means that for every 32 bytes of payload, we only have 1 byte of data.
+          // Also, the tag is not stored in the first 32 bytes of the log, (that's the length of public fields now) but in the next 32.
+          if (logType === 'unencryptedLogs') {
+            const correctedBuffer = Buffer.alloc(32);
+            const initialOffset = 32;
+            for (let i = 0; i < 32; i++) {
+              const byte = Fr.fromBuffer(
+                log.data.subarray(i * 32 + initialOffset, i * 32 + 32 + initialOffset),
+              ).toNumber();
+              correctedBuffer.writeUInt8(byte, i);
+            }
+            tag = new Fr(correctedBuffer);
+          } else {
+            tag = new Fr(log.data.subarray(0, 32));
+          }
+          this.#log.verbose(`Storing tagged (${logType}) log with tag ${tag.toString()} in block ${block.number}`);
+          const currentLogs = this.taggedLogs.get(tag.toString()) || [];
+          this.taggedLogs.set(tag.toString(), [
+            ...currentLogs,
+            new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, logType === 'unencryptedLogs', log.data),
+          ]);
+          const currentTagsInBlock = this.logTagsPerBlock.get(block.number) || [];
+          this.logTagsPerBlock.set(block.number, [...currentTagsInBlock, tag]);
+        } catch (err) {
+          this.#log.warn(`Failed to add tagged log to store: ${err}`);
+        }
+      });
+    });
+  }
+
   /**
    * Append new logs to the store's list.
    * @param block - The block for which to add the logs.
@@ -213,44 +268,30 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   addLogs(blocks: L2Block[]): Promise<boolean> {
     blocks.forEach(block => {
+      void this.#storeTaggedLogs(block, 'noteEncryptedLogs');
+      void this.#storeTaggedLogs(block, 'unencryptedLogs');
       this.noteEncryptedLogsPerBlock.set(block.number, block.body.noteEncryptedLogs);
-      block.body.noteEncryptedLogs.txLogs.forEach(txLogs => {
-        const noteLogs = txLogs.unrollLogs();
-        noteLogs.forEach(noteLog => {
-          if (noteLog.data.length < 32) {
-            this.#log.warn(`Skipping note log with invalid data length: ${noteLog.data.length}`);
-            return;
-          }
-          try {
-            const tag = new Fr(noteLog.data.subarray(0, 32));
-            const currentNoteLogs = this.taggedNoteEncryptedLogs.get(tag.toString()) || [];
-            this.taggedNoteEncryptedLogs.set(tag.toString(), [...currentNoteLogs, noteLog]);
-            const currentTagsInBlock = this.noteEncryptedLogTagsPerBlock.get(block.number) || [];
-            this.noteEncryptedLogTagsPerBlock.set(block.number, [...currentTagsInBlock, tag]);
-          } catch (err) {
-            this.#log.warn(`Failed to add tagged note log to store: ${err}`);
-          }
-        });
-      });
       this.encryptedLogsPerBlock.set(block.number, block.body.encryptedLogs);
       this.unencryptedLogsPerBlock.set(block.number, block.body.unencryptedLogs);
+      this.contractClassLogsPerBlock.set(block.number, block.body.contractClassLogs);
     });
     return Promise.resolve(true);
   }
 
   deleteLogs(blocks: L2Block[]): Promise<boolean> {
-    const noteTagsToDelete = blocks.flatMap(block => this.noteEncryptedLogTagsPerBlock.get(block.number));
-    noteTagsToDelete
+    const tagsToDelete = blocks.flatMap(block => this.logTagsPerBlock.get(block.number));
+    tagsToDelete
       .filter(tag => tag != undefined)
       .forEach(tag => {
-        this.taggedNoteEncryptedLogs.delete(tag!.toString());
+        this.taggedLogs.delete(tag!.toString());
       });
 
     blocks.forEach(block => {
       this.encryptedLogsPerBlock.delete(block.number);
       this.noteEncryptedLogsPerBlock.delete(block.number);
       this.unencryptedLogsPerBlock.delete(block.number);
-      this.noteEncryptedLogTagsPerBlock.delete(block.number);
+      this.logTagsPerBlock.delete(block.number);
+      this.contractClassLogsPerBlock.delete(block.number);
     });
 
     return Promise.resolve(true);
@@ -419,8 +460,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @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<EncryptedL2NoteLog[][]> {
-    const noteLogs = tags.map(tag => this.taggedNoteEncryptedLogs.get(tag.toString()) || []);
+  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
+    const noteLogs = tags.map(tag => this.taggedLogs.get(tag.toString()) || []);
     return Promise.resolve(noteLogs);
   }
 
@@ -507,6 +548,90 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     });
   }
 
+  /**
+   * Gets contract class logs based on the provided filter.
+   * NB: clone of the above fn, but for contract class logs
+   * @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.
+   */
+  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+    let txHash: TxHash | undefined;
+    let fromBlock = 0;
+    let toBlock = this.l2Blocks.length + INITIAL_L2_BLOCK_NUM;
+    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) {
+        fromBlock = filter.afterLog.blockNumber;
+        txIndexInBlock = filter.afterLog.txIndex;
+        logIndexInTx = filter.afterLog.logIndex + 1; // We want to start from the next log
+      } else {
+        fromBlock = filter.fromBlock;
+      }
+    } else {
+      txHash = filter.txHash;
+
+      if (filter.fromBlock !== undefined) {
+        fromBlock = filter.fromBlock;
+      }
+    }
+
+    if (filter.toBlock !== undefined) {
+      toBlock = filter.toBlock;
+    }
+
+    // Ensure the indices are within block array bounds
+    fromBlock = Math.max(fromBlock, INITIAL_L2_BLOCK_NUM);
+    toBlock = Math.min(toBlock, this.l2Blocks.length + INITIAL_L2_BLOCK_NUM);
+
+    if (fromBlock > this.l2Blocks.length || toBlock < fromBlock || toBlock <= 0) {
+      return Promise.resolve({
+        logs: [],
+        maxLogsHit: false,
+      });
+    }
+
+    const contractAddress = filter.contractAddress;
+
+    const logs: ExtendedUnencryptedL2Log[] = [];
+
+    for (; fromBlock < toBlock; fromBlock++) {
+      const block = this.l2Blocks[fromBlock - INITIAL_L2_BLOCK_NUM];
+      const blockLogs = this.contractClassLogsPerBlock.get(fromBlock);
+
+      if (blockLogs) {
+        for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
+          const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs();
+          for (; logIndexInTx < txLogs.length; logIndexInTx++) {
+            const log = txLogs[logIndexInTx];
+            if (
+              (!txHash || block.data.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
+              (!contractAddress || log.contractAddress.equals(contractAddress))
+            ) {
+              logs.push(new ExtendedUnencryptedL2Log(new LogId(block.data.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,
+    });
+  }
+
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.

package/src/factory.ts

@@ -1,5 +1,8 @@
+import { type ArchiverApi, type Service } from '@aztec/circuit-types';
 import { type ContractClassPublic } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { type Maybe } from '@aztec/foundation/types';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/utils';
 import { getCanonicalProtocolContract, protocolContractNames } from '@aztec/protocol-contracts';
 import { type TelemetryClient } from '@aztec/telemetry-client';
@@ -8,13 +11,13 @@ import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { Archiver } from './archiver/archiver.js';
 import { type ArchiverConfig } from './archiver/config.js';
 import { KVArchiverDataStore } from './archiver/index.js';
-import { createArchiverClient } from './rpc/archiver_client.js';
+import { createArchiverClient } from './rpc/index.js';
 
 export async function createArchiver(
-  config: ArchiverConfig,
+  config: ArchiverConfig & DataStoreConfig,
   telemetry: TelemetryClient = new NoopTelemetryClient(),
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
-) {
+): Promise<ArchiverApi & Maybe<Service>> {
   if (!config.archiverUrl) {
     const store = await createStore('archiver', config, createDebugLogger('aztec:archiver:lmdb'));
     const archiverStore = new KVArchiverDataStore(store, config.maxLogs);

package/src/rpc/index.ts

@@ -1,2 +1,11 @@
-export * from './archiver_client.js';
-export * from './archiver_server.js';
+import { type ArchiverApi, ArchiverApiSchema } from '@aztec/circuit-types';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+
+export function createArchiverClient(url: string, fetch = makeFetch([1, 2, 3], true)): ArchiverApi {
+  return createSafeJsonRpcClient<ArchiverApi>(url, ArchiverApiSchema, false, 'archiver', fetch);
+}
+
+export function createArchiverRpcServer(handler: ArchiverApi) {
+  return createSafeJsonRpcServer(handler, ArchiverApiSchema);
+}

package/src/test/mock_l2_block_source.ts

@@ -1,5 +1,6 @@
 import { L2Block, type L2BlockSource, type L2Tips, type TxHash, TxReceipt, TxStatus } from '@aztec/circuit-types';
 import { EthAddress, type Header } from '@aztec/circuits.js';
+import { DefaultL1ContractsConfig } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { getSlotRangeForEpoch } from '../archiver/epoch_helpers.js';
@@ -103,7 +104,8 @@ export class MockL2BlockSource implements L2BlockSource {
   }
 
   getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
-    const [start, end] = getSlotRangeForEpoch(epochNumber);
+    const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
+    const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
     const blocks = this.l2Blocks.filter(b => {
       const slot = b.header.globalVariables.slotNumber.toBigInt();
       return slot >= start && slot <= end;

package/dest/rpc/archiver_client.d.ts

@@ -1,3 +0,0 @@
-import { type ArchiveSource } from '../archiver/archiver.js';
-export declare const createArchiverClient: (url: string, fetch?: (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean) => Promise<any>) => ArchiveSource;
-//# sourceMappingURL=archiver_client.d.ts.map

package/dest/rpc/archiver_client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"archiver_client.d.ts","sourceRoot":"","sources":["../../src/rpc/archiver_client.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,eAAO,MAAM,oBAAoB,QAAS,MAAM,qGAAuC,aAenE,CAAC"}

package/dest/rpc/archiver_client.js

@@ -1,12 +0,0 @@
-import { EncryptedNoteL2BlockL2Logs, ExtendedUnencryptedL2Log, L2Block, NullifierMembershipWitness, TxReceipt, UnencryptedL2BlockL2Logs, } from '@aztec/circuit-types';
-import { EthAddress, Fr } from '@aztec/circuits.js';
-import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
-export const createArchiverClient = (url, fetch = makeFetch([1, 2, 3], true)) => createJsonRpcClient(url, {
-    EthAddress,
-    ExtendedUnencryptedL2Log,
-    Fr,
-    L2Block,
-    EncryptedNoteL2BlockL2Logs,
-    UnencryptedL2BlockL2Logs,
-}, { TxReceipt, NullifierMembershipWitness }, false, 'archiver', fetch);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJjaGl2ZXJfY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JwYy9hcmNoaXZlcl9jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDBCQUEwQixFQUMxQix3QkFBd0IsRUFDeEIsT0FBTyxFQUNQLDBCQUEwQixFQUMxQixTQUFTLEVBQ1Qsd0JBQXdCLEdBQ3pCLE1BQU0sc0JBQXNCLENBQUM7QUFDOUIsT0FBTyxFQUFFLFVBQVUsRUFBRSxFQUFFLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsU0FBUyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFJbkYsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsQ0FBQyxHQUFXLEVBQUUsS0FBSyxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLEVBQWlCLEVBQUUsQ0FDckcsbUJBQW1CLENBQ2pCLEdBQUcsRUFDSDtJQUNFLFVBQVU7SUFDVix3QkFBd0I7SUFDeEIsRUFBRTtJQUNGLE9BQU87SUFDUCwwQkFBMEI7SUFDMUIsd0JBQXdCO0NBQ3pCLEVBQ0QsRUFBRSxTQUFTLEVBQUUsMEJBQTBCLEVBQUUsRUFDekMsS0FBSyxFQUNMLFVBQVUsRUFDVixLQUFLLENBQ1csQ0FBQyJ9

package/dest/rpc/archiver_server.d.ts

@@ -1,9 +0,0 @@
-import { JsonRpcServer } from '@aztec/foundation/json-rpc/server';
-import { type Archiver } from '../archiver/archiver.js';
-/**
- * Wrap an Archiver instance with a JSON RPC HTTP server.
- * @param archiverService - The Archiver instance
- * @returns An JSON-RPC HTTP server
- */
-export declare function createArchiverRpcServer(archiverService: Archiver): JsonRpcServer;
-//# sourceMappingURL=archiver_server.d.ts.map

package/dest/rpc/archiver_server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"archiver_server.d.ts","sourceRoot":"","sources":["../../src/rpc/archiver_server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,QAAQ,GAAG,aAAa,CAehF"}