@aztec/pxe 0.65.2 → 0.67.0

package/src/pxe_service/pxe_service.ts

@@ -12,7 +12,6 @@ import {
   type L2Block,
   type LogFilter,
   MerkleTreeId,
-  type OutgoingNotesFilter,
   type PXE,
   type PXEInfo,
   type PrivateExecutionResult,
@@ -56,8 +55,7 @@ import {
   encodeArguments,
 } from '@aztec/foundation/abi';
 import { Fr, type Point } from '@aztec/foundation/fields';
-import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { SerialQueue } from '@aztec/foundation/queue';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type KeyStore } from '@aztec/key-store';
 import { type L2TipsStore } from '@aztec/kv-store/stores';
 import {
@@ -65,9 +63,12 @@ import {
   getCanonicalProtocolContract,
   protocolContractNames,
 } from '@aztec/protocol-contracts';
-import { type AcirSimulator } from '@aztec/simulator';
+import { type AcirSimulator } from '@aztec/simulator/client';
 
-import { type PXEServiceConfig, getPackageInfo } from '../config/index.js';
+import { inspect } from 'util';
+
+import { type PXEServiceConfig } from '../config/index.js';
+import { getPackageInfo } from '../config/package_info.js';
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
 import { IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
@@ -85,11 +86,8 @@ export class PXEService implements PXE {
   private synchronizer: Synchronizer;
   private contractDataOracle: ContractDataOracle;
   private simulator: AcirSimulator;
-  private log: DebugLogger;
+  private log: Logger;
   private packageVersion: string;
-  // serialize synchronizer and calls to proveTx.
-  // ensures that state is not changed while simulating
-  private jobQueue = new SerialQueue();
 
   constructor(
     private keyStore: KeyStore,
@@ -100,13 +98,11 @@ export class PXEService implements PXE {
     config: PXEServiceConfig,
     logSuffix?: string,
   ) {
-    this.log = createDebugLogger(logSuffix ? `aztec:pxe_service_${logSuffix}` : `aztec:pxe_service`);
+    this.log = createLogger(logSuffix ? `pxe:service:${logSuffix}` : `pxe:service`);
     this.synchronizer = new Synchronizer(node, db, tipsStore, config, logSuffix);
     this.contractDataOracle = new ContractDataOracle(db);
     this.simulator = getAcirSimulator(db, node, keyStore, this.contractDataOracle);
     this.packageVersion = getPackageInfo().version;
-
-    this.jobQueue.start();
   }
 
   /**
@@ -114,25 +110,14 @@ export class PXEService implements PXE {
    *
    * @returns A promise that resolves when the server has started successfully.
    */
-  public async start() {
-    await this.synchronizer.start();
+  public async init() {
     await this.#registerProtocolContracts();
     const info = await this.getNodeInfo();
     this.log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
   }
 
-  /**
-   * 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.
-   * It is useful for gracefully shutting down the server during maintenance or restarts.
-   *
-   * @returns A Promise resolving once the server has been stopped successfully.
-   */
-  public async stop() {
-    await this.jobQueue.cancel();
-    this.log.info('Cancelled Job Queue');
-    await this.synchronizer.stop();
-    this.log.info('Stopped Synchronizer');
+  isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
+    return this.node.isL1ToL2MessageSynced(l1ToL2Message);
   }
 
   /** Returns an estimate of the db size in bytes. */
@@ -314,33 +299,6 @@ export class PXEService implements PXE {
     return Promise.all(extendedNotes);
   }
 
-  public async getOutgoingNotes(filter: OutgoingNotesFilter): Promise<UniqueNote[]> {
-    const noteDaos = await this.db.getOutgoingNotes(filter);
-
-    const extendedNotes = noteDaos.map(async dao => {
-      let owner = filter.owner;
-      if (owner === undefined) {
-        const completeAddresses = (await this.db.getCompleteAddresses()).find(address =>
-          address.publicKeys.masterOutgoingViewingPublicKey.equals(dao.ovpkM),
-        );
-        if (completeAddresses === undefined) {
-          throw new Error(`Cannot find complete address for OvpkM ${dao.ovpkM.toString()}`);
-        }
-        owner = completeAddresses.address;
-      }
-      return new UniqueNote(
-        dao.note,
-        owner,
-        dao.contractAddress,
-        dao.storageSlot,
-        dao.noteTypeId,
-        dao.txHash,
-        dao.nonce,
-      );
-    });
-    return Promise.all(extendedNotes);
-  }
-
   public async getL1ToL2MembershipWitness(
     contractAddress: AztecAddress,
     messageHash: Fr,
@@ -361,7 +319,7 @@ export class PXEService implements PXE {
     }
 
     for (const nonce of nonces) {
-      const { noteHash, siloedNoteHash, innerNullifier } = await this.simulator.computeNoteHashAndOptionallyANullifier(
+      const { noteHash, uniqueNoteHash, innerNullifier } = await this.simulator.computeNoteHashAndOptionallyANullifier(
         note.contractAddress,
         nonce,
         note.storageSlot,
@@ -370,7 +328,7 @@ export class PXEService implements PXE {
         note.note,
       );
 
-      const [index] = await this.node.findLeavesIndexes('latest', MerkleTreeId.NOTE_HASH_TREE, [siloedNoteHash]);
+      const [index] = await this.node.findLeavesIndexes('latest', MerkleTreeId.NOTE_HASH_TREE, [uniqueNoteHash]);
       if (index === undefined) {
         throw new Error('Note does not exist.');
       }
@@ -410,7 +368,7 @@ export class PXEService implements PXE {
     }
 
     for (const nonce of nonces) {
-      const { noteHash, siloedNoteHash, innerNullifier } = await this.simulator.computeNoteHashAndOptionallyANullifier(
+      const { noteHash, uniqueNoteHash, innerNullifier } = await this.simulator.computeNoteHashAndOptionallyANullifier(
         note.contractAddress,
         nonce,
         note.storageSlot,
@@ -423,7 +381,7 @@ export class PXEService implements PXE {
         throw new Error('Unexpectedly received non-zero nullifier.');
       }
 
-      const [index] = await this.node.findLeavesIndexes('latest', MerkleTreeId.NOTE_HASH_TREE, [siloedNoteHash]);
+      const [index] = await this.node.findLeavesIndexes('latest', MerkleTreeId.NOTE_HASH_TREE, [uniqueNoteHash]);
       if (index === undefined) {
         throw new Error('Note does not exist.');
       }
@@ -469,7 +427,7 @@ export class PXEService implements PXE {
       }
 
       const nonce = computeNoteHashNonce(firstNullifier, i);
-      const { siloedNoteHash } = await this.simulator.computeNoteHashAndOptionallyANullifier(
+      const { uniqueNoteHash } = await this.simulator.computeNoteHashAndOptionallyANullifier(
         note.contractAddress,
         nonce,
         note.storageSlot,
@@ -477,7 +435,7 @@ export class PXEService implements PXE {
         false,
         note.note,
       );
-      if (hash.equals(siloedNoteHash)) {
+      if (hash.equals(uniqueNoteHash)) {
         nonces.push(nonce);
       }
     }
@@ -505,23 +463,16 @@ export class PXEService implements PXE {
     return result.publicInputs;
   }
 
-  public proveTx(
+  public async proveTx(
     txRequest: TxExecutionRequest,
     privateExecutionResult: PrivateExecutionResult,
   ): Promise<TxProvingResult> {
-    return this.jobQueue
-      .put(async () => {
-        const { publicInputs, clientIvcProof } = await this.#prove(
-          txRequest,
-          this.proofCreator,
-          privateExecutionResult,
-        );
-        return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
-      })
-      .catch(err => {
-        this.log.error(err);
-        throw err;
-      });
+    try {
+      const { publicInputs, clientIvcProof } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult);
+      return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
+    } catch (err: any) {
+      throw this.contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
+    }
   }
 
   // TODO(#7456) Prevent msgSender being defined here for the first call
@@ -533,52 +484,77 @@ export class PXEService implements PXE {
     profile: boolean = false,
     scopes?: AztecAddress[],
   ): Promise<TxSimulationResult> {
-    return await this.jobQueue
-      .put(async () => {
-        const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
-
-        let publicInputs: PrivateKernelTailCircuitPublicInputs;
-        let profileResult;
-        if (profile) {
-          ({ publicInputs, profileResult } = await this.#profileKernelProver(
-            txRequest,
-            this.proofCreator,
-            privateExecutionResult,
-          ));
-        } else {
-          publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
-        }
+    try {
+      const txInfo = {
+        origin: txRequest.origin,
+        functionSelector: txRequest.functionSelector,
+        simulatePublic,
+        msgSender,
+        chainId: txRequest.txContext.chainId,
+        version: txRequest.txContext.version,
+        authWitnesses: txRequest.authWitnesses.map(w => w.requestHash),
+      };
+      this.log.verbose(
+        `Simulating transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`,
+        txInfo,
+      );
+      await this.synchronizer.sync();
+      const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
 
-        const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
-        const simulatedTx = privateSimulationResult.toSimulatedTx();
-        let publicOutput: PublicSimulationOutput | undefined;
-        if (simulatePublic) {
-          publicOutput = await this.#simulatePublicCalls(simulatedTx);
-        }
+      let publicInputs: PrivateKernelTailCircuitPublicInputs;
+      let profileResult;
+      if (profile) {
+        ({ publicInputs, profileResult } = await this.#profileKernelProver(
+          txRequest,
+          this.proofCreator,
+          privateExecutionResult,
+        ));
+      } else {
+        publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
+      }
 
-        if (!skipTxValidation) {
-          if (!(await this.node.isValidTx(simulatedTx, true))) {
-            throw new Error('The simulated transaction is unable to be added to state and is invalid.');
-          }
-        }
+      const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
+      const simulatedTx = privateSimulationResult.toSimulatedTx();
+      let publicOutput: PublicSimulationOutput | undefined;
+      if (simulatePublic) {
+        publicOutput = await this.#simulatePublicCalls(simulatedTx);
+      }
 
-        // We log only if the msgSender is undefined, as simulating with a different msgSender
-        // is unlikely to be a real transaction, and likely to be only used to read data.
-        // Meaning that it will not necessarily have produced a nullifier (and thus have no TxHash)
-        // If we log, the `getTxHash` function will throw.
-        if (!msgSender) {
-          this.log.info(`Executed local simulation for ${simulatedTx.getTxHash()}`);
+      if (!skipTxValidation) {
+        if (!(await this.node.isValidTx(simulatedTx, true))) {
+          throw new Error('The simulated transaction is unable to be added to state and is invalid.');
         }
-        return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(
-          privateSimulationResult,
-          publicOutput,
-          profileResult,
-        );
-      })
-      .catch(err => {
-        this.log.error(err);
-        throw err;
+      }
+
+      this.log.info(`Simulation completed for ${simulatedTx.tryGetTxHash()}`, {
+        txHash: simulatedTx.tryGetTxHash(),
+        ...txInfo,
+        ...(profileResult ? { gateCounts: profileResult.gateCounts } : {}),
+        ...(publicOutput
+          ? {
+              gasUsed: publicOutput.gasUsed,
+              revertCode: publicOutput.txEffect.revertCode.getCode(),
+              revertReason: publicOutput.revertReason,
+            }
+          : {}),
       });
+
+      return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(
+        privateSimulationResult,
+        publicOutput,
+        profileResult,
+      );
+    } catch (err: any) {
+      throw this.contextualizeError(
+        err,
+        inspect(txRequest),
+        `simulatePublic=${simulatePublic}`,
+        `msgSender=${msgSender?.toString() ?? 'undefined'}`,
+        `skipTxValidation=${skipTxValidation}`,
+        `profile=${profile}`,
+        `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
+      );
+    }
   }
 
   public async sendTx(tx: Tx): Promise<TxHash> {
@@ -586,10 +562,9 @@ export class PXEService implements PXE {
     if (await this.node.getTxEffect(txHash)) {
       throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
     }
-    this.log.info(`Sending transaction ${txHash}`);
+    this.log.debug(`Sending transaction ${txHash}`);
     await this.node.sendTx(tx).catch(err => {
-      this.log.error(err);
-      throw err;
+      throw this.contextualizeError(err, inspect(tx));
     });
     this.log.info(`Sent transaction ${txHash}`);
     return txHash;
@@ -602,20 +577,22 @@ export class PXEService implements PXE {
     _from?: AztecAddress,
     scopes?: AztecAddress[],
   ): Promise<AbiDecoded> {
-    // all simulations must be serialized w.r.t. the synchronizer
-    return await this.jobQueue
-      .put(async () => {
-        // TODO - Should check if `from` has the permission to call the view function.
-        const functionCall = await this.#getFunctionCall(functionName, args, to);
-        const executionResult = await this.#simulateUnconstrained(functionCall, scopes);
-
-        // TODO - Return typed result based on the function artifact.
-        return executionResult;
-      })
-      .catch(err => {
-        this.log.error(err);
-        throw err;
-      });
+    try {
+      await this.synchronizer.sync();
+      // TODO - Should check if `from` has the permission to call the view function.
+      const functionCall = await this.#getFunctionCall(functionName, args, to);
+      const executionResult = await this.#simulateUnconstrained(functionCall, scopes);
+
+      // TODO - Return typed result based on the function artifact.
+      return executionResult;
+    } catch (err: any) {
+      const stringifiedArgs = args.map(arg => arg.toString()).join(', ');
+      throw this.contextualizeError(
+        err,
+        `simulateUnconstrained ${to}:${functionName}(${stringifiedArgs})`,
+        `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
+      );
+    }
   }
 
   public getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
@@ -712,12 +689,14 @@ export class PXEService implements PXE {
   }
 
   async #registerProtocolContracts() {
+    const registered: Record<string, string> = {};
     for (const name of protocolContractNames) {
       const { address, contractClass, instance, artifact } = getCanonicalProtocolContract(name);
       await this.db.addContractArtifact(contractClass.id, artifact);
       await this.db.addContractInstance(instance);
-      this.log.info(`Added protocol contract ${name} at ${address.toString()}`);
+      registered[name] = address.toString();
     }
+    this.log.verbose(`Registered protocol contracts in pxe`, registered);
   }
 
   /**
@@ -749,13 +728,11 @@ export class PXEService implements PXE {
     scopes?: AztecAddress[],
   ): Promise<PrivateExecutionResult> {
     // TODO - Pause syncing while simulating.
-
     const { contractAddress, functionArtifact } = await this.#getSimulationParameters(txRequest);
 
-    this.log.debug('Executing simulator...');
     try {
       const result = await this.simulator.run(txRequest, functionArtifact, contractAddress, msgSender, scopes);
-      this.log.verbose(`Simulation completed for ${contractAddress.toString()}:${functionArtifact.name}`);
+      this.log.debug(`Private simulation completed for ${contractAddress.toString()}:${functionArtifact.name}`);
       return result;
     } catch (err) {
       if (err instanceof SimulationError) {
@@ -833,19 +810,14 @@ export class PXEService implements PXE {
   }
 
   /**
-   * 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
-   * using the simulation result. Finally, it creates a private
-   * transaction object with the generated proof and public inputs. If a new contract address is provided,
-   * the function will also include the new contract's public functions in the transaction object.
+   * Generate a kernel proof, and create a private kernel output.
+   * The function takes in a transaction execution request, and the result of private execution
+   * and then generates a kernel proof.
    *
    * @param txExecutionRequest - The transaction request to be simulated and proved.
    * @param proofCreator - The proof creator to use for proving the execution.
-   * @param msgSender - (Optional) The message sender to use for the simulation.
-   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
-   * @returns An object that contains:
-   * A private transaction object containing the proof, public inputs, and encrypted logs.
-   * The return values of the private execution
+   * @param privateExecutionResult - The result of the private execution
+   * @returns An object that contains the output of the kernel execution, including the ClientIvcProof if proving is enabled.
    */
   async #prove(
     txExecutionRequest: TxExecutionRequest,
@@ -860,14 +832,6 @@ export class PXEService implements PXE {
     return await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult);
   }
 
-  public async isGlobalStateSynchronized() {
-    return await this.synchronizer.isGlobalStateSynchronized();
-  }
-
-  public getSyncStatus() {
-    return Promise.resolve(this.synchronizer.getSyncStatus());
-  }
-
   public async isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
     return !!(await this.node.getContractClass(id));
   }
@@ -896,13 +860,11 @@ export class PXEService implements PXE {
     const blocks = await this.node.getBlocks(from, limit);
 
     const txEffects = blocks.flatMap(block => block.body.txEffects);
-    const encryptedTxLogs = txEffects.flatMap(txEffect => txEffect.encryptedLogs);
-
-    const encryptedLogs = encryptedTxLogs.flatMap(encryptedTxLog => encryptedTxLog.unrollLogs());
+    const privateLogs = txEffects.flatMap(txEffect => txEffect.privateLogs);
 
     const vsks = await Promise.all(
       vpks.map(async vpk => {
-        const [keyPrefix, account] = this.keyStore.getKeyPrefixAndAccount(vpk);
+        const [keyPrefix, account] = await this.keyStore.getKeyPrefixAndAccount(vpk);
         let secretKey = await this.keyStore.getMasterSecretKey(vpk);
         if (keyPrefix === 'iv') {
           const registeredAccount = await this.getRegisteredAccount(account);
@@ -919,10 +881,11 @@ export class PXEService implements PXE {
       }),
     );
 
-    const visibleEvents = encryptedLogs.flatMap(encryptedLog => {
+    const visibleEvents = privateLogs.flatMap(log => {
       for (const sk of vsks) {
-        const decryptedEvent =
-          L1EventPayload.decryptAsIncoming(encryptedLog, sk) ?? L1EventPayload.decryptAsOutgoing(encryptedLog, sk);
+        // 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];
         }
@@ -987,4 +950,18 @@ export class PXEService implements PXE {
   async resetNoteSyncData() {
     return await this.db.resetNoteSyncData();
   }
+
+  private contextualizeError(err: Error, ...context: string[]): Error {
+    let contextStr = '';
+    if (context.length > 0) {
+      contextStr = `\nContext:\n${context.join('\n')}`;
+    }
+    if (err instanceof SimulationError) {
+      err.setAztecContext(contextStr);
+    } else {
+      this.log.error(err.name, err);
+      this.log.debug(contextStr);
+    }
+    return err;
+  }
 }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -115,8 +115,5 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       expect(typeof nodeInfo.l1ChainId).toEqual('number');
       expect(nodeInfo.l1ContractAddresses.rollupAddress.toString()).toMatch(/0x[a-fA-F0-9]+/);
     });
-
-    // Note: Not testing `isGlobalStateSynchronized`, `isAccountStateSynchronized` and `getSyncStatus` as these methods
-    //       only call synchronizer.
   });
 };

package/src/simulator/index.ts

@@ -1,6 +1,6 @@
 import { type AztecNode } from '@aztec/circuit-types';
 import { type KeyStore } from '@aztec/key-store';
-import { AcirSimulator } from '@aztec/simulator';
+import { AcirSimulator } from '@aztec/simulator/client';
 
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
 import { type PxeDatabase } from '../database/pxe_database.js';