@aztec/archiver 0.71.0 → 0.73.0

package/src/archiver/data_retrieval.ts

@@ -1,3 +1,4 @@
+import { type BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import { Body, InboxLeaf, L2Block } from '@aztec/circuit-types';
 import { AppendOnlyTreeSnapshot, BlockHeader, Fr, Proof } from '@aztec/circuits.js';
 import { asyncPool } from '@aztec/foundation/async-pool';
@@ -6,7 +7,7 @@ import { type EthAddress } from '@aztec/foundation/eth-address';
 import { type ViemSignature } from '@aztec/foundation/eth-signature';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { numToUInt32BE } from '@aztec/foundation/serialize';
-import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { ForwarderAbi, type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 
 import {
   type Chain,
@@ -20,6 +21,7 @@ import {
   hexToBytes,
 } from 'viem';
 
+import { NoBlobBodiesFoundError } from './errors.js';
 import { type DataRetrieval } from './structs/data_retrieval.js';
 import { type L1Published, type L1PublishedData } from './structs/published.js';
 
@@ -35,6 +37,7 @@ import { type L1Published, type L1PublishedData } from './structs/published.js';
 export async function retrieveBlocksFromRollup(
   rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>,
   publicClient: PublicClient,
+  blobSinkClient: BlobSinkClientInterface,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
   logger: Logger = createLogger('archiver'),
@@ -63,7 +66,13 @@ export async function retrieveBlocksFromRollup(
       `Got ${l2BlockProposedLogs.length} L2 block processed logs for L2 blocks ${l2BlockProposedLogs[0].args.blockNumber}-${lastLog.args.blockNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
     );
 
-    const newBlocks = await processL2BlockProposedLogs(rollup, publicClient, l2BlockProposedLogs, logger);
+    const newBlocks = await processL2BlockProposedLogs(
+      rollup,
+      publicClient,
+      blobSinkClient,
+      l2BlockProposedLogs,
+      logger,
+    );
     retrievedBlocks.push(...newBlocks);
     searchStartBlock = lastLog.blockNumber! + 1n;
   } while (searchStartBlock <= searchEndBlock);
@@ -80,6 +89,7 @@ export async function retrieveBlocksFromRollup(
 export async function processL2BlockProposedLogs(
   rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>,
   publicClient: PublicClient,
+  blobSinkClient: BlobSinkClientInterface,
   logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
   logger: Logger,
 ): Promise<L1Published<L2Block>[]> {
@@ -88,10 +98,18 @@ export async function processL2BlockProposedLogs(
     const l2BlockNumber = log.args.blockNumber!;
     const archive = log.args.archive!;
     const archiveFromChain = await rollup.read.archiveAt([l2BlockNumber]);
+    const blobHashes = log.args.versionedBlobHashes!.map(blobHash => Buffer.from(blobHash.slice(2), 'hex'));
 
     // The value from the event and contract will match only if the block is in the chain.
     if (archive === archiveFromChain) {
-      const block = await getBlockFromRollupTx(publicClient, log.transactionHash!, l2BlockNumber);
+      const block = await getBlockFromRollupTx(
+        publicClient,
+        blobSinkClient,
+        log.transactionHash!,
+        blobHashes,
+        l2BlockNumber,
+        rollup.address,
+      );
 
       const l1: L1PublishedData = {
         blockNumber: log.blockNumber,
@@ -116,6 +134,57 @@ export async function getL1BlockTime(publicClient: PublicClient, blockNumber: bi
   return block.timestamp;
 }
 
+/**
+ * Extracts the first 'propose' method calldata from a forwarder transaction's data.
+ * @param forwarderData - The forwarder transaction input data
+ * @param rollupAddress - The address of the rollup contract
+ * @returns The calldata for the first 'propose' method call to the rollup contract
+ */
+function extractRollupProposeCalldata(forwarderData: Hex, rollupAddress: Hex): Hex {
+  // TODO(#11451): custom forwarders
+  const { functionName: forwarderFunctionName, args: forwarderArgs } = decodeFunctionData({
+    abi: ForwarderAbi,
+    data: forwarderData,
+  });
+
+  if (forwarderFunctionName !== 'forward') {
+    throw new Error(`Unexpected forwarder method called ${forwarderFunctionName}`);
+  }
+
+  if (forwarderArgs.length !== 2) {
+    throw new Error(`Unexpected number of arguments for forwarder`);
+  }
+
+  const [to, data] = forwarderArgs;
+
+  // Find all rollup calls
+  const rollupAddressLower = rollupAddress.toLowerCase();
+
+  for (let i = 0; i < to.length; i++) {
+    const addr = to[i];
+    if (addr.toLowerCase() !== rollupAddressLower) {
+      continue;
+    }
+    const callData = data[i];
+
+    try {
+      const { functionName: rollupFunctionName } = decodeFunctionData({
+        abi: RollupAbi,
+        data: callData,
+      });
+
+      if (rollupFunctionName === 'propose') {
+        return callData;
+      }
+    } catch (err) {
+      // Skip invalid function data
+      continue;
+    }
+  }
+
+  throw new Error(`Rollup address not found in forwarder args`);
+}
+
 /**
  * Gets block from the calldata of an L1 transaction.
  * Assumes that the block was published from an EOA.
@@ -127,19 +196,26 @@ export async function getL1BlockTime(publicClient: PublicClient, blockNumber: bi
  */
 async function getBlockFromRollupTx(
   publicClient: PublicClient,
+  blobSinkClient: BlobSinkClientInterface,
   txHash: `0x${string}`,
+  blobHashes: Buffer[], // WORKTODO(md): buffer32?
   l2BlockNum: bigint,
+  rollupAddress: Hex,
 ): Promise<L2Block> {
-  const { input: data } = await publicClient.getTransaction({ hash: txHash });
-  const { functionName, args } = decodeFunctionData({ abi: RollupAbi, data });
+  const { input: forwarderData, blockHash } = await publicClient.getTransaction({ hash: txHash });
 
-  const allowedMethods = ['propose', 'proposeAndClaim'];
+  const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
+  const { functionName: rollupFunctionName, args: rollupArgs } = decodeFunctionData({
+    abi: RollupAbi,
+    data: rollupData,
+  });
 
-  if (!allowedMethods.includes(functionName)) {
-    throw new Error(`Unexpected method called ${functionName}`);
+  if (rollupFunctionName !== 'propose') {
+    throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
   }
+
   // TODO(#9101): 'bodyHex' will be removed from below
-  const [decodedArgs, , bodyHex, blobInputs] = args! as readonly [
+  const [decodedArgs, , bodyHex, blobInputs] = rollupArgs! as readonly [
     {
       header: Hex;
       archive: Hex;
@@ -156,16 +232,22 @@ async function getBlockFromRollupTx(
   ];
 
   const header = BlockHeader.fromBuffer(Buffer.from(hexToBytes(decodedArgs.header)));
+
+  const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
+  if (blobBodies.length === 0) {
+    throw new NoBlobBodiesFoundError(Number(l2BlockNum));
+  }
+
+  const blockFields = blobBodies.flatMap(b => b.toEncodedFields());
   // TODO(#9101): Retreiving the block body from calldata is a temporary soln before we have
   // either a beacon chain client or link to some blob store. Web2 is ok because we will
   // verify the block body vs the blob as below.
   const blockBody = Body.fromBuffer(Buffer.from(hexToBytes(bodyHex)));
 
-  const blockFields = blockBody.toBlobFields();
   // TODO(#9101): The below reconstruction is currently redundant, but once we extract blobs will be the way to construct blocks.
   // The blob source will give us blockFields, and we must construct the body from them:
   // TODO(#8954): When logs are refactored into fields, we won't need to inject them here.
-  const reconstructedBlock = Body.fromBlobFields(blockFields, blockBody.unencryptedLogs, blockBody.contractClassLogs);
+  const reconstructedBlock = Body.fromBlobFields(blockFields, blockBody.contractClassLogs);
 
   if (!reconstructedBlock.toBuffer().equals(blockBody.toBuffer())) {
     // TODO(#9101): Remove below check (without calldata there will be nothing to check against)
@@ -173,7 +255,7 @@ async function getBlockFromRollupTx(
   }
 
   // TODO(#9101): Once we stop publishing calldata, we will still need the blobCheck below to ensure that the block we are building does correspond to the blob fields
-  const blobCheck = Blob.getBlobs(blockFields);
+  const blobCheck = await Blob.getBlobs(blockFields);
   if (Blob.getEthBlobEvaluationInputs(blobCheck) !== blobInputs) {
     // NB: We can just check the blobhash here, which is the first 32 bytes of blobInputs
     // A mismatch means that the fields published in the blob in propose() do NOT match those in the extracted block.

package/src/archiver/errors.ts

@@ -0,0 +1,5 @@
+export class NoBlobBodiesFoundError extends Error {
+  constructor(l2BlockNum: number) {
+    super(`No blob bodies found for block ${l2BlockNum}`);
+  }
+}

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,7 +1,8 @@
 import { Body, type InBlock, L2Block, L2BlockHash, type TxEffect, type TxHash, TxReceipt } from '@aztec/circuit-types';
 import { AppendOnlyTreeSnapshot, type AztecAddress, BlockHeader, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
+import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap, type AztecSingleton, type Range } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton, Range } from '@aztec/kv-store';
 
 import { type L1Published, type L1PublishedData } from '../structs/published.js';
 
@@ -18,29 +19,29 @@ type BlockStorage = {
  */
 export class BlockStore {
   /** Map block number to block data */
-  #blocks: AztecMap<number, BlockStorage>;
+  #blocks: AztecAsyncMap<number, BlockStorage>;
 
   /** Map block hash to block body */
-  #blockBodies: AztecMap<string, Buffer>;
+  #blockBodies: AztecAsyncMap<string, Buffer>;
 
   /** Stores L1 block number in which the last processed L2 block was included */
-  #lastSynchedL1Block: AztecSingleton<bigint>;
+  #lastSynchedL1Block: AztecAsyncSingleton<bigint>;
 
   /** Stores l2 block number of the last proven block */
-  #lastProvenL2Block: AztecSingleton<number>;
+  #lastProvenL2Block: AztecAsyncSingleton<number>;
 
   /** Stores l2 epoch number of the last proven epoch */
-  #lastProvenL2Epoch: AztecSingleton<number>;
+  #lastProvenL2Epoch: AztecAsyncSingleton<number>;
 
   /** Index mapping transaction hash (as a string) to its location in a block */
-  #txIndex: AztecMap<string, BlockIndexValue>;
+  #txIndex: AztecAsyncMap<string, BlockIndexValue>;
 
   /** Index mapping a contract's address (as a string) to its location in a block */
-  #contractIndex: AztecMap<string, BlockIndexValue>;
+  #contractIndex: AztecAsyncMap<string, BlockIndexValue>;
 
   #log = createLogger('archiver:block_store');
 
-  constructor(private db: AztecKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#blocks = db.openMap('archiver_blocks');
     this.#blockBodies = db.openMap('archiver_block_bodies');
     this.#txIndex = db.openMap('archiver_tx_index');
@@ -55,28 +56,28 @@ export class BlockStore {
    * @param blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
     if (blocks.length === 0) {
-      return Promise.resolve(true);
+      return true;
     }
 
-    return this.db.transaction(() => {
+    return await this.db.transactionAsync(async () => {
       for (const block of blocks) {
-        void this.#blocks.set(block.data.number, {
+        await this.#blocks.set(block.data.number, {
           header: block.data.header.toBuffer(),
           archive: block.data.archive.toBuffer(),
           l1: block.l1,
         });
 
-        block.data.body.txEffects.forEach((tx, i) => {
-          void this.#txIndex.set(tx.txHash.toString(), [block.data.number, i]);
-        });
+        for (let i = 0; i < block.data.body.txEffects.length; i++) {
+          const txEffect = block.data.body.txEffects[i];
+          await this.#txIndex.set(txEffect.txHash.toString(), [block.data.number, i]);
+        }
 
-        void this.#blockBodies.set(block.data.hash().toString(), block.data.body.toBuffer());
+        await this.#blockBodies.set((await block.data.hash()).toString(), block.data.body.toBuffer());
       }
 
-      void this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
-
+      await this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
       return true;
     });
   }
@@ -88,26 +89,24 @@ export class BlockStore {
    * @param blocksToUnwind - The number of blocks we are to unwind
    * @returns True if the operation is successful
    */
-  unwindBlocks(from: number, blocksToUnwind: number) {
-    return this.db.transaction(() => {
-      const last = this.getSynchedL2BlockNumber();
-      if (from != last) {
+  async unwindBlocks(from: number, blocksToUnwind: number) {
+    return await this.db.transactionAsync(async () => {
+      const last = await this.getSynchedL2BlockNumber();
+      if (from !== last) {
         throw new Error(`Can only unwind blocks from the tip (requested ${from} but current tip is ${last})`);
       }
 
       for (let i = 0; i < blocksToUnwind; i++) {
         const blockNumber = from - i;
-        const block = this.getBlock(blockNumber);
+        const block = await this.getBlock(blockNumber);
 
         if (block === undefined) {
           throw new Error(`Cannot remove block ${blockNumber} from the store, we don't have it`);
         }
-        void this.#blocks.delete(block.data.number);
-        block.data.body.txEffects.forEach(tx => {
-          void this.#txIndex.delete(tx.txHash.toString());
-        });
-        const blockHash = block.data.hash().toString();
-        void this.#blockBodies.delete(blockHash);
+        await this.#blocks.delete(block.data.number);
+        await Promise.all(block.data.body.txEffects.map(tx => this.#txIndex.delete(tx.txHash.toString())));
+        const blockHash = (await block.data.hash()).toString();
+        await this.#blockBodies.delete(blockHash);
         this.#log.debug(`Unwound block ${blockNumber} ${blockHash}`);
       }
 
@@ -121,9 +120,10 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  *getBlocks(start: number, limit: number): IterableIterator<L1Published<L2Block>> {
-    for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
-      yield this.getBlockFromBlockStorage(blockStorage);
+  async *getBlocks(start: number, limit: number): AsyncIterableIterator<L1Published<L2Block>> {
+    for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
+      const block = await this.getBlockFromBlockStorage(blockStorage);
+      yield block;
     }
   }
 
@@ -132,10 +132,10 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  getBlock(blockNumber: number): L1Published<L2Block> | undefined {
-    const blockStorage = this.#blocks.get(blockNumber);
+  async getBlock(blockNumber: number): Promise<L1Published<L2Block> | undefined> {
+    const blockStorage = await this.#blocks.getAsync(blockNumber);
     if (!blockStorage || !blockStorage.header) {
-      return undefined;
+      return Promise.resolve(undefined);
     }
 
     return this.getBlockFromBlockStorage(blockStorage);
@@ -147,17 +147,17 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 block headers
    */
-  *getBlockHeaders(start: number, limit: number): IterableIterator<BlockHeader> {
-    for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
+  async *getBlockHeaders(start: number, limit: number): AsyncIterableIterator<BlockHeader> {
+    for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
       yield BlockHeader.fromBuffer(blockStorage.header);
     }
   }
 
-  private getBlockFromBlockStorage(blockStorage: BlockStorage) {
+  private async getBlockFromBlockStorage(blockStorage: BlockStorage) {
     const header = BlockHeader.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
-    const blockHash = header.hash().toString();
-    const blockBodyBuffer = this.#blockBodies.get(blockHash);
+    const blockHash = (await header.hash()).toString();
+    const blockBodyBuffer = await this.#blockBodies.getAsync(blockHash);
     if (blockBodyBuffer === undefined) {
       throw new Error(
         `Could not retrieve body for block ${header.globalVariables.blockNumber.toNumber()} ${blockHash}`,
@@ -174,13 +174,13 @@ export class BlockStore {
    * @param txHash - The txHash of the tx corresponding to the tx effect.
    * @returns The requested tx effect (or undefined if not found).
    */
-  getTxEffect(txHash: TxHash): InBlock<TxEffect> | undefined {
-    const [blockNumber, txIndex] = this.getTxLocation(txHash) ?? [];
+  async getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined> {
+    const [blockNumber, txIndex] = (await this.getTxLocation(txHash)) ?? [];
     if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
       return undefined;
     }
 
-    const block = this.getBlock(blockNumber);
+    const block = await this.getBlock(blockNumber);
     if (!block) {
       return undefined;
     }
@@ -188,7 +188,7 @@ export class BlockStore {
     return {
       data: block.data.body.txEffects[txIndex],
       l2BlockNumber: block.data.number,
-      l2BlockHash: block.data.hash().toString(),
+      l2BlockHash: (await block.data.hash()).toString(),
     };
   }
 
@@ -197,13 +197,13 @@ export class BlockStore {
    * @param txHash - The hash of a tx we try to get the receipt for.
    * @returns The requested tx receipt (or undefined if not found).
    */
-  getSettledTxReceipt(txHash: TxHash): TxReceipt | undefined {
-    const [blockNumber, txIndex] = this.getTxLocation(txHash) ?? [];
+  async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+    const [blockNumber, txIndex] = (await this.getTxLocation(txHash)) ?? [];
     if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
       return undefined;
     }
 
-    const block = this.getBlock(blockNumber)!;
+    const block = (await this.getBlock(blockNumber))!;
     const tx = block.data.body.txEffects[txIndex];
 
     return new TxReceipt(
@@ -211,7 +211,7 @@ export class BlockStore {
       TxReceipt.statusFromRevertCode(tx.revertCode),
       '',
       tx.transactionFee.toBigInt(),
-      L2BlockHash.fromField(block.data.hash()),
+      L2BlockHash.fromField(await block.data.hash()),
       block.data.number,
     );
   }
@@ -221,8 +221,8 @@ export class BlockStore {
    * @param txHash - The txHash of the tx.
    * @returns The block number and index of the tx.
    */
-  getTxLocation(txHash: TxHash): [blockNumber: number, txIndex: number] | undefined {
-    return this.#txIndex.get(txHash.toString());
+  getTxLocation(txHash: TxHash): Promise<[blockNumber: number, txIndex: number] | undefined> {
+    return this.#txIndex.getAsync(txHash.toString());
   }
 
   /**
@@ -230,16 +230,16 @@ export class BlockStore {
    * @param contractAddress - The address of the contract to look up.
    * @returns The block number and index of the contract.
    */
-  getContractLocation(contractAddress: AztecAddress): [blockNumber: number, index: number] | undefined {
-    return this.#contractIndex.get(contractAddress.toString());
+  getContractLocation(contractAddress: AztecAddress): Promise<[blockNumber: number, index: number] | undefined> {
+    return this.#contractIndex.getAsync(contractAddress.toString());
   }
 
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
-  getSynchedL2BlockNumber(): number {
-    const [lastBlockNumber] = this.#blocks.keys({ reverse: true, limit: 1 });
+  async getSynchedL2BlockNumber(): Promise<number> {
+    const [lastBlockNumber] = await toArray(this.#blocks.keysAsync({ reverse: true, limit: 1 }));
     return typeof lastBlockNumber === 'number' ? lastBlockNumber : INITIAL_L2_BLOCK_NUM - 1;
   }
 
@@ -247,31 +247,31 @@ export class BlockStore {
    * Gets the most recent L1 block processed.
    * @returns The L1 block that published the latest L2 block
    */
-  getSynchedL1BlockNumber(): bigint | undefined {
-    return this.#lastSynchedL1Block.get();
+  getSynchedL1BlockNumber(): Promise<bigint | undefined> {
+    return this.#lastSynchedL1Block.getAsync();
   }
 
   setSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    void this.#lastSynchedL1Block.set(l1BlockNumber);
+    return this.#lastSynchedL1Block.set(l1BlockNumber);
   }
 
-  getProvenL2BlockNumber(): number {
-    return this.#lastProvenL2Block.get() ?? 0;
+  async getProvenL2BlockNumber(): Promise<number> {
+    return (await this.#lastProvenL2Block.getAsync()) ?? 0;
   }
 
   setProvenL2BlockNumber(blockNumber: number) {
-    void this.#lastProvenL2Block.set(blockNumber);
+    return this.#lastProvenL2Block.set(blockNumber);
   }
 
-  getProvenL2EpochNumber(): number | undefined {
-    return this.#lastProvenL2Epoch.get();
+  getProvenL2EpochNumber(): Promise<number | undefined> {
+    return this.#lastProvenL2Epoch.getAsync();
   }
 
   setProvenL2EpochNumber(epochNumber: number) {
-    void this.#lastProvenL2Epoch.set(epochNumber);
+    return this.#lastProvenL2Epoch.set(epochNumber);
   }
 
-  #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'end'>> {
+  #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'limit'>> {
     if (limit < 1) {
       throw new Error(`Invalid limit: ${limit}`);
     }
@@ -280,7 +280,6 @@ export class BlockStore {
       throw new Error(`Invalid start: ${start}`);
     }
 
-    const end = start + limit;
-    return { start, end };
+    return { start, limit };
   }
 }

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);
   }
 }