@aztec/pxe 0.71.0 → 0.72.1

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/pxe_service/pxe_service.ts

@@ -5,7 +5,8 @@ import {
   type EventMetadataDefinition,
   type ExtendedNote,
   type FunctionCall,
-  type GetUnencryptedLogsResponse,
+  type GetContractClassLogsResponse,
+  type GetPublicLogsResponse,
   type InBlock,
   L1EventPayload,
   type L2Block,
@@ -234,7 +235,8 @@ export class PXEService implements PXE {
           `Artifact does not match expected class id (computed ${contractClassId} but instance refers to ${instance.contractClassId})`,
         );
       }
-      if (!computeContractAddressFromInstance(instance).equals(instance.address)) {
+      const computedAddress = await computeContractAddressFromInstance(instance);
+      if (!computedAddress.equals(instance.address)) {
         throw new Error('Added a contract in which the address does not match the contract instance.');
       }
 
@@ -278,13 +280,15 @@ export class PXEService implements PXE {
     const extendedNotes = noteDaos.map(async dao => {
       let owner = filter.owner;
       if (owner === undefined) {
-        const completeAddresses = (await this.db.getCompleteAddresses()).find(completeAddress =>
-          completeAddress.address.toAddressPoint().equals(dao.addressPoint),
-        );
-        if (completeAddresses === undefined) {
+        const completeAddresses = await this.db.getCompleteAddresses();
+        const completeAddressIndex = (
+          await Promise.all(completeAddresses.map(completeAddresses => completeAddresses.address.toAddressPoint()))
+        ).findIndex(addressPoint => addressPoint.equals(dao.addressPoint));
+        const completeAddress = completeAddresses[completeAddressIndex];
+        if (completeAddress === undefined) {
           throw new Error(`Cannot find complete address for addressPoint ${dao.addressPoint.toString()}`);
         }
-        owner = completeAddresses.address;
+        owner = completeAddress.address;
       }
       return new UniqueNote(
         dao.note,
@@ -357,7 +361,7 @@ export class PXEService implements PXE {
           l2BlockNumber,
           l2BlockHash,
           index,
-          owner.address.toAddressPoint(),
+          await owner.address.toAddressPoint(),
           note.noteTypeId,
         ),
         scope,
@@ -402,7 +406,7 @@ export class PXEService implements PXE {
           l2BlockNumber,
           l2BlockHash,
           index,
-          note.owner.toAddressPoint(),
+          await note.owner.toAddressPoint(),
           note.noteTypeId,
         ),
       );
@@ -608,12 +612,12 @@ export class PXEService implements PXE {
   }
 
   /**
-   * 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.
    */
-  public getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
-    return this.node.getUnencryptedLogs(filter);
+  public getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
+    return this.node.getPublicLogs(filter);
   }
 
   /**
@@ -621,7 +625,7 @@ export class PXEService implements PXE {
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  public getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+  public getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     return this.node.getContractClassLogs(filter);
   }
 
@@ -687,7 +691,7 @@ export class PXEService implements PXE {
   async #registerProtocolContracts() {
     const registered: Record<string, string> = {};
     for (const name of protocolContractNames) {
-      const { address, contractClass, instance, artifact } = getCanonicalProtocolContract(name);
+      const { address, contractClass, instance, artifact } = await getCanonicalProtocolContract(name);
       await this.db.addContractArtifact(contractClass.id, artifact);
       await this.db.addContractInstance(instance);
       registered[name] = address.toString();
@@ -833,7 +837,7 @@ export class PXEService implements PXE {
     return !!(await this.node.getNullifierMembershipWitness('latest', initNullifier));
   }
 
-  public async getEncryptedEvents<T>(
+  public async getPrivateEvents<T>(
     eventMetadataDef: EventMetadataDefinition,
     from: number,
     limit: number,
@@ -864,25 +868,29 @@ export class PXEService implements PXE {
 
           const preaddress = registeredAccount.getPreaddress();
 
-          secretKey = computeAddressSecret(preaddress, secretKey);
+          secretKey = await computeAddressSecret(preaddress, secretKey);
         }
 
         return secretKey;
       }),
     );
 
-    const visibleEvents = privateLogs.flatMap(log => {
-      for (const sk of vsks) {
-        // TODO: Verify that the first field of the log is the tag siloed with contract address.
-        // Or use tags to query logs, like we do with notes.
-        const decryptedEvent = L1EventPayload.decryptAsIncoming(log, sk);
-        if (decryptedEvent !== undefined) {
-          return [decryptedEvent];
-        }
-      }
+    const visibleEvents = (
+      await Promise.all(
+        privateLogs.map(async log => {
+          for (const sk of vsks) {
+            // TODO: Verify that the first field of the log is the tag siloed with contract address.
+            // Or use tags to query logs, like we do with notes.
+            const decryptedEvent = await L1EventPayload.decryptAsIncoming(log, sk);
+            if (decryptedEvent !== undefined) {
+              return [decryptedEvent];
+            }
+          }
 
-      return [];
-    });
+          return [];
+        }),
+      )
+    ).flat();
 
     const decodedEvents = visibleEvents
       .map(visibleEvent => {
@@ -892,11 +900,6 @@ export class PXEService implements PXE {
         if (!visibleEvent.eventTypeId.equals(eventMetadata.eventSelector)) {
           return undefined;
         }
-        if (visibleEvent.event.items.length !== eventMetadata.fieldNames.length) {
-          throw new Error(
-            'Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length',
-          );
-        }
 
         return eventMetadata.decode(visibleEvent);
       })
@@ -905,34 +908,32 @@ export class PXEService implements PXE {
     return decodedEvents;
   }
 
-  async getUnencryptedEvents<T>(eventMetadataDef: EventMetadataDefinition, from: number, limit: number): Promise<T[]> {
+  async getPublicEvents<T>(eventMetadataDef: EventMetadataDefinition, from: number, limit: number): Promise<T[]> {
     const eventMetadata = new EventMetadata<T>(eventMetadataDef);
-    const { logs: unencryptedLogs } = await this.node.getUnencryptedLogs({
+    const { logs } = await this.node.getPublicLogs({
       fromBlock: from,
       toBlock: from + limit,
     });
 
-    const decodedEvents = unencryptedLogs
-      .map(unencryptedLog => {
-        const unencryptedLogBuf = unencryptedLog.log.data;
+    const decodedEvents = logs
+      .map(log => {
+        // +1 for the event selector
+        const expectedLength = eventMetadata.fieldNames.length + 1;
+        const logFields = log.log.log.slice(0, expectedLength);
         // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
-        if (
-          !EventSelector.fromBuffer(unencryptedLogBuf.subarray(unencryptedLogBuf.byteLength - 4)).equals(
-            eventMetadata.eventSelector,
-          )
-        ) {
+        if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadata.eventSelector)) {
           return undefined;
         }
-
-        if (unencryptedLogBuf.byteLength !== eventMetadata.fieldNames.length * 32 + 32) {
+        // If any of the remaining fields, are non-zero, the payload does match expected:
+        if (log.log.log.slice(expectedLength + 1).find(f => !f.isZero())) {
           throw new Error(
             'Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length',
           );
         }
 
-        return eventMetadata.decode(unencryptedLog.log);
+        return eventMetadata.decode(log.log);
       })
-      .filter(unencryptedLog => unencryptedLog !== undefined) as T[];
+      .filter(log => log !== undefined) as T[];
 
     return decodedEvents;
   }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -35,7 +35,7 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
     });
 
     it('successfully adds a contract', async () => {
-      const contracts = [randomDeployedContract(), randomDeployedContract()];
+      const contracts = await Promise.all([randomDeployedContract(), randomDeployedContract()]);
       for (const contract of contracts) {
         await pxe.registerContract(contract);
       }
@@ -49,7 +49,7 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       const artifact = randomContractArtifact();
       const contractClass = getContractClassFromArtifact(artifact);
       const contractClassId = contractClass.id;
-      const instance = randomContractInstanceWithAddress({ contractClassId });
+      const instance = await randomContractInstanceWithAddress({ contractClassId });
 
       await pxe.registerContractClass(artifact);
       expect(await pxe.getContractClass(contractClassId)).toMatchObject(
@@ -64,12 +64,12 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       const artifact = randomContractArtifact();
       const contractClass = getContractClassFromArtifact(artifact);
       const contractClassId = contractClass.id;
-      const instance = randomContractInstanceWithAddress({ contractClassId });
+      const instance = await randomContractInstanceWithAddress({ contractClassId });
       await expect(
         pxe.registerContract({
           instance: {
             ...instance,
-            address: AztecAddress.random(),
+            address: await AztecAddress.random(),
           },
           artifact,
         }),
@@ -77,13 +77,13 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
     });
 
     it('refuses to register a contract with a class that has not been registered', async () => {
-      const instance = randomContractInstanceWithAddress();
+      const instance = await randomContractInstanceWithAddress();
       await expect(pxe.registerContract({ instance })).rejects.toThrow(/Missing contract artifact/i);
     });
 
     it('refuses to register a contract with an artifact with mismatching class id', async () => {
       const artifact = randomContractArtifact();
-      const instance = randomContractInstanceWithAddress();
+      const instance = await randomContractInstanceWithAddress();
       await expect(pxe.registerContract({ instance, artifact })).rejects.toThrow(/Artifact does not match/i);
     });
 
@@ -91,13 +91,13 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
     //       a larger setup and it's sufficiently tested in the e2e tests.
 
     it('throws when getting public storage for non-existent contract', async () => {
-      const contract = AztecAddress.random();
+      const contract = await AztecAddress.random();
       await expect(async () => await pxe.getPublicStorageAt(contract, new Fr(0n))).rejects.toThrow(
         `Contract ${contract.toString()} is not deployed`,
       );
     });
 
-    // Note: Not testing `getContractData` and `getUnencryptedLogs` here as these
+    // Note: Not testing `getContractData` and `getPublicLogs` here as these
     //       functions only call AztecNode and these methods are frequently used by the e2e tests.
 
     it('successfully gets a block number', async () => {