@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/archiver/kv_archiver_store/contract_instance_store.ts

@@ -7,71 +7,75 @@ import {
   SerializableContractInstance,
   SerializableContractInstanceUpdate,
 } from '@aztec/stdlib/contract';
+import type { UInt64 } from '@aztec/stdlib/types';
 
-type ContractInstanceUpdateKey = [string, number] | [string, number, number];
+type ContractInstanceUpdateKey = [string, string] | [string, string, number];
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class ContractInstanceStore {
   #contractInstances: AztecAsyncMap<string, Buffer>;
+  #contractInstancePublishedAt: AztecAsyncMap<string, number>;
   #contractInstanceUpdates: AztecAsyncMap<ContractInstanceUpdateKey, Buffer>;
 
-  constructor(db: AztecAsyncKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#contractInstances = db.openMap('archiver_contract_instances');
+    this.#contractInstancePublishedAt = db.openMap('archiver_contract_instances_publication_block_number');
     this.#contractInstanceUpdates = db.openMap('archiver_contract_instance_updates');
   }
 
-  addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
-    return this.#contractInstances.set(
-      contractInstance.address.toString(),
-      new SerializableContractInstance(contractInstance).toBuffer(),
-    );
+  addContractInstance(contractInstance: ContractInstanceWithAddress, blockNumber: number): Promise<void> {
+    return this.db.transactionAsync(async () => {
+      await this.#contractInstances.set(
+        contractInstance.address.toString(),
+        new SerializableContractInstance(contractInstance).toBuffer(),
+      );
+      await this.#contractInstancePublishedAt.set(contractInstance.address.toString(), blockNumber);
+    });
   }
 
   deleteContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
-    return this.#contractInstances.delete(contractInstance.address.toString());
+    return this.db.transactionAsync(async () => {
+      await this.#contractInstances.delete(contractInstance.address.toString());
+      await this.#contractInstancePublishedAt.delete(contractInstance.address.toString());
+    });
   }
 
-  getUpdateKey(contractAddress: AztecAddress, blockNumber: number, logIndex?: number): ContractInstanceUpdateKey {
+  getUpdateKey(contractAddress: AztecAddress, timestamp: UInt64, logIndex?: number): ContractInstanceUpdateKey {
     if (logIndex === undefined) {
-      return [contractAddress.toString(), blockNumber];
+      return [contractAddress.toString(), timestamp.toString()];
     } else {
-      return [contractAddress.toString(), blockNumber, logIndex];
+      return [contractAddress.toString(), timestamp.toString(), logIndex];
     }
   }
 
   addContractInstanceUpdate(
     contractInstanceUpdate: ContractInstanceUpdateWithAddress,
-    blockNumber: number,
+    timestamp: UInt64,
     logIndex: number,
   ): Promise<void> {
     return this.#contractInstanceUpdates.set(
-      this.getUpdateKey(contractInstanceUpdate.address, blockNumber, logIndex),
+      this.getUpdateKey(contractInstanceUpdate.address, timestamp, logIndex),
       new SerializableContractInstanceUpdate(contractInstanceUpdate).toBuffer(),
     );
   }
 
   deleteContractInstanceUpdate(
     contractInstanceUpdate: ContractInstanceUpdateWithAddress,
-    blockNumber: number,
+    timestamp: UInt64,
     logIndex: number,
   ): Promise<void> {
-    return this.#contractInstanceUpdates.delete(
-      this.getUpdateKey(contractInstanceUpdate.address, blockNumber, logIndex),
-    );
+    return this.#contractInstanceUpdates.delete(this.getUpdateKey(contractInstanceUpdate.address, timestamp, logIndex));
   }
 
-  async getCurrentContractInstanceClassId(
-    address: AztecAddress,
-    blockNumber: number,
-    originalClassId: Fr,
-  ): Promise<Fr> {
-    // We need to find the last update before the given block number
+  async getCurrentContractInstanceClassId(address: AztecAddress, timestamp: UInt64, originalClassId: Fr): Promise<Fr> {
+    // We need to find the last update before the given timestamp
     const queryResult = await this.#contractInstanceUpdates
       .valuesAsync({
         reverse: true,
-        end: this.getUpdateKey(address, blockNumber + 1), // No update can match this key since it doesn't have a log index. We want the highest key <= blockNumber
+        start: this.getUpdateKey(address, 0n), // Make sure we only look at updates for this contract
+        end: this.getUpdateKey(address, timestamp + 1n), // No update can match this key since it doesn't have a log index. We want the highest key <= timestamp
         limit: 1,
       })
       .next();
@@ -81,7 +85,7 @@ export class ContractInstanceStore {
 
     const serializedUpdate = queryResult.value;
     const update = SerializableContractInstanceUpdate.fromBuffer(serializedUpdate);
-    if (blockNumber < update.blockOfChange) {
+    if (timestamp < update.timestampOfChange) {
       return update.prevContractClassId.isZero() ? originalClassId : update.prevContractClassId;
     }
     return update.newContractClassId;
@@ -89,7 +93,7 @@ export class ContractInstanceStore {
 
   async getContractInstance(
     address: AztecAddress,
-    blockNumber: number,
+    timestamp: UInt64,
   ): Promise<ContractInstanceWithAddress | undefined> {
     const contractInstance = await this.#contractInstances.getAsync(address.toString());
     if (!contractInstance) {
@@ -99,9 +103,13 @@ export class ContractInstanceStore {
     const instance = SerializableContractInstance.fromBuffer(contractInstance).withAddress(address);
     instance.currentContractClassId = await this.getCurrentContractInstanceClassId(
       address,
-      blockNumber,
+      timestamp,
       instance.originalContractClassId,
     );
     return instance;
   }
+
+  getContractInstanceDeploymentBlockNumber(address: AztecAddress): Promise<number | undefined> {
+    return this.#contractInstancePublishedAt.getAsync(address.toString());
+  }
 }

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,69 +1,104 @@
+import type { L1BlockId } from '@aztec/ethereum';
 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 type { AztecAsyncKVStore, CustomRange, 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 L2Block, L2BlockHash, type ValidateBlockResult } from '@aztec/stdlib/block';
 import type {
   ContractClassPublic,
+  ContractDataSource,
   ContractInstanceUpdateWithAddress,
   ContractInstanceWithAddress,
   ExecutablePrivateFunctionWithMembershipProof,
-  UnconstrainedFunctionWithMembershipProof,
+  UtilityFunctionWithMembershipProof,
 } 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 { UInt64 } from '@aztec/stdlib/types';
+
+import { join } from 'path';
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
-import type { DataRetrieval } from '../structs/data_retrieval.js';
-import type { L1Published } from '../structs/published.js';
+import type { InboxMessage } from '../structs/inbox_message.js';
+import type { PublishedL2Block } 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';
+
+export const ARCHIVER_DB_VERSION = 3;
+export const MAX_FUNCTION_SIGNATURES = 1000;
+export const MAX_FUNCTION_NAME_LEN = 256;
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
  */
-export class KVArchiverDataStore implements ArchiverDataStore {
-  public static readonly SCHEMA_VERSION = 1;
+export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSource {
+  public static readonly SCHEMA_VERSION = ARCHIVER_DB_VERSION;
 
   #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) {
+  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> {
+  public transactionAsync<T>(callback: () => Promise<T>): Promise<T> {
+    return this.db.transactionAsync(callback);
+  }
+
+  public getBlockNumber(): Promise<number> {
+    return this.getSynchedL2BlockNumber();
+  }
+
+  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(_address: AztecAddress, signatures: string[]): Promise<void> {
+  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('(')));
+        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`);
       }
@@ -78,9 +113,12 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#contractClassStore.getContractClassIds();
   }
 
-  async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    const contract = this.#contractInstanceStore.getContractInstance(address, await this.getSynchedL2BlockNumber());
-    return contract;
+  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(
@@ -108,36 +146,35 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   addFunctions(
     contractClassId: Fr,
     privateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
-    unconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[],
+    utilityFunctions: UtilityFunctionWithMembershipProof[],
   ): Promise<boolean> {
-    return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, unconstrainedFunctions);
+    return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, utilityFunctions);
   }
 
-  async addContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
-    return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
+  async addContractInstances(data: ContractInstanceWithAddress[], blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c, blockNumber)))).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> {
+  async addContractInstanceUpdates(data: ContractInstanceUpdateWithAddress[], timestamp: UInt64): Promise<boolean> {
     return (
       await Promise.all(
         data.map((update, logIndex) =>
-          this.#contractInstanceStore.addContractInstanceUpdate(update, blockNumber, logIndex),
+          this.#contractInstanceStore.addContractInstanceUpdate(update, timestamp, logIndex),
         ),
       )
     ).every(Boolean);
   }
-  async deleteContractInstanceUpdates(
-    data: ContractInstanceUpdateWithAddress[],
-    blockNumber: number,
-  ): Promise<boolean> {
+  async deleteContractInstanceUpdates(data: ContractInstanceUpdateWithAddress[], timestamp: UInt64): Promise<boolean> {
     return (
       await Promise.all(
         data.map((update, logIndex) =>
-          this.#contractInstanceStore.deleteContractInstanceUpdate(update, blockNumber, logIndex),
+          this.#contractInstanceStore.deleteContractInstanceUpdate(update, timestamp, logIndex),
         ),
       )
     ).every(Boolean);
@@ -148,8 +185,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @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);
+  addBlocks(blocks: PublishedL2Block[], opts: { force?: boolean } = {}): Promise<boolean> {
+    return this.#blockStore.addBlocks(blocks, opts);
   }
 
   /**
@@ -163,6 +200,18 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#blockStore.unwindBlocks(from, blocksToUnwind);
   }
 
+  getPublishedBlock(number: number): Promise<PublishedL2Block | undefined> {
+    return this.#blockStore.getBlock(number);
+  }
+
+  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+    return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
+  }
+
+  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+    return this.#blockStore.getBlockByArchive(archive);
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    *
@@ -170,7 +219,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  getBlocks(start: number, limit: number): Promise<L1Published<L2Block>[]> {
+  getPublishedBlocks(start: number, limit: number): Promise<PublishedL2Block[]> {
     return toArray(this.#blockStore.getBlocks(start, limit));
   }
 
@@ -185,10 +234,18 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     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 txHash of the tx corresponding to the tx effect.
-   * @returns The requested tx effect (or undefined if not found).
+   * @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);
@@ -216,33 +273,19 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     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();
   }
 
+  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 and the last processed L1 block.
-   * @returns True if the operation is successful.
+   * @param messages - The L1 to L2 messages to be added to the store.
    */
-  addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
+  addL1ToL2Messages(messages: InboxMessage[]): Promise<void> {
     return this.#messageStore.addL1ToL2Messages(messages);
   }
 
@@ -260,7 +303,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @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[]> {
+  getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
     return this.#messageStore.getL1ToL2Messages(blockNumber);
   }
 
@@ -277,12 +320,13 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   /**
    * 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.
+   * @param logsPerTag - How many logs to return per tag. Default returns everything
    * @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[][]> {
+  getLogsByTags(tags: Fr[], logsPerTag?: number): Promise<TxScopedL2Log[][]> {
     try {
-      return this.#logStore.getLogsByTags(tags);
+      return this.#logStore.getLogsByTags(tags, logsPerTag);
     } catch (err) {
       return Promise.reject(err);
     }
@@ -334,8 +378,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
   }
 
-  async setMessageSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    await this.#messageStore.setSynchedL1BlockNumber(l1BlockNumber);
+  async setMessageSynchedL1Block(l1Block: L1BlockId) {
+    await this.#messageStore.setSynchedL1Block(l1Block);
   }
 
   /**
@@ -344,7 +388,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   async getSynchPoint(): Promise<ArchiverL1SynchPoint> {
     const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
       this.#blockStore.getSynchedL1BlockNumber(),
-      this.#messageStore.getSynchedL1BlockNumber(),
+      this.#messageStore.getSynchedL1Block(),
     ]);
     return {
       blocksSynchedTo,
@@ -355,4 +399,24 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   public estimateSize(): Promise<StoreSize> {
     return this.db.estimateSize();
   }
+
+  public rollbackL1ToL2MessagesToL2Block(targetBlockNumber: number): Promise<void> {
+    return this.#messageStore.rollbackL1ToL2MessagesToL2Block(targetBlockNumber);
+  }
+
+  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);
+  }
 }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,4 +1,4 @@
-import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
@@ -30,7 +30,11 @@ export class LogStore {
   #logsMaxPageSize: number;
   #log = createLogger('archiver:log_store');
 
-  constructor(private db: AztecAsyncKVStore, private blockStore: BlockStore, logsMaxPageSize: number = 1000) {
+  constructor(
+    private db: AztecAsyncKVStore,
+    private blockStore: BlockStore,
+    logsMaxPageSize: number = 1000,
+  ) {
     this.#logsByTag = db.openMap('archiver_tagged_logs_by_tag');
     this.#logTagsByBlock = db.openMap('archiver_log_tags_by_block');
     this.#privateLogsByBlock = db.openMap('archiver_private_logs_by_block');
@@ -40,7 +44,7 @@ export class LogStore {
     this.#logsMaxPageSize = logsMaxPageSize;
   }
 
-  #extractTaggedLogsFromPrivate(block: L2Block) {
+  #extractTaggedLogs(block: L2Block) {
     const taggedLogs = new Map<string, Buffer[]>();
     const dataStartIndexForBlock =
       block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
@@ -48,68 +52,22 @@ export class LogStore {
     block.body.txEffects.forEach((txEffect, txIndex) => {
       const txHash = txEffect.txHash;
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
-      txEffect.privateLogs.forEach(log => {
+
+      txEffect.privateLogs.forEach((log, logIndex) => {
         const tag = log.fields[0];
+        this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
+
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-        currentLogs.push(
-          new TxScopedL2Log(
-            txHash,
-            dataStartIndexForTx,
-            block.number,
-            /* isFromPublic */ false,
-            log.toBuffer(),
-          ).toBuffer(),
-        );
+        currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, logIndex, block.number, log).toBuffer());
         taggedLogs.set(tag.toString(), currentLogs);
       });
-    });
-    return taggedLogs;
-  }
-
-  #extractTaggedLogsFromPublic(block: L2Block) {
-    const taggedLogs = new Map<string, Buffer[]>();
-    const dataStartIndexForBlock =
-      block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
-      block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
-    block.body.txEffects.forEach((txEffect, txIndex) => {
-      const txHash = txEffect.txHash;
-      const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
-      txEffect.publicLogs.forEach(log => {
-        // Check that each log stores 2 lengths in its first field. If not, it's not a tagged log:
-        const firstFieldBuf = log.log[0].toBuffer();
-        // See macros/note/mod/ and see how finalization_log[0] is constructed, to understand this monstrosity. (It wasn't me).
-        // Search the codebase for "disgusting encoding" to see other hardcoded instances of this encoding, that you might need to change if you ever find yourself here.
-        if (!firstFieldBuf.subarray(0, 27).equals(Buffer.alloc(27)) || firstFieldBuf[29] !== 0) {
-          // See parseLogFromPublic - the first field of a tagged log is 5 bytes structured:
-          // [ publicLen[0], publicLen[1], 0, privateLen[0], privateLen[1]]
-          this.#log.warn(`Skipping public log with invalid first field: ${log.log[0]}`);
-          return;
-        }
-        // Check that the length values line up with the log contents
-        const publicValuesLength = firstFieldBuf.subarray(-5).readUint16BE();
-        const privateValuesLength = firstFieldBuf.subarray(-5).readUint16BE(3);
-        // Add 1 for the first field holding lengths
-        const totalLogLength = 1 + publicValuesLength + privateValuesLength;
-        // Note that zeroes can be valid log values, so we can only assert that we do not go over the given length
-        if (totalLogLength > PUBLIC_LOG_DATA_SIZE_IN_FIELDS || log.log.slice(totalLogLength).find(f => !f.isZero())) {
-          this.#log.warn(`Skipping invalid tagged public log with first field: ${log.log[0]}`);
-          return;
-        }
 
-        // The first elt stores lengths as above => tag is in fields[1]
-        const tag = log.log[1];
+      txEffect.publicLogs.forEach((log, logIndex) => {
+        const tag = log.fields[0];
+        this.#log.debug(`Found public log with tag ${tag.toString()} in block ${block.number}`);
 
-        this.#log.debug(`Found tagged public log with tag ${tag.toString()} in block ${block.number}`);
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-        currentLogs.push(
-          new TxScopedL2Log(
-            txHash,
-            dataStartIndexForTx,
-            block.number,
-            /* isFromPublic */ true,
-            log.toBuffer(),
-          ).toBuffer(),
-        );
+        currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, logIndex, block.number, log).toBuffer());
         taggedLogs.set(tag.toString(), currentLogs);
       });
     });
@@ -123,14 +81,14 @@ export class LogStore {
    */
   addLogs(blocks: L2Block[]): Promise<boolean> {
     const taggedLogsToAdd = blocks
-      .flatMap(block => [this.#extractTaggedLogsFromPrivate(block), this.#extractTaggedLogsFromPublic(block)])
+      .map(block => this.#extractTaggedLogs(block))
       .reduce((acc, val) => {
         for (const [tag, logs] of val.entries()) {
           const currentLogs = acc.get(tag) ?? [];
           acc.set(tag, currentLogs.concat(logs));
         }
         return acc;
-      });
+      }, new Map());
     const tagsToUpdate = Array.from(taggedLogsToAdd.keys());
 
     return this.db.transactionAsync(async () => {
@@ -204,6 +162,7 @@ export class LogStore {
             this.#privateLogsByBlock.delete(block.number),
             this.#publicLogsByBlock.delete(block.number),
             this.#logTagsByBlock.delete(block.number),
+            this.#contractClassLogsByBlock.delete(block.number),
           ]),
         ),
       );
@@ -236,10 +195,13 @@ export class LogStore {
    * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
    * that tag.
    */
-  async getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
+  async getLogsByTags(tags: Fr[], limitPerTag?: number): Promise<TxScopedL2Log[][]> {
+    if (limitPerTag !== undefined && limitPerTag <= 0) {
+      throw new TypeError('limitPerTag needs to be greater than 0');
+    }
     const logs = await Promise.all(tags.map(tag => this.#logsByTag.getAsync(tag.toString())));
     return logs.map(
-      noteLogBuffers => noteLogBuffers?.map(noteLogBuffer => TxScopedL2Log.fromBuffer(noteLogBuffer)) ?? [],
+      logBuffers => logBuffers?.slice(0, limitPerTag).map(logBuffer => TxScopedL2Log.fromBuffer(logBuffer)) ?? [],
     );
   }