@aztec/pxe 1.2.1 → 2.0.0-nightly.20250813

package/src/pxe_service/pxe_service.ts

@@ -214,7 +214,7 @@ export class PXEService implements PXE {
     if (!result) {
       throw new Error(`L2 to L1 message not found in block ${blockNumber}`);
     }
-    return [result.l2MessageIndex, result.siblingPath];
+    return [result.leafIndex, result.siblingPath];
   }
 
   public getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
@@ -318,7 +318,7 @@ export class PXEService implements PXE {
     return !!(await this.node.getContractClass(id));
   }
 
-  async #isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
+  async #isContractPublished(address: AztecAddress): Promise<boolean> {
     return !!(await this.node.getContract(address));
   }
 
@@ -351,10 +351,11 @@ export class PXEService implements PXE {
     };
   }
 
+  // Executes the entrypoint private function, as well as all nested private
+  // functions that might arise.
   async #executePrivate(
     contractFunctionSimulator: ContractFunctionSimulator,
     txRequest: TxExecutionRequest,
-    msgSender?: AztecAddress,
     scopes?: AztecAddress[],
   ): Promise<PrivateExecutionResult> {
     const { origin: contractAddress, functionSelector } = txRequest;
@@ -364,7 +365,10 @@ export class PXEService implements PXE {
         txRequest,
         contractAddress,
         functionSelector,
-        msgSender,
+        undefined,
+        // The sender for tags is set by contracts, typically by an account
+        // contract entrypoint
+        undefined, // senderForTags
         scopes,
       );
       this.log.debug(`Private simulation completed for ${contractAddress.toString()}:${functionSelector}`);
@@ -496,7 +500,7 @@ export class PXEService implements PXE {
   public async getContractMetadata(address: AztecAddress): Promise<{
     contractInstance: ContractInstanceWithAddress | undefined;
     isContractInitialized: boolean;
-    isContractPubliclyDeployed: boolean;
+    isContractPublished: boolean;
   }> {
     let instance;
     try {
@@ -507,7 +511,7 @@ export class PXEService implements PXE {
     return {
       contractInstance: instance,
       isContractInitialized: await this.#isContractInitialized(address),
-      isContractPubliclyDeployed: await this.#isContractPubliclyDeployed(address),
+      isContractPublished: await this.#isContractPublished(address),
     };
   }
 
@@ -656,6 +660,9 @@ export class PXEService implements PXE {
   }
 
   public async getNotes(filter: NotesFilter): Promise<UniqueNote[]> {
+    // We need to manually trigger private state sync to have a guarantee that all the events are available.
+    await this.simulateUtility('sync_private_state', [], filter.contractAddress);
+
     const noteDaos = await this.noteDataProvider.getNotes(filter);
 
     const extendedNotes = noteDaos.map(async dao => {
@@ -734,9 +741,7 @@ export class PXEService implements PXE {
             totalTime - ((syncTime ?? 0) + (proving ?? 0) + perFunction.reduce((acc, { time }) => acc + time, 0)),
         };
 
-        this.log.info(`Proving completed in ${totalTime}ms`, {
-          timings,
-        });
+        this.log.debug(`Proving completed in ${totalTime}ms`, { timings });
         return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!, {
           timings,
           nodeRPCCalls: contractFunctionSimulator?.getStats().nodeRPCCalls,
@@ -751,7 +756,6 @@ export class PXEService implements PXE {
     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 () => {
@@ -761,7 +765,6 @@ export class PXEService implements PXE {
           origin: txRequest.origin,
           functionSelector: txRequest.functionSelector,
           simulatePublic: false,
-          msgSender,
           chainId: txRequest.txContext.chainId,
           version: txRequest.txContext.version,
           authWitnesses: txRequest.authWitnesses.map(w => w.requestHash),
@@ -775,7 +778,7 @@ export class PXEService implements PXE {
         const syncTime = syncTimer.ms();
 
         const contractFunctionSimulator = this.#getSimulatorForTx();
-        const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, msgSender);
+        const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
 
         const { executionSteps, timings: { proving } = {} } = await this.#prove(
           txRequest,
@@ -816,12 +819,7 @@ export class PXEService implements PXE {
         const simulatorStats = contractFunctionSimulator.getStats();
         return new TxProfileResult(executionSteps, { timings, nodeRPCCalls: simulatorStats.nodeRPCCalls });
       } catch (err: any) {
-        throw this.#contextualizeError(
-          err,
-          inspect(txRequest),
-          `profileMode=${profileMode}`,
-          `msgSender=${msgSender?.toString() ?? 'undefined'}`,
-        );
+        throw this.#contextualizeError(err, inspect(txRequest), `profileMode=${profileMode}`);
       }
     });
   }
@@ -845,7 +843,6 @@ export class PXEService implements PXE {
           origin: txRequest.origin,
           functionSelector: txRequest.functionSelector,
           simulatePublic,
-          msgSender: overrides?.msgSender,
           chainId: txRequest.txContext.chainId,
           version: txRequest.txContext.version,
           authWitnesses: txRequest.authWitnesses.map(w => w.requestHash),
@@ -863,12 +860,9 @@ export class PXEService implements PXE {
         // will fail. Consider handing control to the user/wallet on whether they want to run them
         // or not.
         const skipKernels = overrides?.contracts !== undefined && Object.keys(overrides.contracts ?? {}).length > 0;
-        const privateExecutionResult = await this.#executePrivate(
-          contractFunctionSimulator,
-          txRequest,
-          overrides?.msgSender,
-          scopes,
-        );
+
+        // Execution of private functions only; no proving, and no kernel logic.
+        const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, scopes);
 
         let publicInputs: PrivateKernelTailCircuitPublicInputs | undefined;
         let executionSteps: PrivateExecutionStep[] = [];
@@ -886,6 +880,7 @@ export class PXEService implements PXE {
             this.contractDataProvider,
           ));
         } else {
+          // Kernel logic, plus proving of all private functions and kernels.
           ({ publicInputs, executionSteps } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
             simulate: true,
             skipFeeEnforcement,
@@ -894,7 +889,7 @@ export class PXEService implements PXE {
         }
 
         const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
-        const simulatedTx = privateSimulationResult.toSimulatedTx();
+        const simulatedTx = await privateSimulationResult.toSimulatedTx();
         let publicSimulationTime: number | undefined;
         let publicOutput: PublicSimulationOutput | undefined;
         if (simulatePublic && publicInputs.forPublic) {
@@ -904,7 +899,7 @@ export class PXEService implements PXE {
         }
 
         let validationTime: number | undefined;
-        if (!skipTxValidation && !skipKernels) {
+        if (!skipTxValidation) {
           const validationTimer = new Timer();
           const validationResult = await this.node.isValidTx(simulatedTx, { isSimulation: true, skipFeeEnforcement });
           validationTime = validationTimer.ms();
@@ -913,7 +908,7 @@ export class PXEService implements PXE {
           }
         }
 
-        const txHash = await simulatedTx.getTxHash();
+        const txHash = simulatedTx.getTxHash();
 
         const totalTime = totalTimer.ms();
 
@@ -959,7 +954,6 @@ export class PXEService implements PXE {
           err,
           inspect(txRequest),
           `simulatePublic=${simulatePublic}`,
-          `msgSender=${overrides?.msgSender?.toString() ?? 'undefined'}`,
           `skipTxValidation=${skipTxValidation}`,
           `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
         );
@@ -968,7 +962,7 @@ export class PXEService implements PXE {
   }
 
   public async sendTx(tx: Tx): Promise<TxHash> {
-    const txHash = await tx.getTxHash();
+    const txHash = tx.getTxHash();
     if (await this.node.getTxEffect(txHash)) {
       throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
     }
@@ -1065,9 +1059,9 @@ export class PXEService implements PXE {
     return Promise.resolve({
       pxeVersion: this.packageVersion,
       protocolContractAddresses: {
-        classRegisterer: ProtocolContractAddress.ContractClassRegisterer,
+        classRegistry: ProtocolContractAddress.ContractClassRegistry,
         feeJuice: ProtocolContractAddress.FeeJuice,
-        instanceDeployer: ProtocolContractAddress.ContractInstanceDeployer,
+        instanceRegistry: ProtocolContractAddress.ContractInstanceRegistry,
         multiCallEntrypoint: ProtocolContractAddress.MultiCallEntrypoint,
       },
     });
@@ -1134,4 +1128,8 @@ export class PXEService implements PXE {
   async resetNoteSyncData() {
     return await this.taggingDataProvider.resetNoteSyncData();
   }
+
+  public stop(): Promise<void> {
+    return this.jobQueue.end();
+  }
 }

package/src/storage/capsule_data_provider/capsule_data_provider.ts

@@ -29,7 +29,7 @@ export class CapsuleDataProvider implements DataProvider {
   async loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
     const dataBuffer = await this.#capsules.getAsync(dbSlotToKey(contractAddress, slot));
     if (!dataBuffer) {
-      this.logger.debug(`Data not found for contract ${contractAddress.toString()} and slot ${slot.toString()}`);
+      this.logger.trace(`Data not found for contract ${contractAddress.toString()} and slot ${slot.toString()}`);
       return null;
     }
     const capsule: Fr[] = [];

package/src/storage/note_data_provider/note_data_provider.ts

@@ -202,19 +202,17 @@ export class NoteDataProvider implements DataProvider {
             ? await toArray(
                 this.#notesByTxHashAndScope.get(formattedScopeString)!.getValuesAsync(filter.txHash.toString()),
               )
-            : filter.contractAddress
+            : filter.storageSlot
               ? await toArray(
+                  this.#notesByStorageSlotAndScope
+                    .get(formattedScopeString)!
+                    .getValuesAsync(filter.storageSlot.toString()),
+                )
+              : 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()),
+                ),
       );
     }
 
@@ -229,11 +227,9 @@ export class NoteDataProvider implements DataProvider {
           ? 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()),
+            : filter.storageSlot
+              ? await toArray(this.#nullifiedNotesByStorageSlot.getValuesAsync(filter.storageSlot.toString()))
+              : await toArray(this.#nullifiedNotesByContract.getValuesAsync(filter.contractAddress.toString())),
         notes: this.#nullifiedNotes,
       });
     }
@@ -247,7 +243,7 @@ export class NoteDataProvider implements DataProvider {
         }
 
         const note = NoteDao.fromBuffer(serializedNote);
-        if (filter.contractAddress && !note.contractAddress.equals(filter.contractAddress)) {
+        if (!note.contractAddress.equals(filter.contractAddress)) {
           continue;
         }
 
@@ -334,6 +330,21 @@ export class NoteDataProvider implements DataProvider {
   }
 
   async getSize() {
-    return (await this.getNotes({})).reduce((sum, note) => sum + note.getSize(), 0);
+    const scopes = await toArray(this.#scopes.keysAsync());
+    const contractAddresses = new Set<string>();
+
+    // Collect all unique contract addresses across all scopes
+    for (const scope of scopes) {
+      const addresses = await toArray(this.#notesByContractAndScope.get(scope)!.keysAsync());
+      addresses.forEach(addr => contractAddresses.add(addr));
+    }
+
+    // Get all notes for each contract address
+    const allNotes = await Promise.all(
+      Array.from(contractAddresses).map(addr => this.getNotes({ contractAddress: AztecAddress.fromString(addr) })),
+    );
+
+    // Reduce all notes to get total size
+    return allNotes.flat().reduce((sum, note) => sum + note.getSize(), 0);
   }
 }