@aztec/archiver 0.71.0 → 0.73.0

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,19 +1,24 @@
 import {
   ContractClass2BlockL2Logs,
+  ExtendedPublicLog,
   ExtendedUnencryptedL2Log,
-  type GetUnencryptedLogsResponse,
+  type GetContractClassLogsResponse,
+  type GetPublicLogsResponse,
   type L2Block,
   type LogFilter,
   LogId,
   TxScopedL2Log,
-  UnencryptedL2BlockL2Logs,
-  type UnencryptedL2Log,
+  UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import { Fr, PrivateLog } from '@aztec/circuits.js';
-import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/circuits.js/constants';
+import { type Fr, PrivateLog, PublicLog } from '@aztec/circuits.js';
+import {
+  INITIAL_L2_BLOCK_NUM,
+  MAX_NOTE_HASHES_PER_TX,
+  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+} from '@aztec/circuits.js/constants';
 import { createLogger } from '@aztec/foundation/log';
-import { BufferReader } from '@aztec/foundation/serialize';
-import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 
 import { type BlockStore } from './block_store.js';
 
@@ -21,19 +26,19 @@ 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>;
-  #unencryptedLogsByBlock: 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');
-    this.#unencryptedLogsByBlock = db.openMap('archiver_unencrypted_logs_by_block');
+    this.#publicLogsByBlock = db.openMap('archiver_public_logs_by_block');
     this.#contractClassLogsByBlock = db.openMap('archiver_contract_class_logs_by_block');
 
     this.#logsMaxPageSize = logsMaxPageSize;
@@ -70,39 +75,46 @@ export class LogStore {
     const dataStartIndexForBlock =
       block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
       block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
-    block.body.unencryptedLogs.txLogs.forEach((txLogs, txIndex) => {
-      const txHash = block.body.txEffects[txIndex].txHash;
+    block.body.txEffects.forEach((txEffect, txIndex) => {
+      const txHash = txEffect.txHash;
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
-      const logs = txLogs.unrollLogs();
-      logs.forEach(log => {
-        if (log.data.length < 32 * 33) {
-          // TODO remove when #9835 and #9836 are fixed
-          this.#log.warn(`Skipping unencrypted log with insufficient data length: ${log.data.length}`);
+      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;
         }
-        try {
-          // 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.
-          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);
-          }
-          const tag = new Fr(correctedBuffer);
-
-          this.#log.debug(`Found tagged unencrypted 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.data).toBuffer(),
-          );
-          taggedLogs.set(tag.toString(), currentLogs);
-        } catch (err) {
-          this.#log.warn(`Failed to add tagged log to store: ${err}`);
+        // 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];
+
+        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(),
+        );
+        taggedLogs.set(tag.toString(), currentLogs);
       });
     });
     return taggedLogs;
@@ -113,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) => {
@@ -124,55 +136,73 @@ 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));
-
-        void this.#unencryptedLogsByBlock.set(block.number, block.body.unencryptedLogs.toBuffer());
-        void this.#contractClassLogsByBlock.set(block.number, block.body.contractClassLogs.toBuffer());
-      });
+        await this.#privateLogsByBlock.set(block.number, Buffer.concat(privateLogsInBlock));
+
+        const publicLogsInBlock = block.body.txEffects
+          .map((txEffect, txIndex) =>
+            [
+              numToUInt32BE(txIndex),
+              numToUInt32BE(txEffect.publicLogs.length),
+              txEffect.publicLogs.map(log => log.toBuffer()),
+            ].flat(),
+          )
+          .flat();
+
+        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.#unencryptedLogsByBlock.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;
     });
   }
@@ -183,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));
@@ -200,51 +230,59 @@ 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)) ?? [],
     );
   }
 
   /**
-   * Gets unencrypted logs based on the provided filter.
+   * Gets public logs based on the provided filter.
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getUnencryptedLogs(filter: LogFilter): GetUnencryptedLogsResponse {
+  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
     if (filter.afterLog) {
-      return this.#filterUnencryptedLogsBetweenBlocks(filter);
+      return this.#filterPublicLogsBetweenBlocks(filter);
     } else if (filter.txHash) {
-      return this.#filterUnencryptedLogsOfTx(filter);
+      return this.#filterPublicLogsOfTx(filter);
     } else {
-      return this.#filterUnencryptedLogsBetweenBlocks(filter);
+      return this.#filterPublicLogsBetweenBlocks(filter);
     }
   }
 
-  #filterUnencryptedLogsOfTx(filter: LogFilter): GetUnencryptedLogsResponse {
+  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.#unencryptedLogsByBlock.get(blockNumber) ?? Buffer.alloc(0);
-    const unencryptedLogsInBlock = UnencryptedL2BlockL2Logs.fromBuffer(buffer);
+    const buffer = (await this.#publicLogsByBlock.getAsync(blockNumber)) ?? Buffer.alloc(0);
+    const publicLogsInBlock: [PublicLog[]] = [[]];
+    const reader = new BufferReader(buffer);
+    while (reader.remainingBytes() > 0) {
+      const indexOfTx = reader.readNumber();
+      const numLogsInTx = reader.readNumber();
+      publicLogsInBlock[indexOfTx] = [];
+      for (let i = 0; i < numLogsInTx; i++) {
+        publicLogsInBlock[indexOfTx].push(reader.readObject(PublicLog));
+      }
+    }
 
-    const txLogs = unencryptedLogsInBlock.txLogs[txIndex].unrollLogs();
+    const txLogs = publicLogsInBlock[txIndex];
 
-    const logs: ExtendedUnencryptedL2Log[] = [];
+    const logs: ExtendedPublicLog[] = [];
     const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
 
     return { logs, maxLogsHit };
   }
 
-  #filterUnencryptedLogsBetweenBlocks(filter: LogFilter): GetUnencryptedLogsResponse {
+  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;
@@ -256,13 +294,22 @@ export class LogStore {
       };
     }
 
-    const logs: ExtendedUnencryptedL2Log[] = [];
+    const logs: ExtendedPublicLog[] = [];
 
     let maxLogsHit = false;
-    loopOverBlocks: for (const [blockNumber, logBuffer] of this.#unencryptedLogsByBlock.entries({ start, end })) {
-      const unencryptedLogsInBlock = UnencryptedL2BlockL2Logs.fromBuffer(logBuffer);
-      for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < unencryptedLogsInBlock.txLogs.length; txIndex++) {
-        const txLogs = unencryptedLogsInBlock.txLogs[txIndex].unrollLogs();
+    loopOverBlocks: for await (const [blockNumber, logBuffer] of this.#publicLogsByBlock.entriesAsync({ start, end })) {
+      const publicLogsInBlock: [PublicLog[]] = [[]];
+      const reader = new BufferReader(logBuffer);
+      while (reader.remainingBytes() > 0) {
+        const indexOfTx = reader.readNumber();
+        const numLogsInTx = reader.readNumber();
+        publicLogsInBlock[indexOfTx] = [];
+        for (let i = 0; i < numLogsInTx; i++) {
+          publicLogsInBlock[indexOfTx].push(reader.readObject(PublicLog));
+        }
+      }
+      for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < publicLogsInBlock.length; txIndex++) {
+        const txLogs = publicLogsInBlock[txIndex];
         maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
         if (maxLogsHit) {
           this.#log.debug(`Max logs hit at block ${blockNumber}`);
@@ -279,7 +326,7 @@ export class LogStore {
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getContractClassLogs(filter: LogFilter): GetUnencryptedLogsResponse {
+  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     if (filter.afterLog) {
       return this.#filterContractClassLogsBetweenBlocks(filter);
     } else if (filter.txHash) {
@@ -289,16 +336,16 @@ export class LogStore {
     }
   }
 
-  #filterContractClassLogsOfTx(filter: LogFilter): GetUnencryptedLogsResponse {
+  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([]);
@@ -310,7 +357,7 @@ export class LogStore {
     return { logs, maxLogsHit };
   }
 
-  #filterContractClassLogsBetweenBlocks(filter: LogFilter): GetUnencryptedLogsResponse {
+  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;
@@ -325,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();
@@ -341,10 +391,10 @@ export class LogStore {
   }
 
   #accumulateLogs(
-    results: ExtendedUnencryptedL2Log[],
+    results: (ExtendedUnencryptedL2Log | ExtendedPublicLog)[],
     blockNumber: number,
     txIndex: number,
-    txLogs: UnencryptedL2Log[],
+    txLogs: (UnencryptedL2Log | PublicLog)[],
     filter: LogFilter,
   ): boolean {
     let maxLogsHit = false;
@@ -352,7 +402,12 @@ export class LogStore {
     for (; logIndex < txLogs.length; logIndex++) {
       const log = txLogs[logIndex];
       if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
-        results.push(new ExtendedUnencryptedL2Log(new LogId(blockNumber, txIndex, logIndex), log));
+        if (log instanceof UnencryptedL2Log) {
+          results.push(new ExtendedUnencryptedL2Log(new LogId(blockNumber, txIndex, logIndex), log));
+        } else {
+          results.push(new ExtendedPublicLog(new LogId(blockNumber, txIndex, logIndex), log));
+        }
+
         if (results.length >= this.#logsMaxPageSize) {
           maxLogsHit = true;
           break;

package/src/archiver/kv_archiver_store/message_store.ts

@@ -1,7 +1,7 @@
 import { InboxLeaf } from '@aztec/circuit-types';
 import { Fr, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap, type AztecSingleton } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton } from '@aztec/kv-store';
 
 import { type DataRetrieval } from '../structs/data_retrieval.js';
 
@@ -9,36 +9,36 @@ import { type DataRetrieval } from '../structs/data_retrieval.js';
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class MessageStore {
-  #l1ToL2Messages: AztecMap<string, Buffer>;
-  #l1ToL2MessageIndices: AztecMap<string, bigint>;
-  #lastSynchedL1Block: AztecSingleton<bigint>;
-  #totalMessageCount: AztecSingleton<bigint>;
+  #l1ToL2Messages: AztecAsyncMap<string, Buffer>;
+  #l1ToL2MessageIndices: AztecAsyncMap<string, bigint>;
+  #lastSynchedL1Block: AztecAsyncSingleton<bigint>;
+  #totalMessageCount: AztecAsyncSingleton<bigint>;
 
   #log = createLogger('archiver:message_store');
 
   #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
 
-  constructor(private db: AztecKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#l1ToL2Messages = db.openMap('archiver_l1_to_l2_messages');
     this.#l1ToL2MessageIndices = db.openMap('archiver_l1_to_l2_message_indices');
     this.#lastSynchedL1Block = db.openSingleton('archiver_last_l1_block_new_messages');
     this.#totalMessageCount = db.openSingleton('archiver_l1_to_l2_message_count');
   }
 
-  getTotalL1ToL2MessageCount(): bigint {
-    return this.#totalMessageCount.get() ?? 0n;
+  async getTotalL1ToL2MessageCount(): Promise<bigint> {
+    return (await this.#totalMessageCount.getAsync()) ?? 0n;
   }
 
   /**
    * Gets the last L1 block number that emitted new messages.
    * @returns The last L1 block number processed
    */
-  getSynchedL1BlockNumber(): bigint | undefined {
-    return this.#lastSynchedL1Block.get();
+  getSynchedL1BlockNumber(): Promise<bigint | undefined> {
+    return this.#lastSynchedL1Block.getAsync();
   }
 
-  setSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    void this.#lastSynchedL1Block.set(l1BlockNumber);
+  async setSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void> {
+    await this.#lastSynchedL1Block.set(l1BlockNumber);
   }
 
   /**
@@ -47,22 +47,22 @@ export class MessageStore {
    * @returns True if the operation is successful.
    */
   addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
-    return this.db.transaction(() => {
-      const lastL1BlockNumber = this.#lastSynchedL1Block.get() ?? 0n;
+    return this.db.transactionAsync(async () => {
+      const lastL1BlockNumber = (await this.#lastSynchedL1Block.getAsync()) ?? 0n;
       if (lastL1BlockNumber >= messages.lastProcessedL1BlockNumber) {
         return false;
       }
 
-      void this.#lastSynchedL1Block.set(messages.lastProcessedL1BlockNumber);
+      await this.#lastSynchedL1Block.set(messages.lastProcessedL1BlockNumber);
 
       for (const message of messages.retrievedData) {
         const key = `${message.index}`;
-        void this.#l1ToL2Messages.set(key, message.leaf.toBuffer());
-        void this.#l1ToL2MessageIndices.set(message.leaf.toString(), message.index);
+        await this.#l1ToL2Messages.set(key, message.leaf.toBuffer());
+        await this.#l1ToL2MessageIndices.set(message.leaf.toString(), message.index);
       }
 
-      const lastTotalMessageCount = this.getTotalL1ToL2MessageCount();
-      void this.#totalMessageCount.set(lastTotalMessageCount + BigInt(messages.retrievedData.length));
+      const lastTotalMessageCount = await this.getTotalL1ToL2MessageCount();
+      await this.#totalMessageCount.set(lastTotalMessageCount + BigInt(messages.retrievedData.length));
 
       return true;
     });
@@ -74,17 +74,17 @@ export class MessageStore {
    * @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.#l1ToL2MessageIndices.get(l1ToL2Message.toString()));
+    return this.#l1ToL2MessageIndices.getAsync(l1ToL2Message.toString());
   }
 
-  getL1ToL2Messages(blockNumber: bigint): Fr[] {
+  async getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
     const messages: Fr[] = [];
     let undefinedMessageFound = false;
     const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
     for (let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++) {
       // This is inefficient but probably fine for now.
       const key = `${i}`;
-      const message = this.#l1ToL2Messages.get(key);
+      const message = await this.#l1ToL2Messages.getAsync(key);
       if (message) {
         if (undefinedMessageFound) {
           throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);