@aztec/pxe 0.61.0 → 0.63.0

package/src/pxe_service/pxe_service.ts

@@ -1,8 +1,8 @@
 import {
   type AuthWitness,
   type AztecNode,
-  type EventMetadata,
-  EventType,
+  EventMetadata,
+  type EventMetadataDefinition,
   type ExtendedNote,
   type FunctionCall,
   type GetUnencryptedLogsResponse,
@@ -31,7 +31,6 @@ import {
   UniqueNote,
   getNonNullifiedL1ToL2MessageWitness,
 } from '@aztec/circuit-types';
-import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
 import {
   type AztecAddress,
   type CompleteAddress,
@@ -44,6 +43,7 @@ import {
   computeAddressSecret,
   computeContractAddressFromInstance,
   computeContractClassId,
+  computePoint,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
@@ -89,8 +89,6 @@ export class PXEService implements PXE {
   // ensures that state is not changed while simulating
   private jobQueue = new SerialQueue();
 
-  private fakeProofCreator = new TestPrivateKernelProver();
-
   constructor(
     private keyStore: KeyStore,
     private node: AztecNode,
@@ -116,34 +114,11 @@ export class PXEService implements PXE {
   public async start() {
     const { l2BlockPollingIntervalMS } = this.config;
     await this.synchronizer.start(1, l2BlockPollingIntervalMS);
-    await this.restoreNoteProcessors();
     await this.#registerProtocolContracts();
     const info = await this.getNodeInfo();
     this.log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
   }
 
-  private async restoreNoteProcessors() {
-    const accounts = await this.keyStore.getAccounts();
-    const publicKeys = accounts.map(async account => await this.keyStore.getMasterIncomingViewingPublicKey(account));
-    const publicKeysSet = new Set(publicKeys.map(k => k.toString()));
-
-    const registeredAddresses = await this.db.getCompleteAddresses();
-
-    let count = 0;
-    for (const address of registeredAddresses) {
-      if (!publicKeysSet.has(address.publicKeys.masterIncomingViewingPublicKey.toString())) {
-        continue;
-      }
-
-      count++;
-      this.synchronizer.addAccount(address, this.keyStore, this.config.l2StartingBlock);
-    }
-
-    if (count > 0) {
-      this.log.info(`Restored ${count} accounts`);
-    }
-  }
-
   /**
    * Stops the PXE Service, halting processing of new transactions and shutting down the synchronizer.
    * This function ensures that all ongoing tasks are completed before stopping the server.
@@ -195,7 +170,6 @@ export class PXEService implements PXE {
       this.log.info(`Account:\n "${accountCompleteAddress.address.toString()}"\n already registered.`);
       return accountCompleteAddress;
     } else {
-      this.synchronizer.addAccount(accountCompleteAddress, this.keyStore, this.config.l2StartingBlock);
       this.log.info(`Registered account ${accountCompleteAddress.address.toString()}`);
       this.log.debug(`Registered account\n ${accountCompleteAddress.toReadableString()}`);
     }
@@ -204,47 +178,56 @@ export class PXEService implements PXE {
     return accountCompleteAddress;
   }
 
-  public async getRegisteredAccounts(): Promise<CompleteAddress[]> {
-    // Get complete addresses of both the recipients and the accounts
-    const completeAddresses = await this.db.getCompleteAddresses();
-    // Filter out the addresses not corresponding to accounts
+  public async registerContact(address: AztecAddress): Promise<AztecAddress> {
     const accounts = await this.keyStore.getAccounts();
-    return completeAddresses.filter(completeAddress =>
-      accounts.find(address => address.equals(completeAddress.address)),
-    );
+    if (accounts.includes(address)) {
+      this.log.info(`Account:\n "${address.toString()}"\n already registered.`);
+      return address;
+    }
+
+    const wasAdded = await this.db.addContactAddress(address);
+
+    if (wasAdded) {
+      this.log.info(`Added contact:\n ${address.toString()}`);
+    } else {
+      this.log.info(`Contact:\n "${address.toString()}"\n already registered.`);
+    }
+
+    return address;
   }
 
-  public async getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    const result = await this.getRegisteredAccounts();
-    const account = result.find(r => r.address.equals(address));
-    return Promise.resolve(account);
+  public getContacts(): Promise<AztecAddress[]> {
+    const contacts = this.db.getContactAddresses();
+
+    return Promise.resolve(contacts);
   }
 
-  public async registerRecipient(recipient: CompleteAddress): Promise<void> {
-    const wasAdded = await this.db.addCompleteAddress(recipient);
+  public async removeContact(address: AztecAddress): Promise<void> {
+    const wasRemoved = await this.db.removeContactAddress(address);
 
-    if (wasAdded) {
-      this.log.info(`Added recipient:\n ${recipient.toReadableString()}`);
+    if (wasRemoved) {
+      this.log.info(`Removed contact:\n ${address.toString()}`);
     } else {
-      this.log.info(`Recipient:\n "${recipient.toReadableString()}"\n already registered.`);
+      this.log.info(`Contact:\n "${address.toString()}"\n not in address book.`);
     }
+
+    return Promise.resolve();
   }
 
-  public async getRecipients(): Promise<CompleteAddress[]> {
+  public async getRegisteredAccounts(): Promise<CompleteAddress[]> {
     // Get complete addresses of both the recipients and the accounts
     const completeAddresses = await this.db.getCompleteAddresses();
-    // Filter out the addresses corresponding to accounts
+    // Filter out the addresses not corresponding to accounts
     const accounts = await this.keyStore.getAccounts();
-    const recipients = completeAddresses.filter(
-      completeAddress => !accounts.find(account => account.equals(completeAddress.address)),
+    return completeAddresses.filter(completeAddress =>
+      accounts.find(address => address.equals(completeAddress.address)),
     );
-    return recipients;
   }
 
-  public async getRecipient(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    const result = await this.getRecipients();
-    const recipient = result.find(r => r.address.equals(address));
-    return Promise.resolve(recipient);
+  public async getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
+    const result = await this.getRegisteredAccounts();
+    const account = result.find(r => r.address.equals(address));
+    return Promise.resolve(account);
   }
 
   public async registerContractClass(artifact: ContractArtifact): Promise<void> {
@@ -286,7 +269,6 @@ export class PXEService implements PXE {
 
     this.log.info(`Added contract ${artifact.name} at ${instance.address.toString()}`);
     await this.db.addContractInstance(instance);
-    await this.synchronizer.reprocessDeferredNotesForContract(instance.address);
   }
 
   public getContracts(): Promise<AztecAddress[]> {
@@ -306,11 +288,11 @@ 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(address =>
-          address.publicKeys.masterIncomingViewingPublicKey.equals(dao.ivpkM),
+        const completeAddresses = (await this.db.getCompleteAddresses()).find(completeAddress =>
+          computePoint(completeAddress.address).equals(dao.addressPoint),
         );
         if (completeAddresses === undefined) {
-          throw new Error(`Cannot find complete address for IvpkM ${dao.ivpkM.toString()}`);
+          throw new Error(`Cannot find complete address for addressPoint ${dao.addressPoint.toString()}`);
         }
         owner = completeAddresses.address;
       }
@@ -383,13 +365,15 @@ export class PXEService implements PXE {
         note.note,
       );
 
-      const index = await this.node.findLeafIndex('latest', MerkleTreeId.NOTE_HASH_TREE, siloedNoteHash);
+      const [index] = await this.node.findLeavesIndexes('latest', MerkleTreeId.NOTE_HASH_TREE, [siloedNoteHash]);
       if (index === undefined) {
         throw new Error('Note does not exist.');
       }
 
       const siloedNullifier = siloNullifier(note.contractAddress, innerNullifier!);
-      const nullifierIndex = await this.node.findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, siloedNullifier);
+      const [nullifierIndex] = await this.node.findLeavesIndexes('latest', MerkleTreeId.NULLIFIER_TREE, [
+        siloedNullifier,
+      ]);
       if (nullifierIndex !== undefined) {
         throw new Error('The note has been destroyed.');
       }
@@ -405,7 +389,7 @@ export class PXEService implements PXE {
           noteHash,
           siloedNullifier,
           index,
-          owner.publicKeys.masterIncomingViewingPublicKey,
+          computePoint(owner.address),
         ),
         scope,
       );
@@ -413,11 +397,6 @@ export class PXEService implements PXE {
   }
 
   public async addNullifiedNote(note: ExtendedNote) {
-    const owner = await this.db.getCompleteAddress(note.owner);
-    if (!owner) {
-      throw new Error(`Unknown account: ${note.owner.toString()}`);
-    }
-
     const nonces = await this.#getNoteNonces(note);
     if (nonces.length === 0) {
       throw new Error(`Cannot find the note in tx: ${note.txHash}.`);
@@ -437,7 +416,7 @@ export class PXEService implements PXE {
         throw new Error('Unexpectedly received non-zero nullifier.');
       }
 
-      const index = await this.node.findLeafIndex('latest', MerkleTreeId.NOTE_HASH_TREE, siloedNoteHash);
+      const [index] = await this.node.findLeavesIndexes('latest', MerkleTreeId.NOTE_HASH_TREE, [siloedNoteHash]);
       if (index === undefined) {
         throw new Error('Note does not exist.');
       }
@@ -453,7 +432,7 @@ export class PXEService implements PXE {
           noteHash,
           Fr.ZERO, // We are not able to derive
           index,
-          owner.publicKeys.masterIncomingViewingPublicKey,
+          computePoint(note.owner),
         ),
       );
     }
@@ -529,11 +508,24 @@ export class PXEService implements PXE {
     simulatePublic: boolean,
     msgSender: AztecAddress | undefined = undefined,
     skipTxValidation: boolean = false,
+    profile: boolean = false,
     scopes?: AztecAddress[],
   ): Promise<TxSimulationResult> {
     return await this.jobQueue.put(async () => {
       const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
-      const publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
+
+      let publicInputs: PrivateKernelTailCircuitPublicInputs;
+      let profileResult;
+      if (profile) {
+        ({ publicInputs, profileResult } = await this.#profileKernelProver(
+          txRequest,
+          this.proofCreator,
+          privateExecutionResult,
+        ));
+      } else {
+        publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
+      }
+
       const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
       const simulatedTx = privateSimulationResult.toSimulatedTx();
       let publicOutput: PublicSimulationOutput | undefined;
@@ -554,7 +546,11 @@ export class PXEService implements PXE {
       if (!msgSender) {
         this.log.info(`Executed local simulation for ${simulatedTx.getTxHash()}`);
       }
-      return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput);
+      return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(
+        privateSimulationResult,
+        publicOutput,
+        profileResult,
+      );
     });
   }
 
@@ -612,6 +608,15 @@ export class PXEService implements PXE {
     return this.node.getUnencryptedLogs(filter);
   }
 
+  /**
+   * Gets contract class logs based on the provided filter.
+   * @param filter - The filter to apply to the logs.
+   * @returns The requested logs.
+   */
+  public getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+    return this.node.getContractClassLogs(filter);
+  }
+
   async #getFunctionCall(functionName: string, args: any[], to: AztecAddress): Promise<FunctionCall> {
     const contract = await this.db.getContract(to);
     if (!contract) {
@@ -676,7 +681,6 @@ export class PXEService implements PXE {
       const { address, contractClass, instance, artifact } = getCanonicalProtocolContract(name);
       await this.db.addContractArtifact(contractClass.id, artifact);
       await this.db.addContractInstance(instance);
-      await this.synchronizer.reprocessDeferredNotesForContract(address);
       this.log.info(`Added protocol contract ${name} at ${address.toString()}`);
     }
   }
@@ -759,18 +763,36 @@ export class PXEService implements PXE {
    * @param tx - The transaction to be simulated.
    */
   async #simulatePublicCalls(tx: Tx) {
+    // Simulating public calls can throw if the TX fails in a phase that doesn't allow reverts (setup)
+    // Or return as reverted if it fails in a phase that allows reverts (app logic, teardown)
     try {
-      return await this.node.simulatePublicCalls(tx);
+      const result = await this.node.simulatePublicCalls(tx);
+      if (result.revertReason) {
+        throw result.revertReason;
+      }
+      return result;
     } catch (err) {
-      // Try to fill in the noir call stack since the PXE may have access to the debug metadata
       if (err instanceof SimulationError) {
         await enrichPublicSimulationError(err, this.contractDataOracle, this.db, this.log);
       }
-
       throw err;
     }
   }
 
+  async #profileKernelProver(
+    txExecutionRequest: TxExecutionRequest,
+    proofCreator: PrivateKernelProver,
+    privateExecutionResult: PrivateExecutionResult,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    const block = privateExecutionResult.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
+    const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node, block);
+    const kernelProver = new KernelProver(kernelOracle, proofCreator);
+
+    // Dry run the prover with profiler enabled
+    const result = await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult, true, true);
+    return result;
+  }
+
   /**
    * Simulate a transaction, generate a kernel proof, and create a private transaction object.
    * The function takes in a transaction request, simulates it, and then generates a kernel proof
@@ -803,18 +825,10 @@ export class PXEService implements PXE {
     return await this.synchronizer.isGlobalStateSynchronized();
   }
 
-  public async isAccountStateSynchronized(account: AztecAddress) {
-    return await this.synchronizer.isAccountStateSynchronized(account);
-  }
-
   public getSyncStatus() {
     return Promise.resolve(this.synchronizer.getSyncStatus());
   }
 
-  public getSyncStats(): Promise<{ [address: string]: NoteProcessorStats }> {
-    return Promise.resolve(this.synchronizer.getSyncStats());
-  }
-
   public async isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
     return !!(await this.node.getContractClass(id));
   }
@@ -824,44 +838,18 @@ export class PXEService implements PXE {
   }
 
   public async isContractInitialized(address: AztecAddress): Promise<boolean> {
-    const initNullifier = siloNullifier(address, address);
+    const initNullifier = siloNullifier(address, address.toField());
     return !!(await this.node.getNullifierMembershipWitness('latest', initNullifier));
   }
 
-  public getEvents<T>(
-    type: EventType.Encrypted,
-    eventMetadata: EventMetadata<T>,
-    from: number,
-    limit: number,
-    vpks: Point[],
-  ): Promise<T[]>;
-  public getEvents<T>(
-    type: EventType.Unencrypted,
-    eventMetadata: EventMetadata<T>,
-    from: number,
-    limit: number,
-  ): Promise<T[]>;
-  public getEvents<T>(
-    type: EventType,
-    eventMetadata: EventMetadata<T>,
-    from: number,
-    limit: number,
-    vpks: Point[] = [],
-  ): Promise<T[]> {
-    if (type.includes(EventType.Encrypted)) {
-      return this.getEncryptedEvents(from, limit, eventMetadata, vpks);
-    }
-
-    return this.getUnencryptedEvents(from, limit, eventMetadata);
-  }
-
-  async getEncryptedEvents<T>(
+  public async getEncryptedEvents<T>(
+    eventMetadataDef: EventMetadataDefinition,
     from: number,
     limit: number,
-    eventMetadata: EventMetadata<T>,
     // TODO (#9272): Make this better, we should be able to only pass an address now
     vpks: Point[],
   ): Promise<T[]> {
+    const eventMetadata = new EventMetadata<T>(eventMetadataDef);
     if (vpks.length === 0) {
       throw new Error('Tried to get encrypted events without supplying any viewing public keys');
     }
@@ -925,7 +913,8 @@ export class PXEService implements PXE {
     return decodedEvents;
   }
 
-  async getUnencryptedEvents<T>(from: number, limit: number, eventMetadata: EventMetadata<T>): Promise<T[]> {
+  async getUnencryptedEvents<T>(eventMetadataDef: EventMetadataDefinition, from: number, limit: number): Promise<T[]> {
+    const eventMetadata = new EventMetadata<T>(eventMetadataDef);
     const { logs: unencryptedLogs } = await this.node.getUnencryptedLogs({
       fromBlock: from,
       toBlock: from + limit,

package/src/pxe_service/test/pxe_test_suite.ts

@@ -4,15 +4,9 @@ import {
   randomContractInstanceWithAddress,
   randomDeployedContract,
 } from '@aztec/circuit-types';
-import {
-  AztecAddress,
-  CompleteAddress,
-  Fr,
-  INITIAL_L2_BLOCK_NUM,
-  Point,
-  PublicKeys,
-  getContractClassFromArtifact,
-} from '@aztec/circuits.js';
+import { AztecAddress, Fr, INITIAL_L2_BLOCK_NUM, getContractClassFromArtifact } from '@aztec/circuits.js';
+
+import omit from 'lodash.omit';
 
 export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) => {
   describe(testName, () => {
@@ -29,33 +23,11 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
 
       // Check that the account is correctly registered using the getAccounts and getRecipients methods
       const accounts = await pxe.getRegisteredAccounts();
-      const recipients = await pxe.getRecipients();
       expect(accounts).toContainEqual(completeAddress);
-      expect(recipients).not.toContainEqual(completeAddress);
 
       // Check that the account is correctly registered using the getAccount and getRecipient methods
       const account = await pxe.getRegisteredAccount(completeAddress.address);
-      const recipient = await pxe.getRecipient(completeAddress.address);
       expect(account).toEqual(completeAddress);
-      expect(recipient).toBeUndefined();
-    });
-
-    it('registers a recipient and returns it as a recipient only and not as an account', async () => {
-      const completeAddress = CompleteAddress.random();
-
-      await pxe.registerRecipient(completeAddress);
-
-      // Check that the recipient is correctly registered using the getAccounts and getRecipients methods
-      const accounts = await pxe.getRegisteredAccounts();
-      const recipients = await pxe.getRecipients();
-      expect(accounts).not.toContainEqual(completeAddress);
-      expect(recipients).toContainEqual(completeAddress);
-
-      // Check that the recipient is correctly registered using the getAccount and getRecipient methods
-      const account = await pxe.getRegisteredAccount(completeAddress.address);
-      const recipient = await pxe.getRecipient(completeAddress.address);
-      expect(account).toBeUndefined();
-      expect(recipient).toEqual(completeAddress);
     });
 
     it('does not throw when registering the same account twice (just ignores the second attempt)', async () => {
@@ -66,28 +38,6 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       await pxe.registerAccount(randomSecretKey, randomPartialAddress);
     });
 
-    // Disabled as CompleteAddress constructor now performs preimage validation.
-    it.skip('cannot register a recipient with the same aztec address but different pub key or partial address', async () => {
-      const recipient1 = CompleteAddress.random();
-      const recipient2 = new CompleteAddress(
-        recipient1.address,
-        new PublicKeys(Point.random(), Point.random(), Point.random(), Point.random()),
-        Fr.random(),
-      );
-
-      await pxe.registerRecipient(recipient1);
-      await expect(() => pxe.registerRecipient(recipient2)).rejects.toThrow(
-        `Complete address with aztec address ${recipient1.address}`,
-      );
-    });
-
-    it('does not throw when registering the same recipient twice (just ignores the second attempt)', async () => {
-      const completeAddress = CompleteAddress.random();
-
-      await pxe.registerRecipient(completeAddress);
-      await pxe.registerRecipient(completeAddress);
-    });
-
     it('successfully adds a contract', async () => {
       const contracts = [randomDeployedContract(), randomDeployedContract()];
       for (const contract of contracts) {
@@ -106,7 +56,9 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       const instance = randomContractInstanceWithAddress({ contractClassId });
 
       await pxe.registerContractClass(artifact);
-      expect(await pxe.getContractClass(contractClassId)).toEqual(contractClass);
+      expect(await pxe.getContractClass(contractClassId)).toMatchObject(
+        omit(contractClass, 'privateFunctionsRoot', 'publicBytecodeCommitment'),
+      );
 
       await pxe.registerContract({ instance });
       expect(await pxe.getContractInstance(instance.address)).toEqual(instance);
@@ -121,7 +73,7 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
         pxe.registerContract({
           instance: {
             ...instance,
-            address: Fr.random(),
+            address: AztecAddress.random(),
           },
           artifact,
         }),