@aztec/archiver 0.72.1 → 0.74.0

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -7,17 +7,18 @@ import {
   type UnconstrainedFunctionWithMembershipProof,
   Vector,
 } from '@aztec/circuits.js';
+import { toArray } from '@aztec/foundation/iterable';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
-import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class ContractClassStore {
-  #contractClasses: AztecMap<string, Buffer>;
-  #bytecodeCommitments: AztecMap<string, Buffer>;
+  #contractClasses: AztecAsyncMap<string, Buffer>;
+  #bytecodeCommitments: AztecAsyncMap<string, Buffer>;
 
-  constructor(private db: AztecKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#contractClasses = db.openMap('archiver_contract_classes');
     this.#bytecodeCommitments = db.openMap('archiver_bytecode_commitments');
   }
@@ -35,25 +36,25 @@ export class ContractClassStore {
   }
 
   async deleteContractClasses(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
-    const restoredContractClass = this.#contractClasses.get(contractClass.id.toString());
+    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());
     }
   }
 
-  getContractClass(id: Fr): ContractClassPublic | undefined {
-    const contractClass = this.#contractClasses.get(id.toString());
+  async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
+    const contractClass = await this.#contractClasses.getAsync(id.toString());
     return contractClass && { ...deserializeContractClassPublic(contractClass), id };
   }
 
-  getBytecodeCommitment(id: Fr): Fr | undefined {
-    const value = this.#bytecodeCommitments.get(id.toString());
+  async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
+    const value = await this.#bytecodeCommitments.getAsync(id.toString());
     return value === undefined ? undefined : Fr.fromBuffer(value);
   }
 
-  getContractClassIds(): Fr[] {
-    return Array.from(this.#contractClasses.keys()).map(key => Fr.fromHexString(key));
+  async getContractClassIds(): Promise<Fr[]> {
+    return (await toArray(this.#contractClasses.keysAsync())).map(key => Fr.fromHexString(key));
   }
 
   async addFunctions(
@@ -61,8 +62,8 @@ export class ContractClassStore {
     newPrivateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
     newUnconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[],
   ): Promise<boolean> {
-    await this.db.transaction(() => {
-      const existingClassBuffer = this.#contractClasses.get(contractClassId.toString());
+    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`);
       }
@@ -83,9 +84,10 @@ export class ContractClassStore {
           ),
         ],
       };
-      void this.#contractClasses.set(contractClassId.toString(), serializeContractClassPublic(updatedClass));
+      await this.#contractClasses.set(contractClassId.toString(), serializeContractClassPublic(updatedClass));
     });
-    return Promise.resolve(true);
+
+    return true;
   }
 }
 

package/src/archiver/kv_archiver_store/contract_instance_store.ts

@@ -1,13 +1,13 @@
 import { type AztecAddress, type ContractInstanceWithAddress, SerializableContractInstance } from '@aztec/circuits.js';
-import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class ContractInstanceStore {
-  #contractInstances: AztecMap<string, Buffer>;
+  #contractInstances: AztecAsyncMap<string, Buffer>;
 
-  constructor(db: AztecKVStore) {
+  constructor(db: AztecAsyncKVStore) {
     this.#contractInstances = db.openMap('archiver_contract_instances');
   }
 
@@ -22,8 +22,8 @@ export class ContractInstanceStore {
     return this.#contractInstances.delete(contractInstance.address.toString());
   }
 
-  getContractInstance(address: AztecAddress): ContractInstanceWithAddress | undefined {
-    const contractInstance = this.#contractInstances.get(address.toString());
+  async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    const contractInstance = await this.#contractInstances.getAsync(address.toString());
     return contractInstance && SerializableContractInstance.fromBuffer(contractInstance).withAddress(address);
   }
 }

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -20,8 +20,9 @@ import {
 } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
+import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore } from '@aztec/kv-store';
+import { type AztecAsyncKVStore, type StoreSize } from '@aztec/kv-store';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from '../archiver_store.js';
 import { type DataRetrieval } from '../structs/data_retrieval.js';
@@ -47,7 +48,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
 
   #log = createLogger('archiver:data-store');
 
-  constructor(private db: AztecKVStore, 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);
@@ -63,30 +64,28 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return Promise.resolve(this.functionNames.get(selector.toString()));
   }
 
-  registerContractFunctionSignatures(_address: AztecAddress, signatures: string[]): Promise<void> {
+  async registerContractFunctionSignatures(_address: AztecAddress, signatures: string[]): Promise<void> {
     for (const sig of signatures) {
       try {
-        const selector = FunctionSelector.fromSignature(sig);
+        const selector = await FunctionSelector.fromSignature(sig);
         this.functionNames.set(selector.toString(), sig.slice(0, sig.indexOf('(')));
       } catch {
         this.#log.warn(`Failed to parse signature: ${sig}. Ignoring`);
       }
     }
-
-    return Promise.resolve();
   }
 
   getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    return Promise.resolve(this.#contractClassStore.getContractClass(id));
+    return this.#contractClassStore.getContractClass(id);
   }
 
   getContractClassIds(): Promise<Fr[]> {
-    return Promise.resolve(this.#contractClassStore.getContractClassIds());
+    return this.#contractClassStore.getContractClassIds();
   }
 
   getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
     const contract = this.#contractInstanceStore.getContractInstance(address);
-    return Promise.resolve(contract);
+    return contract;
   }
 
   async addContractClasses(
@@ -108,7 +107,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
-    return Promise.resolve(this.#contractClassStore.getBytecodeCommitment(contractClassId));
+    return this.#contractClassStore.getBytecodeCommitment(contractClassId);
   }
 
   addFunctions(
@@ -155,12 +154,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns The requested L2 blocks
    */
   getBlocks(start: number, limit: number): Promise<L1Published<L2Block>[]> {
-    try {
-      return Promise.resolve(Array.from(this.#blockStore.getBlocks(start, limit)));
-    } catch (err) {
-      // this function is sync so if any errors are thrown we need to make sure they're passed on as rejected Promises
-      return Promise.reject(err);
-    }
+    return toArray(this.#blockStore.getBlocks(start, limit));
   }
 
   /**
@@ -171,12 +165,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns The requested L2 blocks
    */
   getBlockHeaders(start: number, limit: number): Promise<BlockHeader[]> {
-    try {
-      return Promise.resolve(Array.from(this.#blockStore.getBlockHeaders(start, limit)));
-    } catch (err) {
-      // this function is sync so if any errors are thrown we need to make sure they're passed on as rejected Promises
-      return Promise.reject(err);
-    }
+    return toArray(this.#blockStore.getBlockHeaders(start, limit));
   }
 
   /**
@@ -185,7 +174,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns The requested tx effect (or undefined if not found).
    */
   getTxEffect(txHash: TxHash) {
-    return Promise.resolve(this.#blockStore.getTxEffect(txHash));
+    return this.#blockStore.getTxEffect(txHash);
   }
 
   /**
@@ -194,7 +183,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns The requested tx receipt (or undefined if not found).
    */
   getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
-    return Promise.resolve(this.#blockStore.getSettledTxReceipt(txHash));
+    return this.#blockStore.getSettledTxReceipt(txHash);
   }
 
   /**
@@ -228,7 +217,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   getTotalL1ToL2MessageCount(): Promise<bigint> {
-    return Promise.resolve(this.#messageStore.getTotalL1ToL2MessageCount());
+    return this.#messageStore.getTotalL1ToL2MessageCount();
   }
 
   /**
@@ -237,7 +226,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns True if the operation is successful.
    */
   addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
-    return Promise.resolve(this.#messageStore.addL1ToL2Messages(messages));
+    return this.#messageStore.addL1ToL2Messages(messages);
   }
 
   /**
@@ -246,7 +235,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @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 Promise.resolve(this.#messageStore.getL1ToL2MessageIndex(l1ToL2Message));
+    return this.#messageStore.getL1ToL2MessageIndex(l1ToL2Message);
   }
 
   /**
@@ -255,11 +244,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
    */
   getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
-    try {
-      return Promise.resolve(this.#messageStore.getL1ToL2Messages(blockNumber));
-    } catch (err) {
-      return Promise.reject(err);
-    }
+    return this.#messageStore.getL1ToL2Messages(blockNumber);
   }
 
   /**
@@ -269,11 +254,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns An array of private logs from the specified range of blocks.
    */
   getPrivateLogs(from: number, limit: number): Promise<PrivateLog[]> {
-    try {
-      return Promise.resolve(Array.from(this.#logStore.getPrivateLogs(from, limit)));
-    } catch (err) {
-      return Promise.reject(err);
-    }
+    return this.#logStore.getPrivateLogs(from, limit);
   }
 
   /**
@@ -297,7 +278,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    */
   getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
     try {
-      return Promise.resolve(this.#logStore.getPublicLogs(filter));
+      return this.#logStore.getPublicLogs(filter);
     } catch (err) {
       return Promise.reject(err);
     }
@@ -310,7 +291,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    */
   getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     try {
-      return Promise.resolve(this.#logStore.getContractClassLogs(filter));
+      return this.#logStore.getContractClassLogs(filter);
     } catch (err) {
       return Promise.reject(err);
     }
@@ -321,48 +302,48 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns The number of the latest L2 block processed.
    */
   getSynchedL2BlockNumber(): Promise<number> {
-    return Promise.resolve(this.#blockStore.getSynchedL2BlockNumber());
+    return this.#blockStore.getSynchedL2BlockNumber();
   }
 
   getProvenL2BlockNumber(): Promise<number> {
-    return Promise.resolve(this.#blockStore.getProvenL2BlockNumber());
+    return this.#blockStore.getProvenL2BlockNumber();
   }
 
   getProvenL2EpochNumber(): Promise<number | undefined> {
-    return Promise.resolve(this.#blockStore.getProvenL2EpochNumber());
+    return this.#blockStore.getProvenL2EpochNumber();
   }
 
-  setProvenL2BlockNumber(blockNumber: number) {
-    this.#blockStore.setProvenL2BlockNumber(blockNumber);
-    return Promise.resolve();
+  async setProvenL2BlockNumber(blockNumber: number) {
+    await this.#blockStore.setProvenL2BlockNumber(blockNumber);
   }
 
-  setProvenL2EpochNumber(epochNumber: number) {
-    this.#blockStore.setProvenL2EpochNumber(epochNumber);
-    return Promise.resolve();
+  async setProvenL2EpochNumber(epochNumber: number) {
+    await this.#blockStore.setProvenL2EpochNumber(epochNumber);
   }
 
-  setBlockSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
-    return Promise.resolve();
+  async setBlockSynchedL1BlockNumber(l1BlockNumber: bigint) {
+    await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
   }
 
-  setMessageSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    this.#messageStore.setSynchedL1BlockNumber(l1BlockNumber);
-    return Promise.resolve();
+  async setMessageSynchedL1BlockNumber(l1BlockNumber: bigint) {
+    await this.#messageStore.setSynchedL1BlockNumber(l1BlockNumber);
   }
 
   /**
    * Gets the last L1 block number processed by the archiver
    */
-  getSynchPoint(): Promise<ArchiverL1SynchPoint> {
-    return Promise.resolve({
-      blocksSynchedTo: this.#blockStore.getSynchedL1BlockNumber(),
-      messagesSynchedTo: this.#messageStore.getSynchedL1BlockNumber(),
-    });
-  }
-
-  public estimateSize(): { mappingSize: number; actualSize: number; numItems: number } {
+  async getSynchPoint(): Promise<ArchiverL1SynchPoint> {
+    const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
+      this.#blockStore.getSynchedL1BlockNumber(),
+      this.#messageStore.getSynchedL1BlockNumber(),
+    ]);
+    return {
+      blocksSynchedTo,
+      messagesSynchedTo,
+    };
+  }
+
+  public estimateSize(): Promise<StoreSize> {
     return this.db.estimateSize();
   }
 }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -18,7 +18,7 @@ import {
 } from '@aztec/circuits.js/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
-import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 
 import { type BlockStore } from './block_store.js';
 
@@ -26,15 +26,15 @@ import { type BlockStore } from './block_store.js';
  * A store for logs
  */
 export class LogStore {
-  #logsByTag: AztecMap<string, Buffer[]>;
-  #logTagsByBlock: AztecMap<number, string[]>;
-  #privateLogsByBlock: AztecMap<number, Buffer>;
-  #publicLogsByBlock: AztecMap<number, Buffer>;
-  #contractClassLogsByBlock: AztecMap<number, Buffer>;
+  #logsByTag: AztecAsyncMap<string, Buffer[]>;
+  #logTagsByBlock: AztecAsyncMap<number, string[]>;
+  #privateLogsByBlock: AztecAsyncMap<number, Buffer>;
+  #publicLogsByBlock: AztecAsyncMap<number, Buffer>;
+  #contractClassLogsByBlock: AztecAsyncMap<number, Buffer>;
   #logsMaxPageSize: number;
   #log = createLogger('archiver:log_store');
 
-  constructor(private db: AztecKVStore, 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');
@@ -79,21 +79,19 @@ export class LogStore {
       const txHash = txEffect.txHash;
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
       txEffect.publicLogs.forEach(log => {
-        // Check that each log stores 3 lengths in its first field. If not, it's not a tagged 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();
-        if (
-          !firstFieldBuf.subarray(0, 24).equals(Buffer.alloc(24)) ||
-          firstFieldBuf[26] !== 0 ||
-          firstFieldBuf[29] !== 0
-        ) {
-          // See parseLogFromPublic - the first field of a tagged log is 8 bytes structured:
-          // [ publicLen[0], publicLen[1], 0, privateLen[0], privateLen[1], 0, ciphertextLen[0], ciphertextLen[1]]
+        // 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(-8).readUint16BE();
-        const privateValuesLength = firstFieldBuf.subarray(-8).readUint16BE(3);
+        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
@@ -127,7 +125,7 @@ export class LogStore {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  async addLogs(blocks: L2Block[]): Promise<boolean> {
+  addLogs(blocks: L2Block[]): Promise<boolean> {
     const taggedLogsToAdd = blocks
       .flatMap(block => [this.#extractTaggedLogsFromPrivate(block), this.#extractTaggedLogsFromPublic(block)])
       .reduce((acc, val) => {
@@ -138,31 +136,32 @@ export class LogStore {
         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 => {
+
+    return this.db.transactionAsync(async () => {
+      const currentTaggedLogs = await Promise.all(
+        tagsToUpdate.map(async tag => ({ tag, logBuffers: await this.#logsByTag.getAsync(tag) })),
+      );
+      currentTaggedLogs.forEach(taggedLogBuffer => {
+        if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+          taggedLogsToAdd.set(
+            taggedLogBuffer.tag,
+            taggedLogBuffer.logBuffers!.concat(taggedLogsToAdd.get(taggedLogBuffer.tag)!),
+          );
+        }
+      });
+      for (const block of blocks) {
         const tagsInBlock = [];
         for (const [tag, logs] of taggedLogsToAdd.entries()) {
-          void this.#logsByTag.set(tag, logs);
+          await this.#logsByTag.set(tag, logs);
           tagsInBlock.push(tag);
         }
-        void this.#logTagsByBlock.set(block.number, tagsInBlock);
+        await this.#logTagsByBlock.set(block.number, tagsInBlock);
 
         const privateLogsInBlock = block.body.txEffects
           .map(txEffect => txEffect.privateLogs)
           .flat()
           .map(log => log.toBuffer());
-        void this.#privateLogsByBlock.set(block.number, Buffer.concat(privateLogsInBlock));
+        await this.#privateLogsByBlock.set(block.number, Buffer.concat(privateLogsInBlock));
 
         const publicLogsInBlock = block.body.txEffects
           .map((txEffect, txIndex) =>
@@ -174,29 +173,36 @@ export class LogStore {
           )
           .flat();
 
-        void this.#publicLogsByBlock.set(block.number, Buffer.concat(publicLogsInBlock));
-        void this.#contractClassLogsByBlock.set(block.number, block.body.contractClassLogs.toBuffer());
-      });
+        await this.#publicLogsByBlock.set(block.number, Buffer.concat(publicLogsInBlock));
+        await this.#contractClassLogsByBlock.set(block.number, block.body.contractClassLogs.toBuffer());
+      }
 
       return true;
     });
   }
 
-  async deleteLogs(blocks: L2Block[]): Promise<boolean> {
-    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.#privateLogsByBlock.delete(block.number);
-        void this.#publicLogsByBlock.delete(block.number);
-        void this.#logTagsByBlock.delete(block.number);
-      });
-
-      tagsToDelete.forEach(tag => {
-        void this.#logsByTag.delete(tag.toString());
-      });
-
+  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+    return this.db.transactionAsync(async () => {
+      const tagsToDelete = (
+        await Promise.all(
+          blocks.map(async block => {
+            const tags = await this.#logTagsByBlock.getAsync(block.number);
+            return tags ?? [];
+          }),
+        )
+      ).flat();
+
+      await Promise.all(
+        blocks.map(block =>
+          Promise.all([
+            this.#privateLogsByBlock.delete(block.number),
+            this.#publicLogsByBlock.delete(block.number),
+            this.#logTagsByBlock.delete(block.number),
+          ]),
+        ),
+      );
+
+      await Promise.all(tagsToDelete.map(tag => this.#logsByTag.delete(tag.toString())));
       return true;
     });
   }
@@ -207,9 +213,9 @@ export class LogStore {
    * @param limit - The maximum number of blocks to retrieve logs from.
    * @returns An array of private logs from the specified range of blocks.
    */
-  getPrivateLogs(start: number, limit: number) {
+  async getPrivateLogs(start: number, limit: number): Promise<PrivateLog[]> {
     const logs = [];
-    for (const buffer of this.#privateLogsByBlock.values({ start, limit })) {
+    for await (const buffer of this.#privateLogsByBlock.valuesAsync({ start, limit })) {
       const reader = new BufferReader(buffer);
       while (reader.remainingBytes() > 0) {
         logs.push(reader.readObject(PrivateLog));
@@ -224,11 +230,10 @@ 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<TxScopedL2Log[][]> {
-    return this.db.transaction(() =>
-      tags
-        .map(tag => this.#logsByTag.get(tag.toString()))
-        .map(noteLogBuffers => noteLogBuffers?.map(noteLogBuffer => TxScopedL2Log.fromBuffer(noteLogBuffer)) ?? []),
+  async getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
+    const logs = await Promise.all(tags.map(tag => this.#logsByTag.getAsync(tag.toString())));
+    return logs.map(
+      noteLogBuffers => noteLogBuffers?.map(noteLogBuffer => TxScopedL2Log.fromBuffer(noteLogBuffer)) ?? [],
     );
   }
 
@@ -237,7 +242,7 @@ export class LogStore {
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getPublicLogs(filter: LogFilter): GetPublicLogsResponse {
+  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
     if (filter.afterLog) {
       return this.#filterPublicLogsBetweenBlocks(filter);
     } else if (filter.txHash) {
@@ -247,17 +252,17 @@ export class LogStore {
     }
   }
 
-  #filterPublicLogsOfTx(filter: LogFilter): GetPublicLogsResponse {
+  async #filterPublicLogsOfTx(filter: LogFilter): Promise<GetPublicLogsResponse> {
     if (!filter.txHash) {
       throw new Error('Missing txHash');
     }
 
-    const [blockNumber, txIndex] = this.blockStore.getTxLocation(filter.txHash) ?? [];
+    const [blockNumber, txIndex] = (await this.blockStore.getTxLocation(filter.txHash)) ?? [];
     if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
       return { logs: [], maxLogsHit: false };
     }
 
-    const buffer = this.#publicLogsByBlock.get(blockNumber) ?? Buffer.alloc(0);
+    const buffer = (await this.#publicLogsByBlock.getAsync(blockNumber)) ?? Buffer.alloc(0);
     const publicLogsInBlock: [PublicLog[]] = [[]];
     const reader = new BufferReader(buffer);
     while (reader.remainingBytes() > 0) {
@@ -277,7 +282,7 @@ export class LogStore {
     return { logs, maxLogsHit };
   }
 
-  #filterPublicLogsBetweenBlocks(filter: LogFilter): GetPublicLogsResponse {
+  async #filterPublicLogsBetweenBlocks(filter: LogFilter): Promise<GetPublicLogsResponse> {
     const start =
       filter.afterLog?.blockNumber ?? Math.max(filter.fromBlock ?? INITIAL_L2_BLOCK_NUM, INITIAL_L2_BLOCK_NUM);
     const end = filter.toBlock;
@@ -292,7 +297,7 @@ export class LogStore {
     const logs: ExtendedPublicLog[] = [];
 
     let maxLogsHit = false;
-    loopOverBlocks: for (const [blockNumber, logBuffer] of this.#publicLogsByBlock.entries({ start, end })) {
+    loopOverBlocks: for await (const [blockNumber, logBuffer] of this.#publicLogsByBlock.entriesAsync({ start, end })) {
       const publicLogsInBlock: [PublicLog[]] = [[]];
       const reader = new BufferReader(logBuffer);
       while (reader.remainingBytes() > 0) {
@@ -321,7 +326,7 @@ export class LogStore {
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getContractClassLogs(filter: LogFilter): GetContractClassLogsResponse {
+  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     if (filter.afterLog) {
       return this.#filterContractClassLogsBetweenBlocks(filter);
     } else if (filter.txHash) {
@@ -331,16 +336,16 @@ export class LogStore {
     }
   }
 
-  #filterContractClassLogsOfTx(filter: LogFilter): GetContractClassLogsResponse {
+  async #filterContractClassLogsOfTx(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     if (!filter.txHash) {
       throw new Error('Missing txHash');
     }
 
-    const [blockNumber, txIndex] = this.blockStore.getTxLocation(filter.txHash) ?? [];
+    const [blockNumber, txIndex] = (await this.blockStore.getTxLocation(filter.txHash)) ?? [];
     if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
       return { logs: [], maxLogsHit: false };
     }
-    const contractClassLogsBuffer = this.#contractClassLogsByBlock.get(blockNumber);
+    const contractClassLogsBuffer = await this.#contractClassLogsByBlock.getAsync(blockNumber);
     const contractClassLogsInBlock = contractClassLogsBuffer
       ? ContractClass2BlockL2Logs.fromBuffer(contractClassLogsBuffer)
       : new ContractClass2BlockL2Logs([]);
@@ -352,7 +357,7 @@ export class LogStore {
     return { logs, maxLogsHit };
   }
 
-  #filterContractClassLogsBetweenBlocks(filter: LogFilter): GetContractClassLogsResponse {
+  async #filterContractClassLogsBetweenBlocks(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     const start =
       filter.afterLog?.blockNumber ?? Math.max(filter.fromBlock ?? INITIAL_L2_BLOCK_NUM, INITIAL_L2_BLOCK_NUM);
     const end = filter.toBlock;
@@ -367,7 +372,10 @@ export class LogStore {
     const logs: ExtendedUnencryptedL2Log[] = [];
 
     let maxLogsHit = false;
-    loopOverBlocks: for (const [blockNumber, logBuffer] of this.#contractClassLogsByBlock.entries({ start, end })) {
+    loopOverBlocks: for await (const [blockNumber, logBuffer] of this.#contractClassLogsByBlock.entriesAsync({
+      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();