@aztec/pxe 0.86.0 → 0.87.0

package/src/pxe_service/error_enriching.ts

@@ -16,35 +16,45 @@ export async function enrichSimulationError(
   contractDataProvider: ContractDataProvider,
   logger: Logger,
 ) {
-  // Maps contract addresses to the set of function names that were in error.
+  // Maps contract addresses to the set of function selectors that were in error.
   // Map and Set do reference equality for their keys instead of value equality, so we store the string
   // representation to get e.g. different contract address objects with the same address value to match.
-  const mentionedFunctions: Map<string, Set<string>> = new Map();
+  const mentionedFunctions: Map<string, Set<FunctionSelector>> = new Map();
 
-  err.getCallStack().forEach(({ contractAddress, functionName }) => {
+  err.getCallStack().forEach(({ contractAddress, functionSelector }) => {
     if (!mentionedFunctions.has(contractAddress.toString())) {
       mentionedFunctions.set(contractAddress.toString(), new Set());
     }
-    mentionedFunctions.get(contractAddress.toString())!.add(functionName?.toString() ?? '');
+    if (functionSelector) {
+      mentionedFunctions.get(contractAddress.toString())!.add(functionSelector);
+    }
   });
 
   await Promise.all(
-    [...mentionedFunctions.entries()].map(async ([contractAddress, fnNames]) => {
+    [...mentionedFunctions.entries()].map(async ([contractAddress, fnSelectors]) => {
       const parsedContractAddress = AztecAddress.fromString(contractAddress);
       const contract = await contractDataProvider.getContract(parsedContractAddress);
       if (contract) {
         err.enrichWithContractName(parsedContractAddress, contract.name);
-        for (const fnName of fnNames) {
-          const functionArtifact = contract.functions.find(f => fnName === f.name);
-          if (functionArtifact) {
+        // Map from function selector to function name. It uses a stringified key for the same reason as mentionedFunctions.
+        const selectorToNameMap: Map<string, string> = new Map();
+        await Promise.all(
+          contract.functions.map(async fn => {
+            const selector = await FunctionSelector.fromNameAndParameters(fn);
+            selectorToNameMap.set(selector.toString(), fn.name);
+          }),
+        );
+
+        for (const fnSelector of fnSelectors) {
+          if (selectorToNameMap.has(fnSelector.toString())) {
             err.enrichWithFunctionName(
               parsedContractAddress,
-              await FunctionSelector.fromNameAndParameters(functionArtifact),
-              functionArtifact.name,
+              fnSelector,
+              selectorToNameMap.get(fnSelector.toString())!,
             );
           } else {
             logger.warn(
-              `Could not find function artifact in contract ${contract.name} for function '${fnName}' when enriching error callstack`,
+              `Could not find function artifact in contract ${contract.name} for function '${fnSelector}' when enriching error callstack`,
             );
           }
         }
@@ -85,7 +95,7 @@ export async function enrichPublicSimulationError(
       try {
         // Public functions are simulated as a single Brillig entry point.
         // Thus, we can safely assume here that the Brillig function id is `0`.
-        const parsedCallStack = resolveOpcodeLocations(noirCallStack, debugInfo, 0);
+        const parsedCallStack = resolveOpcodeLocations(noirCallStack, debugInfo.debugSymbols, debugInfo.files, 0);
         err.setNoirCallStack(parsedCallStack);
       } catch (err) {
         logger.warn(

package/src/pxe_service/pxe_service.ts

@@ -14,7 +14,6 @@ import {
 } from '@aztec/protocol-contracts';
 import { AcirSimulator, type SimulationProvider, readCurrentClassId } from '@aztec/simulator/client';
 import {
-  type AbiDecoded,
   type ContractArtifact,
   EventSelector,
   FunctionCall,
@@ -57,7 +56,9 @@ import {
   type IndexedTxEffect,
   PrivateExecutionResult,
   PrivateSimulationResult,
+  type ProvingTimings,
   PublicSimulationOutput,
+  type SimulationTimings,
   Tx,
   TxExecutionRequest,
   type TxHash,
@@ -65,6 +66,7 @@ import {
   TxProvingResult,
   type TxReceipt,
   TxSimulationResult,
+  UtilitySimulationResult,
 } from '@aztec/stdlib/tx';
 
 import { inspect } from 'util';
@@ -91,6 +93,8 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
  * A Private eXecution Environment (PXE) implementation.
  */
 export class PXEService implements PXE {
+  #nodeInfo?: NodeInfo;
+
   private constructor(
     private node: AztecNode,
     private synchronizer: Synchronizer,
@@ -648,23 +652,52 @@ export class PXEService implements PXE {
 
   public proveTx(
     txRequest: TxExecutionRequest,
-    privateExecutionResult: PrivateExecutionResult,
+    privateExecutionResult?: PrivateExecutionResult,
   ): Promise<TxProvingResult> {
     // We disable proving concurrently mostly out of caution, since it accesses some of our stores. Proving is so
     // computationally demanding that it'd be rare for someone to try to do it concurrently regardless.
     return this.#putInJobQueue(async () => {
+      const totalTimer = new Timer();
       try {
-        const { publicInputs, clientIvcProof } = await this.#prove(
-          txRequest,
-          this.proofCreator,
-          privateExecutionResult,
-          {
-            simulate: false,
-            skipFeeEnforcement: false,
-            profileMode: 'none',
-          },
-        );
-        return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
+        let syncTime: number | undefined;
+        if (!privateExecutionResult) {
+          const syncTimer = new Timer();
+          await this.synchronizer.sync();
+          syncTime = syncTimer.ms();
+          privateExecutionResult = await this.#executePrivate(txRequest);
+        }
+        const {
+          publicInputs,
+          clientIvcProof,
+          executionSteps,
+          timings: { proving } = {},
+        } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+          simulate: false,
+          skipFeeEnforcement: false,
+          profileMode: 'none',
+        });
+
+        const totalTime = totalTimer.ms();
+
+        const perFunction = executionSteps.map(({ functionName, timings: { witgen } }) => ({
+          functionName,
+          time: witgen,
+        }));
+
+        const timings: ProvingTimings = {
+          total: totalTime,
+          sync: syncTime,
+          proving,
+          perFunction,
+          unaccounted:
+            totalTime - ((syncTime ?? 0) + (proving ?? 0) + perFunction.reduce((acc, { time }) => acc + time, 0)),
+        };
+
+        this.log.info(`Proving completed in ${totalTime}ms`, {
+          timings,
+        });
+
+        return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!, timings);
       } catch (err: any) {
         throw this.#contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
       }
@@ -674,10 +707,12 @@ export class PXEService implements PXE {
   public profileTx(
     txRequest: TxExecutionRequest,
     profileMode: 'full' | 'execution-steps' | 'gates',
+    skipProofGeneration: boolean = true,
     msgSender?: AztecAddress,
   ): Promise<TxProfileResult> {
     // We disable concurrent profiles for consistency with simulateTx.
     return this.#putInJobQueue(async () => {
+      const totalTimer = new Timer();
       try {
         const txInfo = {
           origin: txRequest.origin,
@@ -692,16 +727,48 @@ export class PXEService implements PXE {
           `Profiling transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`,
           txInfo,
         );
+        const syncTimer = new Timer();
         await this.synchronizer.sync();
+        const syncTime = syncTimer.ms();
+
         const privateExecutionResult = await this.#executePrivate(txRequest, msgSender);
 
-        const { executionSteps } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
-          simulate: true,
-          skipFeeEnforcement: false,
-          profileMode,
-        });
+        const { executionSteps, timings: { proving } = {} } = await this.#prove(
+          txRequest,
+          this.proofCreator,
+          privateExecutionResult,
+          {
+            simulate: skipProofGeneration,
+            skipFeeEnforcement: false,
+            profileMode,
+          },
+        );
 
-        return new TxProfileResult(executionSteps);
+        const totalTime = totalTimer.ms();
+
+        const perFunction = executionSteps.map(({ functionName, timings: { witgen } }) => ({
+          functionName,
+          time: witgen,
+        }));
+
+        // Gate computation is time is not relevant for profiling, so we subtract it from the total time.
+        const gateCountComputationTime =
+          executionSteps.reduce((acc, { timings }) => acc + (timings.gateCount ?? 0), 0) ?? 0;
+
+        const timings: ProvingTimings = {
+          total: totalTime - gateCountComputationTime,
+          sync: syncTime,
+          proving,
+          perFunction,
+          unaccounted:
+            totalTime -
+            ((syncTime ?? 0) +
+              (proving ?? 0) +
+              perFunction.reduce((acc, { time }) => acc + time, 0) +
+              gateCountComputationTime),
+        };
+
+        return new TxProfileResult(executionSteps, timings);
       } catch (err: any) {
         throw this.#contextualizeError(
           err,
@@ -727,6 +794,7 @@ export class PXEService implements PXE {
     // delete the same read value, or reading values that another simulation is currently modifying).
     return this.#putInJobQueue(async () => {
       try {
+        const totalTimer = new Timer();
         const txInfo = {
           origin: txRequest.origin,
           functionSelector: txRequest.functionSelector,
@@ -740,32 +808,67 @@ export class PXEService implements PXE {
           `Simulating transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`,
           txInfo,
         );
-        const timer = new Timer();
+        const syncTimer = new Timer();
         await this.synchronizer.sync();
+        const syncTime = syncTimer.ms();
+
         const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
 
-        const { publicInputs } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
-          simulate: true,
-          skipFeeEnforcement,
-          profileMode: 'none',
-        });
+        const { publicInputs, executionSteps } = await this.#prove(
+          txRequest,
+          this.proofCreator,
+          privateExecutionResult,
+          {
+            simulate: true,
+            skipFeeEnforcement,
+            profileMode: 'none',
+          },
+        );
 
         const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
         const simulatedTx = privateSimulationResult.toSimulatedTx();
+        let publicSimulationTime: number | undefined;
         let publicOutput: PublicSimulationOutput | undefined;
         if (simulatePublic && publicInputs.forPublic) {
+          const publicSimulationTimer = new Timer();
           publicOutput = await this.#simulatePublicCalls(simulatedTx, skipFeeEnforcement);
+          publicSimulationTime = publicSimulationTimer.ms();
         }
 
+        let validationTime: number | undefined;
         if (!skipTxValidation) {
+          const validationTimer = new Timer();
           const validationResult = await this.node.isValidTx(simulatedTx, { isSimulation: true, skipFeeEnforcement });
+          validationTime = validationTimer.ms();
           if (validationResult.result === 'invalid') {
             throw new Error('The simulated transaction is unable to be added to state and is invalid.');
           }
         }
 
         const txHash = await simulatedTx.getTxHash();
-        this.log.info(`Simulation completed for ${txHash.toString()} in ${timer.ms()}ms`, {
+
+        const totalTime = totalTimer.ms();
+
+        const perFunction = executionSteps.map(({ functionName, timings: { witgen } }) => ({
+          functionName,
+          time: witgen,
+        }));
+
+        const timings: SimulationTimings = {
+          total: totalTime,
+          sync: syncTime,
+          publicSimulation: publicSimulationTime,
+          validation: validationTime,
+          perFunction,
+          unaccounted:
+            totalTime -
+            (syncTime +
+              (publicSimulationTime ?? 0) +
+              (validationTime ?? 0) +
+              perFunction.reduce((acc, { time }) => acc + time, 0)),
+        };
+
+        this.log.info(`Simulation completed for ${txHash.toString()} in ${totalTime}ms`, {
           txHash,
           ...txInfo,
           ...(publicOutput
@@ -775,9 +878,14 @@ export class PXEService implements PXE {
                 revertReason: publicOutput.revertReason,
               }
             : {}),
+          timings,
         });
 
-        return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput);
+        return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(
+          privateSimulationResult,
+          publicOutput,
+          timings,
+        );
       } catch (err: any) {
         throw this.#contextualizeError(
           err,
@@ -811,19 +919,34 @@ export class PXEService implements PXE {
     authwits?: AuthWitness[],
     _from?: AztecAddress,
     scopes?: AztecAddress[],
-  ): Promise<AbiDecoded> {
+  ): Promise<UtilitySimulationResult> {
     // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
     // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
     // delete the same read value, or reading values that another simulation is currently modifying).
     return this.#putInJobQueue(async () => {
       try {
+        const totalTimer = new Timer();
+        const syncTimer = new Timer();
         await this.synchronizer.sync();
+        const syncTime = syncTimer.ms();
         // TODO - Should check if `from` has the permission to call the view function.
         const functionCall = await this.#getFunctionCall(functionName, args, to);
+        const functionTimer = new Timer();
         const executionResult = await this.#simulateUtility(functionCall, authwits ?? [], scopes);
+        const functionTime = functionTimer.ms();
 
-        // TODO - Return typed result based on the function artifact.
-        return executionResult;
+        const totalTime = totalTimer.ms();
+
+        const perFunction = [{ functionName, time: functionTime }];
+
+        const timings: SimulationTimings = {
+          total: totalTime,
+          sync: syncTime,
+          perFunction,
+          unaccounted: totalTime - (syncTime + perFunction.reduce((acc, { time }) => acc + time, 0)),
+        };
+
+        return { result: executionResult, timings };
       } catch (err: any) {
         const stringifiedArgs = args.map(arg => arg.toString()).join(', ');
         throw this.#contextualizeError(
@@ -836,25 +959,31 @@ export class PXEService implements PXE {
   }
 
   public async getNodeInfo(): Promise<NodeInfo> {
-    const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses] = await Promise.all([
-      this.node.getNodeVersion(),
-      this.node.getVersion(),
-      this.node.getChainId(),
-      this.node.getEncodedEnr(),
-      this.node.getL1ContractAddresses(),
-      this.node.getProtocolContractAddresses(),
-    ]);
-
-    const nodeInfo: NodeInfo = {
-      nodeVersion,
-      l1ChainId: chainId,
-      rollupVersion,
-      enr,
-      l1ContractAddresses: contractAddresses,
-      protocolContractAddresses: protocolContractAddresses,
-    };
+    // This assumes we're connected to a single node, so we cache the info to avoid repeated calls.
+    // Load balancers and a myriad other configurations can break this assumption, so review this!
+    // Temporary mesure to avoid hammering full nodes with requests on testnet.
+    if (!this.#nodeInfo) {
+      const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses] =
+        await Promise.all([
+          this.node.getNodeVersion(),
+          this.node.getVersion(),
+          this.node.getChainId(),
+          this.node.getEncodedEnr(),
+          this.node.getL1ContractAddresses(),
+          this.node.getProtocolContractAddresses(),
+        ]);
+
+      this.#nodeInfo = {
+        nodeVersion,
+        l1ChainId: chainId,
+        rollupVersion,
+        enr,
+        l1ContractAddresses: contractAddresses,
+        protocolContractAddresses: protocolContractAddresses,
+      };
+    }
 
-    return nodeInfo;
+    return this.#nodeInfo;
   }
 
   public getPXEInfo(): Promise<PXEInfo> {
@@ -908,19 +1037,19 @@ export class PXEService implements PXE {
       .map(log => {
         // +1 for the event selector
         const expectedLength = eventMetadataDef.fieldNames.length + 1;
-        const logFields = log.log.log.slice(0, expectedLength);
+        if (log.log.emittedLength !== expectedLength) {
+          throw new Error(
+            `Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length. Expected ${expectedLength}. Got ${log.log.emittedLength}.`,
+          );
+        }
+
+        const logFields = log.log.getEmittedFields();
         // 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.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
           return undefined;
         }
-        // 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 decodeFromAbi([eventMetadataDef.abiType], log.log.log) as T;
+        return decodeFromAbi([eventMetadataDef.abiType], log.log.fields) as T;
       })
       .filter(log => log !== undefined) as T[];
 

package/src/storage/note_data_provider/note_data_provider.ts

@@ -199,20 +199,22 @@ export class NoteDataProvider implements DataProvider {
               this.#notesByRecipientAndScope.get(formattedScopeString)!.getValuesAsync(filter.recipient.toString()),
             )
           : filter.txHash
-          ? await toArray(
-              this.#notesByTxHashAndScope.get(formattedScopeString)!.getValuesAsync(filter.txHash.toString()),
-            )
-          : filter.contractAddress
-          ? await toArray(
-              this.#notesByContractAndScope
-                .get(formattedScopeString)!
-                .getValuesAsync(filter.contractAddress.toString()),
-            )
-          : filter.storageSlot
-          ? await toArray(
-              this.#notesByStorageSlotAndScope.get(formattedScopeString)!.getValuesAsync(filter.storageSlot.toString()),
-            )
-          : await toArray(this.#notesByRecipientAndScope.get(formattedScopeString)!.valuesAsync()),
+            ? await toArray(
+                this.#notesByTxHashAndScope.get(formattedScopeString)!.getValuesAsync(filter.txHash.toString()),
+              )
+            : filter.contractAddress
+              ? await toArray(
+                  this.#notesByContractAndScope
+                    .get(formattedScopeString)!
+                    .getValuesAsync(filter.contractAddress.toString()),
+                )
+              : filter.storageSlot
+                ? await toArray(
+                    this.#notesByStorageSlotAndScope
+                      .get(formattedScopeString)!
+                      .getValuesAsync(filter.storageSlot.toString()),
+                  )
+                : await toArray(this.#notesByRecipientAndScope.get(formattedScopeString)!.valuesAsync()),
       );
     }
 
@@ -226,12 +228,12 @@ export class NoteDataProvider implements DataProvider {
         ids: filter.recipient
           ? await toArray(this.#nullifiedNotesByRecipient.getValuesAsync(filter.recipient.toString()))
           : filter.txHash
-          ? await toArray(this.#nullifiedNotesByTxHash.getValuesAsync(filter.txHash.toString()))
-          : filter.contractAddress
-          ? await toArray(this.#nullifiedNotesByContract.getValuesAsync(filter.contractAddress.toString()))
-          : filter.storageSlot
-          ? await toArray(this.#nullifiedNotesByStorageSlot.getValuesAsync(filter.storageSlot.toString()))
-          : await toArray(this.#nullifiedNotes.keysAsync()),
+            ? await toArray(this.#nullifiedNotesByTxHash.getValuesAsync(filter.txHash.toString()))
+            : filter.contractAddress
+              ? await toArray(this.#nullifiedNotesByContract.getValuesAsync(filter.contractAddress.toString()))
+              : filter.storageSlot
+                ? await toArray(this.#nullifiedNotesByStorageSlot.getValuesAsync(filter.storageSlot.toString()))
+                : await toArray(this.#nullifiedNotes.keysAsync()),
         notes: this.#nullifiedNotes,
       });
     }

package/src/synchronizer/synchronizer.ts

@@ -105,7 +105,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
 
     try {
       currentHeader = await this.syncDataProvider.getBlockHeader();
-    } catch (e) {
+    } catch {
       this.log.debug('Header is not set, requesting from the node');
     }
     if (!currentHeader) {