@aztec/pxe 0.41.0 → 0.42.0

package/src/kernel_prover/private_inputs_builders/build_private_kernel_tail_hints.ts

@@ -3,13 +3,14 @@ import {
   MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   MAX_UNENCRYPTED_LOGS_PER_TX,
   type PrivateKernelCircuitPublicInputs,
   PrivateKernelTailHints,
   sortByCounterGetSortedHints,
 } from '@aztec/circuits.js';
 
-export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPublicInputs) {
+export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPublicInputs): PrivateKernelTailHints {
   const [sortedNoteHashes, sortedNoteHashesIndexes] = sortByCounterGetSortedHints(
     publicInputs.end.newNoteHashes,
     MAX_NEW_NOTE_HASHES_PER_TX,
@@ -35,6 +36,15 @@ export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPu
     MAX_UNENCRYPTED_LOGS_PER_TX,
   );
 
+  const [sortedCallRequests, sortedCallRequestsIndexes] = sortByCounterGetSortedHints(
+    publicInputs.end.publicCallStack,
+    MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+    {
+      ascending: false,
+      hintIndexesBy: 'sorted',
+    },
+  );
+
   return new PrivateKernelTailHints(
     sortedNoteHashes,
     sortedNoteHashesIndexes,
@@ -46,5 +56,7 @@ export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPu
     sortedEncryptedLogHashesIndexes,
     sortedUnencryptedLogHashes,
     sortedUnencryptedLogHashesIndexes,
+    sortedCallRequests,
+    sortedCallRequestsIndexes,
   );
 }

package/src/kernel_prover/proving_data_oracle.ts

@@ -4,7 +4,6 @@ import {
   type Fr,
   type FunctionSelector,
   type GrumpkinPrivateKey,
-  type KeyGenerator,
   type MembershipWitness,
   type NOTE_HASH_TREE_HEIGHT,
   type Point,
@@ -71,13 +70,13 @@ export interface ProvingDataOracle {
   getNoteHashTreeRoot(): Promise<Fr>;
 
   /**
-   * Retrieves the sk_m for the pk_m and a generator index of the key type.
+   * Retrieves the sk_m corresponding to the pk_m.
    * @throws If the provided public key is not associated with any of the registered accounts.
-   * @param masterPublicKey - The master public key to get secret key for.
-   * @returns A Promise that resolves to sk_m and the corresponding app key generator.
+   * @param pkM - The master public key to get secret key for.
+   * @returns A Promise that resolves to sk_m.
    * @dev Used when feeding the sk_m to the kernel circuit for keys verification.
    */
-  getMasterSecretKeyAndAppKeyGenerator(masterPublicKey: Point): Promise<[GrumpkinPrivateKey, KeyGenerator]>;
+  getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinPrivateKey>;
 
-  getFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 }

package/src/note_processor/note_processor.ts

@@ -1,6 +1,6 @@
 import {
   type AztecNode,
-  type EncryptedL2BlockL2Logs,
+  type EncryptedNoteL2BlockL2Logs,
   L1NotePayload,
   type L2Block,
   TaggedNote,
@@ -88,7 +88,7 @@ export class NoteProcessor {
    * @param encryptedL2BlockLogs - Encrypted logs associated with the L2 blocks.
    * @returns A promise that resolves once the processing is completed.
    */
-  public async process(l2Blocks: L2Block[], encryptedL2BlockLogs: EncryptedL2BlockL2Logs[]): Promise<void> {
+  public async process(l2Blocks: L2Block[], encryptedL2BlockLogs: EncryptedNoteL2BlockL2Logs[]): Promise<void> {
     if (l2Blocks.length !== encryptedL2BlockLogs.length) {
       throw new Error(
         `Number of blocks and EncryptedLogs is not equal. Received ${l2Blocks.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`,

package/src/pxe_http/pxe_http_server.ts

@@ -1,7 +1,7 @@
 import {
   AuthWitness,
   CompleteAddress,
-  EncryptedL2BlockL2Logs,
+  EncryptedNoteL2BlockL2Logs,
   ExtendedNote,
   ExtendedUnencryptedL2Log,
   L2Block,
@@ -50,7 +50,7 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
       TxEffect,
       LogId,
     },
-    { SimulatedTx, Tx, TxReceipt, EncryptedL2BlockL2Logs, UnencryptedL2BlockL2Logs, NullifierMembershipWitness },
+    { SimulatedTx, Tx, TxReceipt, EncryptedNoteL2BlockL2Logs, UnencryptedL2BlockL2Logs, NullifierMembershipWitness },
     ['start', 'stop'],
   );
 }

package/src/pxe_service/create_pxe_service.ts

@@ -65,7 +65,7 @@ export async function createPXEService(
     getCanonicalClassRegisterer(),
     getCanonicalInstanceDeployer(),
     getCanonicalMultiCallEntrypointContract(),
-    getCanonicalGasToken(l1Contracts.gasPortalAddress),
+    getCanonicalGasToken(),
     getCanonicalKeyRegistry(),
   ]) {
     await server.registerContract(contract);

package/src/pxe_service/pxe_service.ts

@@ -1,6 +1,7 @@
 import {
   type AuthWitness,
   type AztecNode,
+  EncryptedNoteTxL2Logs,
   EncryptedTxL2Logs,
   ExtendedNote,
   type FunctionCall,
@@ -10,6 +11,7 @@ import {
   MerkleTreeId,
   type NoteFilter,
   type PXE,
+  type PXEInfo,
   type ProofCreator,
   SimulatedTx,
   SimulationError,
@@ -21,27 +23,24 @@ import {
   UnencryptedTxL2Logs,
   isNoirCallStackUnresolved,
 } from '@aztec/circuit-types';
-import { type TxPXEProcessingStats } from '@aztec/circuit-types/stats';
 import {
   AztecAddress,
-  CallRequest,
   type CompleteAddress,
-  FunctionData,
-  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   type PartialAddress,
-  type PrivateKernelTailCircuitPublicInputs,
-  type PublicCallRequest,
   computeContractClassId,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
 import { type ContractArtifact, type DecodedReturn, FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
-import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
 import { type Fq, Fr } from '@aztec/foundation/fields';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
 import { type KeyStore } from '@aztec/key-store';
+import { getCanonicalClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
+import { getCanonicalGasToken } from '@aztec/protocol-contracts/gas-token';
+import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
+import { getCanonicalKeyRegistryAddress } from '@aztec/protocol-contracts/key-registry';
+import { getCanonicalMultiCallEntrypointAddress } from '@aztec/protocol-contracts/multi-call-entrypoint';
 import {
   type AcirSimulator,
   type ExecutionResult,
@@ -73,7 +72,7 @@ export class PXEService implements PXE {
   private contractDataOracle: ContractDataOracle;
   private simulator: AcirSimulator;
   private log: DebugLogger;
-  private nodeVersion: string;
+  private packageVersion: string;
   // serialize synchronizer and calls to proveTx.
   // ensures that state is not changed while simulating
   private jobQueue = new SerialQueue();
@@ -90,7 +89,7 @@ export class PXEService implements PXE {
     this.synchronizer = new Synchronizer(node, db, this.jobQueue, logSuffix);
     this.contractDataOracle = new ContractDataOracle(db);
     this.simulator = getAcirSimulator(db, node, keyStore, this.contractDataOracle);
-    this.nodeVersion = getPackageInfo().version;
+    this.packageVersion = getPackageInfo().version;
 
     this.jobQueue.start();
   }
@@ -426,25 +425,13 @@ export class PXEService implements PXE {
     simulatePublic: boolean,
     msgSender: AztecAddress | undefined = undefined,
   ): Promise<SimulatedTx> {
-    if (!txRequest.functionData.isPrivate) {
-      throw new Error(`Public entrypoints are not allowed`);
-    }
     return await this.jobQueue.put(async () => {
-      const timer = new Timer();
       const simulatedTx = await this.#simulateAndProve(txRequest, msgSender);
       // 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.debug(`Processed private part of ${simulatedTx.tx.getTxHash()}`, {
-          eventName: 'tx-pxe-processing',
-          duration: timer.ms(),
-          ...simulatedTx.tx.getStats(),
-        } satisfies TxPXEProcessingStats);
-      }
-
       if (simulatePublic) {
         simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
       }
@@ -518,29 +505,49 @@ export class PXEService implements PXE {
     }
 
     return {
+      name: functionDao.name,
       args: encodeArguments(functionDao, args),
-      functionData: FunctionData.fromAbi(functionDao),
+      selector: FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
+      type: functionDao.functionType,
       to,
       isStatic: functionDao.isStatic,
+      returnTypes: functionDao.returnTypes,
     };
   }
 
   public async getNodeInfo(): Promise<NodeInfo> {
-    const [version, chainId, contractAddresses] = await Promise.all([
+    const [nodeVersion, protocolVersion, chainId, contractAddresses, protocolContractAddresses] = await Promise.all([
+      this.node.getNodeVersion(),
       this.node.getVersion(),
       this.node.getChainId(),
       this.node.getL1ContractAddresses(),
+      this.node.getProtocolContractAddresses(),
     ]);
 
     const nodeInfo: NodeInfo = {
-      nodeVersion: this.nodeVersion,
+      nodeVersion,
       chainId,
-      protocolVersion: version,
+      protocolVersion,
       l1ContractAddresses: contractAddresses,
+      protocolContractAddresses: protocolContractAddresses,
     };
+
     return nodeInfo;
   }
 
+  public getPXEInfo(): Promise<PXEInfo> {
+    return Promise.resolve({
+      pxeVersion: this.packageVersion,
+      protocolContractAddresses: {
+        classRegisterer: getCanonicalClassRegistererAddress(),
+        gasToken: getCanonicalGasToken().address,
+        instanceDeployer: getCanonicalInstanceDeployer().address,
+        keyRegistry: getCanonicalKeyRegistryAddress(),
+        multiCallEntrypoint: getCanonicalMultiCallEntrypointAddress(),
+      },
+    });
+  }
+
   /**
    * Retrieves the simulation parameters required to run an ACIR simulation.
    * This includes the contract address, function artifact, and historical tree roots.
@@ -550,14 +557,10 @@ export class PXEService implements PXE {
    */
   async #getSimulationParameters(execRequest: FunctionCall | TxExecutionRequest) {
     const contractAddress = (execRequest as FunctionCall).to ?? (execRequest as TxExecutionRequest).origin;
-    const functionArtifact = await this.contractDataOracle.getFunctionArtifact(
-      contractAddress,
-      execRequest.functionData.selector,
-    );
-    const debug = await this.contractDataOracle.getFunctionDebugMetadata(
-      contractAddress,
-      execRequest.functionData.selector,
-    );
+    const functionSelector =
+      (execRequest as FunctionCall).selector ?? (execRequest as TxExecutionRequest).functionSelector;
+    const functionArtifact = await this.contractDataOracle.getFunctionArtifact(contractAddress, functionSelector);
+    const debug = await this.contractDataOracle.getFunctionDebugMetadata(contractAddress, functionSelector);
 
     return {
       contractAddress,
@@ -664,16 +667,12 @@ export class PXEService implements PXE {
     this.log.debug(`Executing kernel prover...`);
     const { proof, publicInputs } = await kernelProver.prove(txExecutionRequest.toTxRequest(), executionResult);
 
-    const noteEncryptedLogs = new EncryptedTxL2Logs([collectSortedNoteEncryptedLogs(executionResult)]);
+    const noteEncryptedLogs = new EncryptedNoteTxL2Logs([collectSortedNoteEncryptedLogs(executionResult)]);
     const unencryptedLogs = new UnencryptedTxL2Logs([collectSortedUnencryptedLogs(executionResult)]);
     const encryptedLogs = new EncryptedTxL2Logs([collectSortedEncryptedLogs(executionResult)]);
     const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(executionResult);
     const teardownPublicFunction = collectPublicTeardownFunctionCall(executionResult);
 
-    // HACK(#1639): Manually patches the ordering of the public call stack
-    // TODO(#757): Enforce proper ordering of enqueued public calls
-    await this.patchPublicCallStackOrdering(publicInputs, enqueuedPublicFunctions);
-
     const tx = new Tx(
       publicInputs,
       proof.binaryProof,
@@ -724,76 +723,6 @@ export class PXEService implements PXE {
     );
   }
 
-  // HACK(#1639): this is a hack to fix ordering of public calls enqueued in the call stack. Since the private kernel
-  // cannot keep track of side effects that happen after or before a nested call, we override the public call stack
-  // it emits with whatever we got from the simulator collected enqueued calls. As a sanity check, we at least verify
-  // that the elements are the same, so we are only tweaking their ordering.
-  // See yarn-project/end-to-end/src/e2e_ordering.test.ts
-  // See https://github.com/AztecProtocol/aztec-packages/issues/1615
-  // TODO(#757): Enforce proper ordering of enqueued public calls
-  private async patchPublicCallStackOrdering(
-    publicInputs: PrivateKernelTailCircuitPublicInputs,
-    enqueuedPublicCalls: PublicCallRequest[],
-  ) {
-    if (!publicInputs.forPublic) {
-      return;
-    }
-
-    const enqueuedPublicCallStackItems = await Promise.all(enqueuedPublicCalls.map(c => c.toCallRequest()));
-
-    // Validate all items in enqueued public calls are in the kernel emitted stack
-    const enqueuedRevertiblePublicCallStackItems = enqueuedPublicCallStackItems.filter(enqueued =>
-      publicInputs.forPublic!.end.publicCallStack.find(item => item.equals(enqueued)),
-    );
-
-    const revertibleStackSize = arrayNonEmptyLength(publicInputs.forPublic.end.publicCallStack, item => item.isEmpty());
-
-    if (enqueuedRevertiblePublicCallStackItems.length !== revertibleStackSize) {
-      throw new Error(
-        `Enqueued revertible public function calls and revertible public call stack do not match.\nEnqueued calls: ${enqueuedRevertiblePublicCallStackItems
-          .map(h => h.hash.toString())
-          .join(', ')}\nPublic call stack: ${publicInputs.forPublic.end.publicCallStack
-          .map(i => i.toString())
-          .join(', ')}`,
-      );
-    }
-
-    // Override kernel output
-    publicInputs.forPublic.end.publicCallStack = padArrayEnd(
-      enqueuedRevertiblePublicCallStackItems,
-      CallRequest.empty(),
-      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-    );
-
-    // Do the same for non-revertible
-
-    const enqueuedNonRevertiblePublicCallStackItems = enqueuedPublicCallStackItems.filter(enqueued =>
-      publicInputs.forPublic!.endNonRevertibleData.publicCallStack.find(item => item.equals(enqueued)),
-    );
-
-    const nonRevertibleStackSize = arrayNonEmptyLength(
-      publicInputs.forPublic.endNonRevertibleData.publicCallStack,
-      item => item.isEmpty(),
-    );
-
-    if (enqueuedNonRevertiblePublicCallStackItems.length !== nonRevertibleStackSize) {
-      throw new Error(
-        `Enqueued non-revertible public function calls and non-revertible public call stack do not match.\nEnqueued calls: ${enqueuedNonRevertiblePublicCallStackItems
-          .map(h => h.hash.toString())
-          .join(', ')}\nPublic call stack: ${publicInputs.forPublic.endNonRevertibleData.publicCallStack
-          .map(i => i.toString())
-          .join(', ')}`,
-      );
-    }
-
-    // Override kernel output
-    publicInputs.forPublic.endNonRevertibleData.publicCallStack = padArrayEnd(
-      enqueuedNonRevertiblePublicCallStackItems,
-      CallRequest.empty(),
-      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-    );
-  }
-
   public async isGlobalStateSynchronized() {
     return await this.synchronizer.isGlobalStateSynchronized();
   }
@@ -806,6 +735,10 @@ export class PXEService implements PXE {
     return Promise.resolve(this.synchronizer.getSyncStatus());
   }
 
+  public getSyncStats() {
+    return Promise.resolve(this.synchronizer.getSyncStats());
+  }
+
   public async isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
     return !!(await this.node.getContractClass(id));
   }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -1,6 +1,5 @@
 import {
   type PXE,
-  TxExecutionRequest,
   randomContractArtifact,
   randomContractInstanceWithAddress,
   randomDeployedContract,
@@ -9,11 +8,9 @@ import {
   AztecAddress,
   CompleteAddress,
   Fr,
-  FunctionData,
   INITIAL_L2_BLOCK_NUM,
   Point,
   PublicKeys,
-  TxContext,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 
@@ -126,23 +123,6 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       await expect(pxe.registerContract({ instance, artifact })).rejects.toThrow(/Artifact does not match/i);
     });
 
-    it('throws when simulating a tx targeting public entrypoint', async () => {
-      const functionData = FunctionData.empty();
-      functionData.isPrivate = false;
-      const txExecutionRequest = TxExecutionRequest.from({
-        origin: AztecAddress.random(),
-        firstCallArgsHash: new Fr(0),
-        functionData,
-        txContext: TxContext.empty(),
-        argsOfCalls: [],
-        authWitnesses: [],
-      });
-
-      await expect(async () => await pxe.proveTx(txExecutionRequest, false)).rejects.toThrow(
-        'Public entrypoints are not allowed',
-      );
-    });
-
     // Note: Not testing a successful run of `proveTx`, `sendTx`, `getTxReceipt` and `simulateUnconstrained` here as it requires
     //       a larger setup and it's sufficiently tested in the e2e tests.
 

package/src/simulator_oracle/index.ts

@@ -230,4 +230,8 @@ export class SimulatorOracle implements DBOracle {
   public async getBlockNumber(): Promise<number> {
     return await this.aztecNode.getBlockNumber();
   }
+
+  public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string> {
+    return this.contractDataOracle.getDebugFunctionName(contractAddress, selector);
+  }
 }

package/src/synchronizer/synchronizer.ts

@@ -110,6 +110,7 @@ export class Synchronizer {
         `Forwarding ${logCount} encrypted logs and blocks to ${this.noteProcessors.length} note processors`,
       );
       for (const noteProcessor of this.noteProcessors) {
+        // TODO(#6830): pass in only the blocks
         await noteProcessor.process(blocks, noteEncryptedLogs);
       }
       return true;
@@ -319,6 +320,14 @@ export class Synchronizer {
     };
   }
 
+  /**
+   * Returns the note processor stats.
+   * @returns The note processor stats for notes for each public key being tracked.
+   */
+  public getSyncStats() {
+    return Object.fromEntries(this.noteProcessors.map(n => [n.masterIncomingViewingPublicKey.toString(), n.stats]));
+  }
+
   /**
    * Retry decoding any deferred notes for the specified contract address.
    * @param contractAddress - the contract address that has just been added