@aztec/archiver 0.71.0 → 0.73.0

package/src/archiver/kv_archiver_store/nullifier_store.ts

@@ -1,46 +1,55 @@
 import { type InBlock, type L2Block } from '@aztec/circuit-types';
 import { type Fr, MAX_NULLIFIERS_PER_TX } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 
 export class NullifierStore {
-  #nullifiersToBlockNumber: AztecMap<string, number>;
-  #nullifiersToBlockHash: AztecMap<string, string>;
-  #nullifiersToIndex: AztecMap<string, number>;
+  #nullifiersToBlockNumber: AztecAsyncMap<string, number>;
+  #nullifiersToBlockHash: AztecAsyncMap<string, string>;
+  #nullifiersToIndex: AztecAsyncMap<string, number>;
   #log = createLogger('archiver:log_store');
 
-  constructor(private db: AztecKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#nullifiersToBlockNumber = db.openMap('archiver_nullifiers_to_block_number');
     this.#nullifiersToBlockHash = db.openMap('archiver_nullifiers_to_block_hash');
     this.#nullifiersToIndex = db.openMap('archiver_nullifiers_to_index');
   }
 
   async addNullifiers(blocks: L2Block[]): Promise<boolean> {
-    await this.db.transaction(() => {
-      blocks.forEach(block => {
-        const dataStartIndexForBlock =
-          block.header.state.partial.nullifierTree.nextAvailableLeafIndex -
-          block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
-        block.body.txEffects.forEach((txEffects, txIndex) => {
-          const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
-          txEffects.nullifiers.forEach((nullifier, nullifierIndex) => {
-            void this.#nullifiersToBlockNumber.set(nullifier.toString(), block.number);
-            void this.#nullifiersToBlockHash.set(nullifier.toString(), block.hash().toString());
-            void this.#nullifiersToIndex.set(nullifier.toString(), dataStartIndexForTx + nullifierIndex);
-          });
-        });
-      });
+    const blockHashes = await Promise.all(blocks.map(block => block.hash()));
+    await this.db.transactionAsync(async () => {
+      await Promise.all(
+        blocks.map((block, i) => {
+          const dataStartIndexForBlock =
+            block.header.state.partial.nullifierTree.nextAvailableLeafIndex -
+            block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
+          return Promise.all(
+            block.body.txEffects.map((txEffects, txIndex) => {
+              const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
+              return Promise.all(
+                txEffects.nullifiers.map(async (nullifier, nullifierIndex) => {
+                  await this.#nullifiersToBlockNumber.set(nullifier.toString(), block.number);
+                  await this.#nullifiersToBlockHash.set(nullifier.toString(), blockHashes[i].toString());
+                  await this.#nullifiersToIndex.set(nullifier.toString(), dataStartIndexForTx + nullifierIndex);
+                }),
+              );
+            }),
+          );
+        }),
+      );
     });
     return true;
   }
 
   async deleteNullifiers(blocks: L2Block[]): Promise<boolean> {
-    await this.db.transaction(() => {
+    await this.db.transactionAsync(async () => {
       for (const block of blocks) {
         for (const nullifier of block.body.txEffects.flatMap(tx => tx.nullifiers)) {
-          void this.#nullifiersToBlockNumber.delete(nullifier.toString());
-          void this.#nullifiersToBlockHash.delete(nullifier.toString());
-          void this.#nullifiersToIndex.delete(nullifier.toString());
+          await Promise.all([
+            this.#nullifiersToBlockNumber.delete(nullifier.toString()),
+            this.#nullifiersToBlockHash.delete(nullifier.toString()),
+            this.#nullifiersToIndex.delete(nullifier.toString()),
+          ]);
         }
       }
     });
@@ -51,13 +60,22 @@ export class NullifierStore {
     blockNumber: number,
     nullifiers: Fr[],
   ): Promise<(InBlock<bigint> | undefined)[]> {
-    const maybeNullifiers = await this.db.transaction(() => {
-      return nullifiers.map(nullifier => ({
-        data: this.#nullifiersToIndex.get(nullifier.toString()),
-        l2BlockNumber: this.#nullifiersToBlockNumber.get(nullifier.toString()),
-        l2BlockHash: this.#nullifiersToBlockHash.get(nullifier.toString()),
-      }));
-    });
+    const asStrings = nullifiers.map(x => x.toString());
+
+    const maybeNullifiers = await Promise.all(
+      asStrings.map(async nullifier => {
+        const [data, l2BlockNumber, l2BlockHash] = await Promise.all([
+          this.#nullifiersToIndex.getAsync(nullifier),
+          this.#nullifiersToBlockNumber.getAsync(nullifier),
+          this.#nullifiersToBlockHash.getAsync(nullifier),
+        ]);
+        return {
+          data,
+          l2BlockNumber,
+          l2BlockHash,
+        };
+      }),
+    );
     return maybeNullifiers.map(({ data, l2BlockNumber, l2BlockHash }) => {
       if (
         data === undefined ||

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,7 +1,9 @@
 import {
   type ContractClass2BlockL2Logs,
+  ExtendedPublicLog,
   ExtendedUnencryptedL2Log,
-  type GetUnencryptedLogsResponse,
+  type GetContractClassLogsResponse,
+  type GetPublicLogsResponse,
   type InBlock,
   type InboxLeaf,
   type L2Block,
@@ -12,7 +14,6 @@ import {
   type TxHash,
   TxReceipt,
   TxScopedL2Log,
-  type UnencryptedL2BlockL2Logs,
   wrapInBlock,
 } from '@aztec/circuit-types';
 import {
@@ -25,7 +26,9 @@ import {
   INITIAL_L2_BLOCK_NUM,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
+  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
   type PrivateLog,
+  type PublicLog,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
@@ -57,7 +60,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private privateLogsPerBlock: Map<number, PrivateLog[]> = new Map();
 
-  private unencryptedLogsPerBlock: Map<number, UnencryptedL2BlockL2Logs> = new Map();
+  private publicLogsPerBlock: Map<number, PublicLog[]> = new Map();
 
   private contractClassLogsPerBlock: Map<number, ContractClass2BlockL2Logs> = new Map();
 
@@ -89,7 +92,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   #log = createLogger('archiver:data-store');
 
   constructor(
-    /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
+    /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
     public readonly maxLogs: number,
   ) {}
 
@@ -188,14 +191,18 @@ export class MemoryArchiverStore 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.
    */
-  public addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  public async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
     if (blocks.length === 0) {
       return Promise.resolve(true);
     }
 
     this.lastL1BlockNewBlocks = blocks[blocks.length - 1].l1.blockNumber;
     this.l2Blocks.push(...blocks);
-    this.txEffects.push(...blocks.flatMap(b => b.data.body.txEffects.map(txEffect => wrapInBlock(txEffect, b.data))));
+    const flatTxEffects = blocks.flatMap(b => b.data.body.txEffects.map(txEffect => ({ block: b, txEffect })));
+    const wrappedTxEffects = await Promise.all(
+      flatTxEffects.map(flatTxEffect => wrapInBlock(flatTxEffect.txEffect, flatTxEffect.block.data)),
+    );
+    this.txEffects.push(...wrappedTxEffects);
 
     return Promise.resolve(true);
   }
@@ -249,43 +256,41 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     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 (
-          // TODO remove when #9835 and #9836 are fixed
-          log.data.length <
-          32 * 33
-        ) {
-          this.#log.warn(`Skipping unencrypted log with invalid data length: ${log.data.length}`);
+      txEffect.publicLogs.forEach(log => {
+        // Check that each log stores 3 lengths in its first field. If not, it's not a tagged log:
+        // 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.
+        const firstFieldBuf = log.log[0].toBuffer();
+        if (!firstFieldBuf.subarray(0, 27).equals(Buffer.alloc(27)) || 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]]
+          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.verbose(`Storing unencrypted tagged log with tag ${tag.toString()} in block ${block.number}`);
-          const currentLogs = this.taggedLogs.get(tag.toString()) || [];
-          this.taggedLogs.set(tag.toString(), [
-            ...currentLogs,
-            new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ true, log.data),
-          ]);
-          const currentTagsInBlock = this.logTagsPerBlock.get(block.number) || [];
-          this.logTagsPerBlock.set(block.number, [...currentTagsInBlock, tag]);
-        } catch (err) {
-          this.#log.warn(`Failed to add tagged log to store: ${err}`);
+        // 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 => tag is in fields[1]
+        const tag = log.log[1];
+        this.#log.verbose(`Storing public tagged log with tag ${tag.toString()} in block ${block.number}`);
+        const currentLogs = this.taggedLogs.get(tag.toString()) || [];
+        this.taggedLogs.set(tag.toString(), [
+          ...currentLogs,
+          new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ true, log.toBuffer()),
+        ]);
+        const currentTagsInBlock = this.logTagsPerBlock.get(block.number) || [];
+        this.logTagsPerBlock.set(block.number, [...currentTagsInBlock, tag]);
       });
     });
   }
@@ -297,10 +302,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   addLogs(blocks: L2Block[]): Promise<boolean> {
     blocks.forEach(block => {
-      void this.#storeTaggedLogsFromPrivate(block);
-      void this.#storeTaggedLogsFromPublic(block);
+      this.#storeTaggedLogsFromPrivate(block);
+      this.#storeTaggedLogsFromPublic(block);
       this.privateLogsPerBlock.set(block.number, block.body.txEffects.map(txEffect => txEffect.privateLogs).flat());
-      this.unencryptedLogsPerBlock.set(block.number, block.body.unencryptedLogs);
+      this.publicLogsPerBlock.set(block.number, block.body.txEffects.map(txEffect => txEffect.publicLogs).flat());
       this.contractClassLogsPerBlock.set(block.number, block.body.contractClassLogs);
     });
     return Promise.resolve(true);
@@ -316,7 +321,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
     blocks.forEach(block => {
       this.privateLogsPerBlock.delete(block.number);
-      this.unencryptedLogsPerBlock.delete(block.number);
+      this.publicLogsPerBlock.delete(block.number);
       this.logTagsPerBlock.delete(block.number);
       this.contractClassLogsPerBlock.delete(block.number);
     });
@@ -324,22 +329,25 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
-  addNullifiers(blocks: L2Block[]): Promise<boolean> {
-    blocks.forEach(block => {
-      const dataStartIndexForBlock =
-        block.header.state.partial.nullifierTree.nextAvailableLeafIndex -
-        block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
-      block.body.txEffects.forEach((txEffects, txIndex) => {
-        const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
-        txEffects.nullifiers.forEach((nullifier, nullifierIndex) => {
-          this.blockScopedNullifiers.set(nullifier.toString(), {
-            index: BigInt(dataStartIndexForTx + nullifierIndex),
-            blockNumber: block.number,
-            blockHash: block.hash().toString(),
+  async addNullifiers(blocks: L2Block[]): Promise<boolean> {
+    await Promise.all(
+      blocks.map(async block => {
+        const dataStartIndexForBlock =
+          block.header.state.partial.nullifierTree.nextAvailableLeafIndex -
+          block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
+        const blockHash = await block.hash();
+        block.body.txEffects.forEach((txEffects, txIndex) => {
+          const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
+          txEffects.nullifiers.forEach((nullifier, nullifierIndex) => {
+            this.blockScopedNullifiers.set(nullifier.toString(), {
+              index: BigInt(dataStartIndexForTx + nullifierIndex),
+              blockNumber: block.number,
+              blockHash: blockHash.toString(),
+            });
           });
         });
-      });
-    });
+      }),
+    );
     return Promise.resolve(true);
   }
 
@@ -447,24 +455,22 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @param txHash - The hash of a tx we try to get the receipt for.
    * @returns The requested tx receipt (or undefined if not found).
    */
-  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+  public async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
     for (const block of this.l2Blocks) {
       for (const txEffect of block.data.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
-          return Promise.resolve(
-            new TxReceipt(
-              txHash,
-              TxReceipt.statusFromRevertCode(txEffect.revertCode),
-              '',
-              txEffect.transactionFee.toBigInt(),
-              L2BlockHash.fromField(block.data.hash()),
-              block.data.number,
-            ),
+          return new TxReceipt(
+            txHash,
+            TxReceipt.statusFromRevertCode(txEffect.revertCode),
+            '',
+            txEffect.transactionFee.toBigInt(),
+            L2BlockHash.fromField(await block.data.hash()),
+            block.data.number,
           );
         }
       }
     }
-    return Promise.resolve(undefined);
+    return undefined;
   }
 
   /**
@@ -518,12 +524,12 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   /**
-   * 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.
    * @remarks Works by doing an intersection of all params in the filter.
    */
-  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
     let txHash: TxHash | undefined;
     let fromBlock = 0;
     let toBlock = this.l2Blocks.length + INITIAL_L2_BLOCK_NUM;
@@ -564,34 +570,34 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
     const contractAddress = filter.contractAddress;
 
-    const logs: ExtendedUnencryptedL2Log[] = [];
+    const logs: ExtendedPublicLog[] = [];
 
     for (; fromBlock < toBlock; fromBlock++) {
       const block = this.l2Blocks[fromBlock - INITIAL_L2_BLOCK_NUM];
-      const blockLogs = this.unencryptedLogsPerBlock.get(fromBlock);
+      const blockLogs = this.publicLogsPerBlock.get(fromBlock);
 
       if (blockLogs) {
-        for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
-          const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs();
-          for (; logIndexInTx < txLogs.length; logIndexInTx++) {
-            const log = txLogs[logIndexInTx];
-            if (
-              (!txHash || block.data.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
-              (!contractAddress || log.contractAddress.equals(contractAddress))
-            ) {
-              logs.push(new ExtendedUnencryptedL2Log(new LogId(block.data.number, txIndexInBlock, logIndexInTx), log));
-              if (logs.length === this.maxLogs) {
-                return Promise.resolve({
-                  logs,
-                  maxLogsHit: true,
-                });
-              }
+        for (let logIndex = 0; logIndex < blockLogs.length; logIndex++) {
+          const log = blockLogs[logIndex];
+          const thisTxEffect = block.data.body.txEffects.filter(effect => effect.publicLogs.includes(log))[0];
+          const thisTxIndexInBlock = block.data.body.txEffects.indexOf(thisTxEffect);
+          const thisLogIndexInTx = thisTxEffect.publicLogs.indexOf(log);
+          if (
+            (!txHash || thisTxEffect.txHash.equals(txHash)) &&
+            (!contractAddress || log.contractAddress.equals(contractAddress)) &&
+            thisTxIndexInBlock >= txIndexInBlock &&
+            thisLogIndexInTx >= logIndexInTx
+          ) {
+            logs.push(new ExtendedPublicLog(new LogId(block.data.number, thisTxIndexInBlock, thisLogIndexInTx), log));
+            if (logs.length === this.maxLogs) {
+              return Promise.resolve({
+                logs,
+                maxLogsHit: true,
+              });
             }
           }
-          logIndexInTx = 0;
         }
       }
-      txIndexInBlock = 0;
     }
 
     return Promise.resolve({
@@ -607,7 +613,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @returns The requested logs.
    * @remarks Works by doing an intersection of all params in the filter.
    */
-  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     let txHash: TxHash | undefined;
     let fromBlock = 0;
     let toBlock = this.l2Blocks.length + INITIAL_L2_BLOCK_NUM;
@@ -734,20 +740,18 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.functionNames.get(selector.toString()));
   }
 
-  public registerContractFunctionSignatures(_address: AztecAddress, signatures: string[]): Promise<void> {
+  public 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();
   }
 
-  public estimateSize(): { mappingSize: number; actualSize: number; numItems: number } {
-    return { mappingSize: 0, actualSize: 0, numItems: 0 };
+  public estimateSize(): Promise<{ mappingSize: number; actualSize: number; numItems: number }> {
+    return Promise.resolve({ mappingSize: 0, actualSize: 0, numItems: 0 });
   }
 }

package/src/factory.ts

@@ -9,7 +9,7 @@ import { FunctionType, decodeFunctionSignature } from '@aztec/foundation/abi';
 import { createLogger } from '@aztec/foundation/log';
 import { type Maybe } from '@aztec/foundation/types';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
-import { createStore } from '@aztec/kv-store/lmdb';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContractArtifact } from '@aztec/noir-contracts.js/TokenBridge';
 import { protocolContractNames } from '@aztec/protocol-contracts';
@@ -41,7 +41,7 @@ export async function createArchiver(
 async function registerProtocolContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
-    const contract = getCanonicalProtocolContract(name);
+    const contract = await getCanonicalProtocolContract(name);
     const contractClassPublic: ContractClassPublic = {
       ...contract.contractClass,
       privateFunctions: [],
@@ -53,7 +53,7 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
       .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
 
     await store.registerContractFunctionSignatures(contract.address, publicFunctionSignatures);
-    const bytecodeCommitment = computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
+    const bytecodeCommitment = await computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
     await store.addContractClasses([contractClassPublic], [bytecodeCommitment], blockNumber);
     await store.addContractInstances([contract.instance], blockNumber);
   }
@@ -67,11 +67,13 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
 async function registerCommonContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   const artifacts = [TokenBridgeContractArtifact, TokenContractArtifact];
-  const classes = artifacts.map(artifact => ({
-    ...getContractClassFromArtifact(artifact),
-    privateFunctions: [],
-    unconstrainedFunctions: [],
-  }));
-  const bytecodeCommitments = classes.map(x => computePublicBytecodeCommitment(x.packedBytecode));
+  const classes = await Promise.all(
+    artifacts.map(async artifact => ({
+      ...(await getContractClassFromArtifact(artifact)),
+      privateFunctions: [],
+      unconstrainedFunctions: [],
+    })),
+  );
+  const bytecodeCommitments = await Promise.all(classes.map(x => computePublicBytecodeCommitment(x.packedBytecode)));
   await store.addContractClasses(classes, bytecodeCommitments, blockNumber);
 }

package/src/rpc/index.ts

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

package/src/test/mock_archiver.ts

@@ -51,5 +51,6 @@ export class MockPrefilledArchiver extends MockArchiver {
 
     const fromBlock = this.l2Blocks.length;
     this.addBlocks(this.precomputed.slice(fromBlock, fromBlock + numBlocks));
+    return Promise.resolve();
   }
 }

package/src/test/mock_l2_block_source.ts

@@ -24,10 +24,10 @@ export class MockL2BlockSource implements L2BlockSource {
 
   private log = createLogger('archiver:mock_l2_block_source');
 
-  public createBlocks(numBlocks: number) {
+  public async createBlocks(numBlocks: number) {
     for (let i = 0; i < numBlocks; i++) {
       const blockNum = this.l2Blocks.length + 1;
-      const block = L2Block.random(blockNum);
+      const block = await L2Block.random(blockNum);
       this.l2Blocks.push(block);
     }
 
@@ -126,7 +126,7 @@ export class MockL2BlockSource implements L2BlockSource {
    * @param txHash - The hash of a transaction which resulted in the returned tx effect.
    * @returns The requested tx effect.
    */
-  public getTxEffect(txHash: TxHash) {
+  public async getTxEffect(txHash: TxHash) {
     const match = this.l2Blocks
       .flatMap(b => b.body.txEffects.map(tx => [tx, b] as const))
       .find(([tx]) => tx.txHash.equals(txHash));
@@ -134,7 +134,7 @@ export class MockL2BlockSource implements L2BlockSource {
       return Promise.resolve(undefined);
     }
     const [txEffect, block] = match;
-    return Promise.resolve({ data: txEffect, l2BlockNumber: block.number, l2BlockHash: block.hash().toString() });
+    return { data: txEffect, l2BlockNumber: block.number, l2BlockHash: (await block.hash()).toString() };
   }
 
   /**
@@ -142,24 +142,22 @@ export class MockL2BlockSource implements L2BlockSource {
    * @param txHash - The hash of a tx we try to get the receipt for.
    * @returns The requested tx receipt (or undefined if not found).
    */
-  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+  public async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
     for (const block of this.l2Blocks) {
       for (const txEffect of block.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
-          return Promise.resolve(
-            new TxReceipt(
-              txHash,
-              TxStatus.SUCCESS,
-              '',
-              txEffect.transactionFee.toBigInt(),
-              L2BlockHash.fromField(block.hash()),
-              block.number,
-            ),
+          return new TxReceipt(
+            txHash,
+            TxStatus.SUCCESS,
+            '',
+            txEffect.transactionFee.toBigInt(),
+            L2BlockHash.fromField(await block.hash()),
+            block.number,
           );
         }
       }
     }
-    return Promise.resolve(undefined);
+    return undefined;
   }
 
   async getL2Tips(): Promise<L2Tips> {
@@ -169,10 +167,14 @@ export class MockL2BlockSource implements L2BlockSource {
       await this.getProvenBlockNumber(),
     ] as const;
 
+    const latestBlock = this.l2Blocks[latest - 1];
+    const provenBlock = this.l2Blocks[proven - 1];
+    const finalizedBlock = this.l2Blocks[finalized - 1];
+
     return {
-      latest: { number: latest, hash: this.l2Blocks[latest - 1]?.hash().toString() },
-      proven: { number: proven, hash: this.l2Blocks[proven - 1]?.hash().toString() },
-      finalized: { number: finalized, hash: this.l2Blocks[finalized - 1]?.hash().toString() },
+      latest: { number: latest, hash: (await latestBlock?.hash())?.toString() },
+      proven: { number: proven, hash: (await provenBlock?.hash())?.toString() },
+      finalized: { number: finalized, hash: (await finalizedBlock?.hash())?.toString() },
     };
   }