@aztec/pxe 0.71.0 → 0.73.0

package/src/database/kv_pxe_database.ts

@@ -10,7 +10,7 @@ import {
 } from '@aztec/circuits.js';
 import { type ContractArtifact, FunctionSelector, FunctionType } from '@aztec/foundation/abi';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr, type Point } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { type LogFn, createDebugOnlyLogger } from '@aztec/foundation/log';
 import {
@@ -135,14 +135,17 @@ export class KVPxeDatabase implements PxeDatabase {
   }
 
   public async addContractArtifact(id: Fr, contract: ContractArtifact): Promise<void> {
-    const privateSelectors = contract.functions
-      .filter(functionArtifact => functionArtifact.functionType === FunctionType.PRIVATE)
-      .map(privateFunctionArtifact =>
-        FunctionSelector.fromNameAndParameters(
-          privateFunctionArtifact.name,
-          privateFunctionArtifact.parameters,
+    const privateFunctions = contract.functions.filter(
+      functionArtifact => functionArtifact.functionType === FunctionType.PRIVATE,
+    );
+
+    const privateSelectors = await Promise.all(
+      privateFunctions.map(async privateFunctionArtifact =>
+        (
+          await FunctionSelector.fromNameAndParameters(privateFunctionArtifact.name, privateFunctionArtifact.parameters)
         ).toString(),
-      );
+      ),
+    );
 
     if (privateSelectors.length !== new Set(privateSelectors).size) {
       throw new Error('Repeated function selectors of private functions');
@@ -297,7 +300,7 @@ export class KVPxeDatabase implements PxeDatabase {
   }
 
   async getNotes(filter: NotesFilter): Promise<NoteDao[]> {
-    const publicKey: PublicKey | undefined = filter.owner ? filter.owner.toAddressPoint() : undefined;
+    const publicKey: PublicKey | undefined = filter.owner ? await filter.owner.toAddressPoint() : undefined;
 
     filter.status = filter.status ?? NoteStatus.ACTIVE;
 
@@ -311,7 +314,7 @@ export class KVPxeDatabase implements PxeDatabase {
 
     for (const scope of new Set(filter.scopes)) {
       const formattedScopeString = scope.toString();
-      if (!this.#scopes.hasAsync(formattedScopeString)) {
+      if (!(await this.#scopes.hasAsync(formattedScopeString))) {
         throw new Error('Trying to get incoming notes of an scope that is not in the PXE database');
       }
 
@@ -394,7 +397,7 @@ export class KVPxeDatabase implements PxeDatabase {
     return result;
   }
 
-  removeNullifiedNotes(nullifiers: InBlock<Fr>[], accountAddressPoint: PublicKey): Promise<NoteDao[]> {
+  removeNullifiedNotes(nullifiers: InBlock<Fr>[], accountAddressPoint: Point): Promise<NoteDao[]> {
     if (nullifiers.length === 0) {
       return Promise.resolve([]);
     }
@@ -537,7 +540,7 @@ export class KVPxeDatabase implements PxeDatabase {
     }
 
     const value = await this.#completeAddresses.atAsync(index);
-    return value ? CompleteAddress.fromBuffer(value) : undefined;
+    return value ? await CompleteAddress.fromBuffer(value) : undefined;
   }
 
   getCompleteAddress(account: AztecAddress): Promise<CompleteAddress | undefined> {
@@ -545,7 +548,9 @@ export class KVPxeDatabase implements PxeDatabase {
   }
 
   async getCompleteAddresses(): Promise<CompleteAddress[]> {
-    return (await toArray(this.#completeAddresses.valuesAsync())).map(v => CompleteAddress.fromBuffer(v));
+    return await Promise.all(
+      (await toArray(this.#completeAddresses.valuesAsync())).map(v => CompleteAddress.fromBuffer(v)),
+    );
   }
 
   async addSenderAddress(address: AztecAddress): Promise<boolean> {
@@ -563,7 +568,7 @@ export class KVPxeDatabase implements PxeDatabase {
   }
 
   async removeSenderAddress(address: AztecAddress): Promise<boolean> {
-    if (!this.#addressBook.hasAsync(address.toString())) {
+    if (!(await this.#addressBook.hasAsync(address.toString()))) {
       return false;
     }
 

package/src/database/note_dao.ts

@@ -6,14 +6,14 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { type NoteData } from '@aztec/simulator/client';
 
 /**
- * A Note Data Access Object, representing a note that was comitted to the note hash tree, holding all of the
+ * A Note Data Access Object, representing a note that was committed to the note hash tree, holding all of the
  * information required to use it during execution and manage its state.
  */
 export class NoteDao implements NoteData {
   constructor(
     // Note information
 
-    /** The serialized content of the note, as will be returned in the getNotes oracle. */
+    /** The packed content of the note, as will be returned in the getNotes oracle. */
     public note: Note,
     /** The address of the contract that created the note (i.e. the address used by the kernel during siloing). */
     public contractAddress: AztecAddress,
@@ -127,9 +127,9 @@ export class NoteDao implements NoteData {
     return noteSize + AztecAddress.SIZE_IN_BYTES + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + indexSize;
   }
 
-  static random({
+  static async random({
     note = Note.random(),
-    contractAddress = AztecAddress.random(),
+    contractAddress = undefined,
     storageSlot = Fr.random(),
     nonce = Fr.random(),
     noteHash = Fr.random(),
@@ -138,12 +138,12 @@ export class NoteDao implements NoteData {
     l2BlockNumber = Math.floor(Math.random() * 1000),
     l2BlockHash = Fr.random().toString(),
     index = Fr.random().toBigInt(),
-    addressPoint = Point.random(),
+    addressPoint = undefined,
     noteTypeId = NoteSelector.random(),
   }: Partial<NoteDao> = {}) {
     return new NoteDao(
       note,
-      contractAddress,
+      contractAddress ?? (await AztecAddress.random()),
       storageSlot,
       nonce,
       noteHash,
@@ -152,7 +152,7 @@ export class NoteDao implements NoteData {
       l2BlockNumber,
       l2BlockHash,
       index,
-      addressPoint,
+      addressPoint ?? (await Point.random()),
       noteTypeId,
     );
   }

package/src/database/outgoing_note_dao.ts

@@ -99,9 +99,9 @@ export class OutgoingNoteDao {
     return noteSize + AztecAddress.SIZE_IN_BYTES + Fr.SIZE_IN_BYTES * 2 + TxHash.SIZE + Point.SIZE_IN_BYTES;
   }
 
-  static random({
+  static async random({
     note = Note.random(),
-    contractAddress = AztecAddress.random(),
+    contractAddress = undefined,
     txHash = randomTxHash(),
     storageSlot = Fr.random(),
     noteTypeId = NoteSelector.random(),
@@ -110,11 +110,11 @@ export class OutgoingNoteDao {
     l2BlockHash = Fr.random().toString(),
     noteHash = Fr.random(),
     index = Fr.random().toBigInt(),
-    ovpkM = Point.random(),
+    ovpkM = undefined,
   }: Partial<OutgoingNoteDao> = {}) {
     return new OutgoingNoteDao(
       note,
-      contractAddress,
+      contractAddress ?? (await AztecAddress.random()),
       storageSlot,
       noteTypeId,
       txHash,
@@ -123,7 +123,7 @@ export class OutgoingNoteDao {
       nonce,
       noteHash,
       index,
-      ovpkM,
+      ovpkM ?? (await Point.random()),
     );
   }
 }

package/src/database/pxe_database_test_suite.ts

@@ -8,11 +8,14 @@ import {
 } from '@aztec/circuits.js';
 import { makeHeader } from '@aztec/circuits.js/testing';
 import { FunctionType } from '@aztec/foundation/abi';
+import { timesParallel } from '@aztec/foundation/collection';
 import { randomInt } from '@aztec/foundation/crypto';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { BenchmarkingContractArtifact } from '@aztec/noir-contracts.js/Benchmarking';
 import { TestContractArtifact } from '@aztec/noir-contracts.js/Test';
 
+import times from 'lodash.times';
+
 import { NoteDao } from './note_dao.js';
 import { type PxeDatabase } from './pxe_database.js';
 
@@ -80,53 +83,62 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       let storageSlots: Fr[];
       let notes: NoteDao[];
 
-      const filteringTests: [() => NotesFilter, () => NoteDao[]][] = [
-        [() => ({}), () => notes],
+      const filteringTests: [() => Promise<NotesFilter>, () => Promise<NoteDao[]>][] = [
+        [() => Promise.resolve({}), () => Promise.resolve(notes)],
 
         [
-          () => ({ contractAddress: contractAddresses[0] }),
-          () => notes.filter(note => note.contractAddress.equals(contractAddresses[0])),
+          () => Promise.resolve({ contractAddress: contractAddresses[0] }),
+          () => Promise.resolve(notes.filter(note => note.contractAddress.equals(contractAddresses[0]))),
         ],
-        [() => ({ contractAddress: AztecAddress.random() }), () => []],
+        [async () => ({ contractAddress: await AztecAddress.random() }), () => Promise.resolve([])],
 
         [
-          () => ({ storageSlot: storageSlots[0] }),
-          () => notes.filter(note => note.storageSlot.equals(storageSlots[0])),
+          () => Promise.resolve({ storageSlot: storageSlots[0] }),
+          () => Promise.resolve(notes.filter(note => note.storageSlot.equals(storageSlots[0]))),
         ],
-        [() => ({ storageSlot: Fr.random() }), () => []],
+        [() => Promise.resolve({ storageSlot: Fr.random() }), () => Promise.resolve([])],
 
-        [() => ({ txHash: notes[0].txHash }), () => [notes[0]]],
-        [() => ({ txHash: randomTxHash() }), () => []],
+        [() => Promise.resolve({ txHash: notes[0].txHash }), () => Promise.resolve([notes[0]])],
+        [() => Promise.resolve({ txHash: randomTxHash() }), () => Promise.resolve([])],
 
         [
-          () => ({ owner: owners[0].address }),
-          () => notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint())),
+          () => Promise.resolve({ owner: owners[0].address }),
+          async () => {
+            const ownerAddressPoint = await owners[0].address.toAddressPoint();
+            return notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
+          },
         ],
 
         [
-          () => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[0] }),
+          () => Promise.resolve({ contractAddress: contractAddresses[0], storageSlot: storageSlots[0] }),
           () =>
-            notes.filter(
-              note => note.contractAddress.equals(contractAddresses[0]) && note.storageSlot.equals(storageSlots[0]),
+            Promise.resolve(
+              notes.filter(
+                note => note.contractAddress.equals(contractAddresses[0]) && note.storageSlot.equals(storageSlots[0]),
+              ),
             ),
         ],
-        [() => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[1] }), () => []],
+        [
+          () => Promise.resolve({ contractAddress: contractAddresses[0], storageSlot: storageSlots[1] }),
+          () => Promise.resolve([]),
+        ],
       ];
 
       beforeEach(async () => {
-        owners = Array.from({ length: 2 }).map(() => CompleteAddress.random());
-        contractAddresses = Array.from({ length: 2 }).map(() => AztecAddress.random());
-        storageSlots = Array.from({ length: 2 }).map(() => Fr.random());
+        owners = await timesParallel(2, () => CompleteAddress.random());
+        contractAddresses = await timesParallel(2, () => AztecAddress.random());
+        storageSlots = times(2, () => Fr.random());
 
-        notes = Array.from({ length: 10 }).map((_, i) =>
-          NoteDao.random({
+        notes = await timesParallel(10, async i => {
+          const addressPoint = await owners[i % owners.length].address.toAddressPoint();
+          return NoteDao.random({
             contractAddress: contractAddresses[i % contractAddresses.length],
             storageSlot: storageSlots[i % storageSlots.length],
-            addressPoint: owners[i % owners.length].address.toAddressPoint(),
+            addressPoint,
             index: BigInt(i),
             l2BlockNumber: i,
-          }),
-        );
+          });
+        });
 
         for (const owner of owners) {
           await database.addCompleteAddress(owner);
@@ -135,9 +147,9 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
       it.each(filteringTests)('stores notes in bulk and retrieves notes', async (getFilter, getExpected) => {
         await database.addNotes(notes);
-        const returnedNotes = await database.getNotes(getFilter());
-
-        expect(returnedNotes.sort()).toEqual(getExpected().sort());
+        const returnedNotes = await database.getNotes(await getFilter());
+        const expected = await getExpected();
+        expect(returnedNotes.sort()).toEqual(expected.sort());
       });
 
       it.each(filteringTests)('stores notes one by one and retrieves notes', async (getFilter, getExpected) => {
@@ -145,9 +157,10 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
           await database.addNote(note);
         }
 
-        const returnedNotes = await database.getNotes(getFilter());
+        const returnedNotes = await database.getNotes(await getFilter());
 
-        expect(returnedNotes.sort()).toEqual(getExpected().sort());
+        const expected = await getExpected();
+        expect(returnedNotes.sort()).toEqual(expected.sort());
       });
 
       it.each(filteringTests)('retrieves nullified notes', async (getFilter, getExpected) => {
@@ -155,26 +168,25 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
         // Nullify all notes and use the same filter as other test cases
         for (const owner of owners) {
-          const notesToNullify = notes.filter(note => note.addressPoint.equals(owner.address.toAddressPoint()));
+          const ownerAddressPoint = await owner.address.toAddressPoint();
+          const notesToNullify = notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
           const nullifiers = notesToNullify.map(note => ({
             data: note.siloedNullifier,
             l2BlockNumber: note.l2BlockNumber,
             l2BlockHash: note.l2BlockHash,
           }));
-          await expect(database.removeNullifiedNotes(nullifiers, owner.address.toAddressPoint())).resolves.toEqual(
-            notesToNullify,
-          );
+          await expect(database.removeNullifiedNotes(nullifiers, ownerAddressPoint)).resolves.toEqual(notesToNullify);
         }
-
-        await expect(database.getNotes({ ...getFilter(), status: NoteStatus.ACTIVE_OR_NULLIFIED })).resolves.toEqual(
-          getExpected(),
-        );
+        const filter = await getFilter();
+        const returnedNotes = await database.getNotes({ ...filter, status: NoteStatus.ACTIVE_OR_NULLIFIED });
+        const expected = await getExpected();
+        expect(returnedNotes.sort()).toEqual(expected.sort());
       });
 
       it('skips nullified notes by default or when requesting active', async () => {
         await database.addNotes(notes);
-
-        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const ownerAddressPoint = await owners[0].address.toAddressPoint();
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
         const nullifiers = notesToNullify.map(note => ({
           data: note.siloedNullifier,
           l2BlockNumber: note.l2BlockNumber,
@@ -194,8 +206,9 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       it('handles note unnullification', async () => {
         await database.setHeader(makeHeader(randomInt(1000), 100, 0 /** slot number */));
         await database.addNotes(notes);
+        const ownerAddressPoint = await owners[0].address.toAddressPoint();
 
-        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
         const nullifiers = notesToNullify.map(note => ({
           data: note.siloedNullifier,
           l2BlockNumber: 99,
@@ -213,8 +226,9 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
       it('returns active and nullified notes when requesting either', async () => {
         await database.addNotes(notes);
+        const ownerAddressPoint = await owners[0].address.toAddressPoint();
 
-        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
         const nullifiers = notesToNullify.map(note => ({
           data: note.siloedNullifier,
           l2BlockNumber: note.l2BlockNumber,
@@ -275,7 +289,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
             scopes: [owners[1].address],
           }),
         ).resolves.toEqual([notes[0]]);
-
+        const ownerAddressPoint = await owners[0].address.toAddressPoint();
         await expect(
           database.removeNullifiedNotes(
             [
@@ -285,7 +299,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
                 l2BlockNumber: notes[0].l2BlockNumber,
               },
             ],
-            owners[0].address.toAddressPoint(),
+            ownerAddressPoint,
           ),
         ).resolves.toEqual([notes[0]]);
 
@@ -325,22 +339,22 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
     describe('addresses', () => {
       it('stores and retrieves addresses', async () => {
-        const address = CompleteAddress.random();
+        const address = await CompleteAddress.random();
         await expect(database.addCompleteAddress(address)).resolves.toBe(true);
         await expect(database.getCompleteAddress(address.address)).resolves.toEqual(address);
       });
 
       it('silently ignores an address it already knows about', async () => {
-        const address = CompleteAddress.random();
+        const address = await CompleteAddress.random();
         await expect(database.addCompleteAddress(address)).resolves.toBe(true);
         await expect(database.addCompleteAddress(address)).resolves.toBe(false);
       });
 
       it.skip('refuses to overwrite an address with a different public key', async () => {
-        const address = CompleteAddress.random();
-        const otherAddress = new CompleteAddress(
+        const address = await CompleteAddress.random();
+        const otherAddress = await CompleteAddress.create(
           address.address,
-          new PublicKeys(Point.random(), Point.random(), Point.random(), Point.random()),
+          new PublicKeys(await Point.random(), await Point.random(), await Point.random(), await Point.random()),
           address.partialAddress,
         );
 
@@ -349,7 +363,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('returns all addresses', async () => {
-        const addresses = Array.from({ length: 10 }).map(() => CompleteAddress.random());
+        const addresses = await timesParallel(10, () => CompleteAddress.random());
         for (const address of addresses) {
           await database.addCompleteAddress(address);
         }
@@ -359,7 +373,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('returns a single address', async () => {
-        const addresses = Array.from({ length: 10 }).map(() => CompleteAddress.random());
+        const addresses = await timesParallel(10, () => CompleteAddress.random());
         for (const address of addresses) {
           await database.addCompleteAddress(address);
         }
@@ -373,7 +387,8 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it("returns undefined if it doesn't have an address", async () => {
-        expect(await database.getCompleteAddress(CompleteAddress.random().address)).toBeUndefined();
+        const completeAddress = await CompleteAddress.random();
+        expect(await database.getCompleteAddress(completeAddress.address)).toBeUndefined();
       });
     });
 
@@ -399,8 +414,8 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('stores a contract instance', async () => {
-        const address = AztecAddress.random();
-        const instance = SerializableContractInstance.random().withAddress(address);
+        const address = await AztecAddress.random();
+        const instance = (await SerializableContractInstance.random()).withAddress(address);
         await database.addContractInstance(instance);
         await expect(database.getContractInstance(address)).resolves.toEqual(instance);
       });
@@ -409,9 +424,9 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
     describe('contract non-volatile database', () => {
       let contract: AztecAddress;
 
-      beforeEach(() => {
+      beforeEach(async () => {
         // Setup mock contract address
-        contract = AztecAddress.random();
+        contract = await AztecAddress.random();
       });
 
       it('stores and loads a single value', async () => {
@@ -445,7 +460,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('stores values for different contracts independently', async () => {
-        const anotherContract = AztecAddress.random();
+        const anotherContract = await AztecAddress.random();
         const slot = new Fr(1);
         const values1 = [new Fr(42)];
         const values2 = [new Fr(100)];

package/src/kernel_oracle/index.ts

@@ -37,7 +37,7 @@ export class KernelOracle implements ProvingDataOracle {
   public async getContractAddressPreimage(address: AztecAddress) {
     const instance = await this.contractDataOracle.getContractInstance(address);
     return {
-      saltedInitializationHash: computeSaltedInitializationHash(instance),
+      saltedInitializationHash: await computeSaltedInitializationHash(instance),
       ...instance,
     };
   }
@@ -51,9 +51,9 @@ export class KernelOracle implements ProvingDataOracle {
     return await this.contractDataOracle.getFunctionMembershipWitness(contractAddress, selector);
   }
 
-  public getVkMembershipWitness(vk: VerificationKeyAsFields) {
-    const leafIndex = getVKIndex(vk);
-    return Promise.resolve(new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
+  public async getVkMembershipWitness(vk: VerificationKeyAsFields) {
+    const leafIndex = await getVKIndex(vk);
+    return new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), await getVKSiblingPath(leafIndex));
   }
 
   async getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>> {

package/src/kernel_prover/kernel_prover.ts

@@ -214,7 +214,7 @@ export class KernelProver {
       if (firstIteration) {
         const proofInput = new PrivateKernelInitCircuitPrivateInputs(
           txRequest,
-          getVKTreeRoot(),
+          await getVKTreeRoot(),
           protocolContractTreeRoot,
           privateCallData,
           isPrivateOnlyTx,
@@ -339,8 +339,8 @@ export class KernelProver {
   private async createPrivateCallData({ publicInputs, vk: vkAsBuffer }: PrivateCallExecutionResult) {
     const { contractAddress, functionSelector } = publicInputs.callContext;
 
-    const vkAsFields = vkAsFieldsMegaHonk(vkAsBuffer);
-    const vk = new VerificationKeyAsFields(vkAsFields, hashVK(vkAsFields));
+    const vkAsFields = await vkAsFieldsMegaHonk(vkAsBuffer);
+    const vk = new VerificationKeyAsFields(vkAsFields, await hashVK(vkAsFields));
 
     const functionLeafMembershipWitness = await this.oracle.getFunctionMembershipWitness(
       contractAddress,
@@ -357,7 +357,7 @@ export class KernelProver {
     const acirHash = Fr.fromBuffer(Buffer.alloc(32, 0));
 
     const protocolContractSiblingPath = isProtocolContract(contractAddress)
-      ? getProtocolContractSiblingPath(contractAddress)
+      ? await getProtocolContractSiblingPath(contractAddress)
       : makeTuple(PROTOCOL_CONTRACT_TREE_HEIGHT, Fr.zero);
 
     return PrivateCallData.from({

package/src/pxe_http/pxe_http_server.ts

@@ -21,6 +21,7 @@ export function startPXEHttpServer(pxeService: PXE, port: string | number): http
   const rpcServer = createNamespacedSafeJsonRpcServer({ pxe: [pxeService, PXESchema] });
 
   const app = rpcServer.getApp();
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
   const httpServer = http.createServer(app.callback());
   httpServer.listen(port);
 

package/src/pxe_service/error_enriching.ts

@@ -32,12 +32,12 @@ export async function enrichSimulationError(err: SimulationError, db: PxeDatabas
       const contract = await db.getContract(parsedContractAddress);
       if (contract) {
         err.enrichWithContractName(parsedContractAddress, contract.name);
-        fnNames.forEach(fnName => {
+        for (const fnName of fnNames) {
           const functionArtifact = contract.functions.find(f => fnName === f.name);
           if (functionArtifact) {
             err.enrichWithFunctionName(
               parsedContractAddress,
-              FunctionSelector.fromNameAndParameters(functionArtifact),
+              await FunctionSelector.fromNameAndParameters(functionArtifact),
               functionArtifact.name,
             );
           } else {
@@ -45,7 +45,7 @@ export async function enrichSimulationError(err: SimulationError, db: PxeDatabas
               `Could not find function artifact in contract ${contract.name} for function '${fnName}' when enriching error callstack`,
             );
           }
-        });
+        }
       } else {
         logger.warn(
           `Could not find contract in database for address: ${parsedContractAddress} when enriching error callstack`,