@aztec/pxe 0.32.1 → 0.33.0

package/src/kernel_prover/kernel_prover.ts

@@ -1,5 +1,4 @@
 import {
-  type AztecAddress,
   CallRequest,
   Fr,
   type MAX_NEW_NOTE_HASHES_PER_TX,
@@ -9,10 +8,10 @@ import {
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
   NoteHashReadRequestMembershipWitness,
   PrivateCallData,
+  PrivateKernelCircuitPublicInputs,
+  PrivateKernelData,
   PrivateKernelInitCircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
-  PrivateKernelInnerCircuitPublicInputs,
-  PrivateKernelInnerData,
   PrivateKernelTailCircuitPrivateInputs,
   type SideEffect,
   type SideEffectLinkedToNoteHash,
@@ -26,43 +25,12 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { assertLength, mapTuple } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
-import { type ExecutionResult, type NoteAndSlot } from '@aztec/simulator';
+import { type ExecutionResult } from '@aztec/simulator';
 
 import { HintsBuilder } from './hints_builder.js';
 import { KernelProofCreator, type ProofCreator, type ProofOutput, type ProofOutputFinal } from './proof_creator.js';
 import { type ProvingDataOracle } from './proving_data_oracle.js';
 
-/**
- * Represents an output note data object.
- * Contains the contract address, new note data and commitment for the note,
- * resulting from the execution of a transaction in the Aztec network.
- */
-export interface OutputNoteData {
-  /**
-   * The address of the contract the note was created in.
-   */
-  contractAddress: AztecAddress;
-  /**
-   * The encrypted note data for an output note.
-   */
-  data: NoteAndSlot;
-  /**
-   * The unique value representing the note.
-   */
-  commitment: Fr;
-}
-
-/**
- * Represents the output data of the Kernel Prover.
- * Provides information about the newly created notes, along with the public inputs and proof.
- */
-export interface KernelProverOutput extends ProofOutputFinal {
-  /**
-   * An array of output notes containing the contract address, note data, and commitment for each new note.
-   */
-  outputNotes: OutputNoteData[];
-}
-
 /**
  * The KernelProver class is responsible for generating kernel proofs.
  * It takes a transaction request, its signature, and the simulation result as inputs, and outputs a proof
@@ -87,14 +55,13 @@ export class KernelProver {
    * @param executionResult - The execution result object containing nested executions and preimages.
    * @returns A Promise that resolves to a KernelProverOutput object containing proof, public inputs, and output notes.
    */
-  async prove(txRequest: TxRequest, executionResult: ExecutionResult): Promise<KernelProverOutput> {
+  async prove(txRequest: TxRequest, executionResult: ExecutionResult): Promise<ProofOutputFinal> {
     const executionStack = [executionResult];
-    const newNotes: { [commitmentStr: string]: OutputNoteData } = {};
     let firstIteration = true;
     let previousVerificationKey = VerificationKey.makeFake();
 
     let output: ProofOutput = {
-      publicInputs: PrivateKernelInnerCircuitPublicInputs.empty(),
+      publicInputs: PrivateKernelCircuitPublicInputs.empty(),
       proof: makeEmptyProof(),
     };
 
@@ -147,7 +114,7 @@ export class KernelProver {
         output = await this.proofCreator.createProofInit(proofInput);
       } else {
         const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(previousVerificationKey);
-        const previousKernelData = new PrivateKernelInnerData(
+        const previousKernelData = new PrivateKernelData(
           output.publicInputs,
           output.proof,
           previousVerificationKey,
@@ -158,15 +125,12 @@ export class KernelProver {
         pushTestData('private-kernel-inputs-inner', proofInput);
         output = await this.proofCreator.createProofInner(proofInput);
       }
-      (await this.getNewNotes(currentExecution)).forEach(n => {
-        newNotes[n.commitment.toString()] = n;
-      });
       firstIteration = false;
       previousVerificationKey = privateCallData.vk;
     }
 
     const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(previousVerificationKey);
-    const previousKernelData = new PrivateKernelInnerData(
+    const previousKernelData = new PrivateKernelData(
       output.publicInputs,
       output.proof,
       previousVerificationKey,
@@ -174,6 +138,20 @@ export class KernelProver {
       assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
     );
 
+    const readNoteHashHints = this.hintsBuilder.getNoteHashReadRequestHints(
+      output.publicInputs.validationRequests.noteHashReadRequests,
+      output.publicInputs.end.newNoteHashes,
+    );
+
+    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
+      output.publicInputs.validationRequests.nullifierReadRequests,
+      output.publicInputs.end.newNullifiers,
+    );
+
+    const masterNullifierSecretKeys = await this.hintsBuilder.getMasterNullifierSecretKeys(
+      output.publicInputs.validationRequests.nullifierKeyValidationRequests,
+    );
+
     const [sortedNoteHashes, sortedNoteHashesIndexes] = this.hintsBuilder.sortSideEffects<
       SideEffect,
       typeof MAX_NEW_NOTE_HASHES_PER_TX
@@ -184,25 +162,11 @@ export class KernelProver {
       typeof MAX_NEW_NULLIFIERS_PER_TX
     >(output.publicInputs.end.newNullifiers);
 
-    const readNoteHashHints = this.hintsBuilder.getNoteHashReadRequestHints(
-      output.publicInputs.validationRequests.noteHashReadRequests,
-      sortedNoteHashes,
-    );
-
-    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
-      output.publicInputs.validationRequests.nullifierReadRequests,
-      output.publicInputs.end.newNullifiers,
-    );
-
     const nullifierNoteHashHints = this.hintsBuilder.getNullifierHints(
       mapTuple(sortedNullifiers, n => n.noteHash),
       sortedNoteHashes,
     );
 
-    const masterNullifierSecretKeys = await this.hintsBuilder.getMasterNullifierSecretKeys(
-      output.publicInputs.validationRequests.nullifierKeyValidationRequests,
-    );
-
     this.log.debug(
       `Calling private kernel tail with hwm ${previousKernelData.publicInputs.minRevertibleSideEffectCounter}`,
     );
@@ -219,13 +183,7 @@ export class KernelProver {
       masterNullifierSecretKeys,
     );
     pushTestData('private-kernel-inputs-ordering', privateInputs);
-    const outputFinal = await this.proofCreator.createProofTail(privateInputs);
-
-    // Only return the notes whose commitment is in the commitments of the final proof.
-    const finalNewCommitments = outputFinal.publicInputs.end.newNoteHashes;
-    const outputNotes = finalNewCommitments.map(c => newNotes[c.value.toString()]).filter(c => !!c);
-
-    return { ...outputFinal, outputNotes };
+    return await this.proofCreator.createProofTail(privateInputs);
   }
 
   private async createPrivateCallData(
@@ -282,28 +240,4 @@ export class KernelProver {
       acirHash,
     });
   }
-
-  /**
-   * Retrieves the new output notes for a given execution result.
-   * The function maps over the new notes and associates them with their corresponding
-   * commitments in the public inputs of the execution result. It also includes the contract address
-   * from the call context of the public inputs.
-   *
-   * @param executionResult - The execution result object containing notes and public inputs.
-   * @returns An array of OutputNoteData objects, each representing an output note with its associated data.
-   */
-  private async getNewNotes(executionResult: ExecutionResult): Promise<OutputNoteData[]> {
-    const {
-      callStackItem: { publicInputs },
-      newNotes,
-    } = executionResult;
-    const contractAddress = publicInputs.callContext.storageContractAddress;
-    // Assuming that for each new commitment there's an output note added to the execution result.
-    const newNoteHashes = await this.proofCreator.getSiloedCommitments(publicInputs);
-    return newNotes.map((data, i) => ({
-      contractAddress,
-      data,
-      commitment: newNoteHashes[i],
-    }));
-  }
 }

package/src/kernel_prover/proof_creator.ts

@@ -1,9 +1,9 @@
 import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
   type PrivateCircuitPublicInputs,
+  type PrivateKernelCircuitPublicInputs,
   type PrivateKernelInitCircuitPrivateInputs,
   type PrivateKernelInnerCircuitPrivateInputs,
-  type PrivateKernelInnerCircuitPublicInputs,
   type PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
   type Proof,
@@ -13,7 +13,7 @@ import { siloNoteHash } from '@aztec/circuits.js/hash';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
-import { executeInit, executeInner, executeTail } from '@aztec/noir-protocol-circuits-types';
+import { executeInit, executeInner, executeTail, executeTailForPublic } from '@aztec/noir-protocol-circuits-types';
 
 /**
  * Represents the output of the proof creation process for init and inner private kernel circuit.
@@ -23,7 +23,7 @@ export interface ProofOutput {
   /**
    * The public inputs required for the proof generation process.
    */
-  publicInputs: PrivateKernelInnerCircuitPublicInputs;
+  publicInputs: PrivateKernelCircuitPublicInputs;
   /**
    * The zk-SNARK proof for the kernel execution.
    */
@@ -138,7 +138,10 @@ export class KernelProofCreator implements ProofCreator {
   }
 
   public async createProofTail(privateInputs: PrivateKernelTailCircuitPrivateInputs): Promise<ProofOutputFinal> {
-    const [duration, result] = await elapsed(() => executeTail(privateInputs));
+    const isForPublic = privateInputs.isForPublic();
+    const [duration, result] = await elapsed(() =>
+      isForPublic ? executeTailForPublic(privateInputs) : executeTail(privateInputs),
+    );
     this.log(`Simulated private kernel ordering`, {
       eventName: 'circuit-simulation',
       circuitName: 'private-kernel-ordering',

package/src/note_processor/note_processor.ts

@@ -3,7 +3,7 @@ import {
   type EncryptedL2BlockL2Logs,
   type KeyStore,
   L1NotePayload,
-  type L2BlockContext,
+  type L2Block,
   TaggedNote,
 } from '@aztec/circuit-types';
 import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
@@ -25,9 +25,9 @@ import { produceNoteDao } from './produce_note_dao.js';
  */
 interface ProcessedData {
   /**
-   * Holds L2 block and a cache of already requested tx hashes.
+   * Holds L2 block.
    */
-  blockContext: L2BlockContext;
+  block: L2Block;
   /**
    * DAOs of processed notes.
    */
@@ -82,25 +82,20 @@ export class NoteProcessor {
   }
 
   /**
-   * Process the given L2 block contexts and encrypted logs to update the note processor.
-   * It synchronizes the user's account by decrypting the encrypted logs and processing
-   * the transactions and auxiliary data associated with them.
-   * Throws an error if the number of block contexts and encrypted logs do not match.
+   * Extracts new user-relevant notes from the information contained in the provided L2 blocks and encrypted logs.
    *
-   * @param l2BlockContexts - An array of L2 block contexts to be processed.
-   * @param encryptedL2BlockLogs - An array of encrypted logs associated with the L2 block contexts.
+   * @throws If the number of blocks and encrypted logs do not match.
+   * @param l2Blocks - L2 blocks to be processed.
+   * @param encryptedL2BlockLogs - Encrypted logs associated with the L2 blocks.
    * @returns A promise that resolves once the processing is completed.
    */
-  public async process(
-    l2BlockContexts: L2BlockContext[],
-    encryptedL2BlockLogs: EncryptedL2BlockL2Logs[],
-  ): Promise<void> {
-    if (l2BlockContexts.length !== encryptedL2BlockLogs.length) {
+  public async process(l2Blocks: L2Block[], encryptedL2BlockLogs: EncryptedL2BlockL2Logs[]): Promise<void> {
+    if (l2Blocks.length !== encryptedL2BlockLogs.length) {
       throw new Error(
-        `Number of blocks and EncryptedLogs is not equal. Received ${l2BlockContexts.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`,
+        `Number of blocks and EncryptedLogs is not equal. Received ${l2Blocks.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`,
       );
     }
-    if (!l2BlockContexts.length) {
+    if (l2Blocks.length === 0) {
       return;
     }
 
@@ -113,9 +108,10 @@ export class NoteProcessor {
     for (let blockIndex = 0; blockIndex < encryptedL2BlockLogs.length; ++blockIndex) {
       this.stats.blocks++;
       const { txLogs } = encryptedL2BlockLogs[blockIndex];
-      const blockContext = l2BlockContexts[blockIndex];
-      const block = blockContext.block;
-      const dataEndIndexForBlock = block.header.state.partial.noteHashTree.nextAvailableLeafIndex;
+      const block = l2Blocks[blockIndex];
+      const dataStartIndexForBlock =
+        block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
+        block.body.numberOfTxsIncludingPadded * MAX_NEW_NOTE_HASHES_PER_TX;
 
       // We are using set for `userPertainingTxIndices` to avoid duplicates. This would happen in case there were
       // multiple encrypted logs in a tx pertaining to a user.
@@ -125,8 +121,7 @@ export class NoteProcessor {
       // Iterate over all the encrypted logs and try decrypting them. If successful, store the note.
       for (let indexOfTxInABlock = 0; indexOfTxInABlock < txLogs.length; ++indexOfTxInABlock) {
         this.stats.txs++;
-        const dataStartIndexForTx =
-          dataEndIndexForBlock - (txLogs.length - indexOfTxInABlock) * MAX_NEW_NOTE_HASHES_PER_TX;
+        const dataStartIndexForTx = dataStartIndexForBlock + indexOfTxInABlock * MAX_NEW_NOTE_HASHES_PER_TX;
         const newNoteHashes = block.body.txEffects[indexOfTxInABlock].noteHashes;
         // Note: Each tx generates a `TxL2Logs` object and for this reason we can rely on its index corresponding
         //       to the index of a tx in a block.
@@ -139,7 +134,7 @@ export class NoteProcessor {
             if (taggedNote?.notePayload) {
               const { notePayload: payload } = taggedNote;
               // We have successfully decrypted the data.
-              const txHash = blockContext.getTxHash(indexOfTxInABlock);
+              const txHash = block.body.txEffects[indexOfTxInABlock].txHash;
               try {
                 const noteDao = await produceNoteDao(
                   this.simulator,
@@ -178,7 +173,7 @@ export class NoteProcessor {
       }
 
       blocksAndNotes.push({
-        blockContext: l2BlockContexts[blockIndex],
+        block: l2Blocks[blockIndex],
         noteDaos,
       });
     }
@@ -186,7 +181,7 @@ export class NoteProcessor {
     await this.processBlocksAndNotes(blocksAndNotes);
     await this.processDeferredNotes(deferredNoteDaos);
 
-    const syncedToBlock = l2BlockContexts[l2BlockContexts.length - 1].block.number;
+    const syncedToBlock = l2Blocks[l2Blocks.length - 1].number;
     await this.db.setSynchedBlockNumberForPublicKey(this.publicKey, syncedToBlock);
 
     this.log(`Synched block ${syncedToBlock}`);
@@ -199,7 +194,7 @@ export class NoteProcessor {
    * transaction auxiliary data from the database. This function keeps track of new nullifiers
    * and ensures all other transactions are updated with newly settled block information.
    *
-   * @param blocksAndNotes - Array of objects containing L2BlockContexts, user-pertaining transaction indices, and NoteDaos.
+   * @param blocksAndNotes - Array of objects containing L2 blocks, user-pertaining transaction indices, and NoteDaos.
    */
   private async processBlocksAndNotes(blocksAndNotes: ProcessedData[]) {
     const noteDaos = blocksAndNotes.flatMap(b => b.noteDaos);
@@ -215,7 +210,7 @@ export class NoteProcessor {
     }
 
     const newNullifiers: Fr[] = blocksAndNotes.flatMap(b =>
-      b.blockContext.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
+      b.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
     );
     const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.publicKey);
     removedNotes.forEach(noteDao => {

package/src/pxe_http/pxe_http_server.ts

@@ -9,6 +9,7 @@ import {
   Note,
   NullifierMembershipWitness,
   type PXE,
+  SimulatedTx,
   Tx,
   TxEffect,
   TxExecutionRequest,
@@ -49,7 +50,7 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
       TxEffect,
       LogId,
     },
-    { Tx, TxReceipt, EncryptedL2BlockL2Logs, UnencryptedL2BlockL2Logs, NullifierMembershipWitness },
+    { SimulatedTx, Tx, TxReceipt, EncryptedL2BlockL2Logs, UnencryptedL2BlockL2Logs, NullifierMembershipWitness },
     ['start', 'stop'],
   );
 }

package/src/pxe_service/pxe_service.ts

@@ -11,6 +11,7 @@ import {
   MerkleTreeId,
   type NoteFilter,
   type PXE,
+  SimulatedTx,
   SimulationError,
   Tx,
   type TxEffect,
@@ -27,8 +28,7 @@ import {
   CompleteAddress,
   FunctionData,
   type GrumpkinPrivateKey,
-  MAX_NON_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  MAX_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   type PartialAddress,
   type PrivateKernelTailCircuitPublicInputs,
   type PublicCallRequest,
@@ -71,7 +71,7 @@ export class PXEService implements PXE {
   private simulator: AcirSimulator;
   private log: DebugLogger;
   private nodeVersion: string;
-  // serialize synchronizer and calls to simulateTx.
+  // serialize synchronizer and calls to proveTx.
   // ensures that state is not changed while simulating
   private jobQueue = new SerialQueue();
 
@@ -388,26 +388,43 @@ export class PXEService implements PXE {
     return await this.node.getBlock(blockNumber);
   }
 
-  public async simulateTx(txRequest: TxExecutionRequest, simulatePublic: boolean) {
+  public async proveTx(txRequest: TxExecutionRequest, simulatePublic: boolean) {
+    return (await this.simulateTx(txRequest, simulatePublic)).tx;
+  }
+
+  public async simulateTx(
+    txRequest: TxExecutionRequest,
+    simulatePublic: boolean,
+    msgSender: AztecAddress | undefined = undefined,
+  ) {
     if (!txRequest.functionData.isPrivate) {
       throw new Error(`Public entrypoints are not allowed`);
     }
-
-    // all simulations must be serialized w.r.t. the synchronizer
     return await this.jobQueue.put(async () => {
       const timer = new Timer();
-      const tx = await this.#simulateAndProve(txRequest);
-      this.log(`Processed private part of ${tx.getTxHash()}`, {
-        eventName: 'tx-pxe-processing',
-        duration: timer.ms(),
-        ...tx.getStats(),
-      } satisfies TxPXEProcessingStats);
+      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(`Processed private part of ${simulatedTx.tx.getTxHash()}`, {
+          eventName: 'tx-pxe-processing',
+          duration: timer.ms(),
+          ...simulatedTx.tx.getStats(),
+        } satisfies TxPXEProcessingStats);
+      }
+
       if (simulatePublic) {
-        await this.#simulatePublicCalls(tx);
+        // Only one transaction, so we can take index 0.
+        simulatedTx.publicReturnValues = (await this.#simulatePublicCalls(simulatedTx.tx))[0];
       }
-      this.log.info(`Executed local simulation for ${tx.getTxHash()}`);
 
-      return tx;
+      if (!msgSender) {
+        this.log.info(`Executed local simulation for ${simulatedTx.tx.getTxHash()}`);
+      }
+      return simulatedTx;
     });
   }
 
@@ -524,14 +541,14 @@ export class PXEService implements PXE {
     };
   }
 
-  async #simulate(txRequest: TxExecutionRequest): Promise<ExecutionResult> {
+  async #simulate(txRequest: TxExecutionRequest, msgSender?: AztecAddress): Promise<ExecutionResult> {
     // TODO - Pause syncing while simulating.
 
     const { contractAddress, functionArtifact, portalContract } = await this.#getSimulationParameters(txRequest);
 
     this.log('Executing simulator...');
     try {
-      const result = await this.simulator.run(txRequest, functionArtifact, contractAddress, portalContract);
+      const result = await this.simulator.run(txRequest, functionArtifact, contractAddress, portalContract, msgSender);
       this.log('Simulation completed!');
       return result;
     } catch (err) {
@@ -575,7 +592,7 @@ export class PXEService implements PXE {
    */
   async #simulatePublicCalls(tx: Tx) {
     try {
-      await this.node.simulatePublicCalls(tx);
+      return await this.node.simulatePublicCalls(tx);
     } catch (err) {
       // Try to fill in the noir call stack since the PXE may have access to the debug metadata
       if (err instanceof SimulationError) {
@@ -599,28 +616,26 @@ 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 and an ECDSA signature. It simulates the transaction,
-   * then generates a kernel proof using the simulation result. Finally, it creates a private
+   * 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.
    *
    * @param txExecutionRequest - The transaction request to be simulated and proved.
    * @param signature - The ECDSA signature for the transaction request.
-   * @returns A private transaction object containing the proof, public inputs, and encrypted logs.
+   * @param msgSender - (Optional) The message sender to use for the simulation.
+   * @returns An object tract contains:
+   * A private transaction object containing the proof, public inputs, and encrypted logs.
+   * The return values of the private execution
    */
-  async #simulateAndProve(txExecutionRequest: TxExecutionRequest) {
-    // TODO - Pause syncing while simulating.
-
+  async #simulateAndProve(txExecutionRequest: TxExecutionRequest, msgSender?: AztecAddress) {
     // Get values that allow us to reconstruct the block hash
-    const executionResult = await this.#simulate(txExecutionRequest);
+    const executionResult = await this.#simulate(txExecutionRequest, msgSender);
 
     const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node);
     const kernelProver = new KernelProver(kernelOracle);
     this.log(`Executing kernel prover...`);
     const { proof, publicInputs } = await kernelProver.prove(txExecutionRequest.toTxRequest(), executionResult);
-    this.log(
-      `Needs setup: ${publicInputs.needsSetup}, needs app logic: ${publicInputs.needsAppLogic}, needs teardown: ${publicInputs.needsTeardown}`,
-    );
 
     const encryptedLogs = new EncryptedTxL2Logs(collectEncryptedLogs(executionResult));
     const unencryptedLogs = new UnencryptedTxL2Logs(collectUnencryptedLogs(executionResult));
@@ -630,7 +645,8 @@ export class PXEService implements PXE {
     // TODO(#757): Enforce proper ordering of enqueued public calls
     await this.patchPublicCallStackOrdering(publicInputs, enqueuedPublicFunctions);
 
-    return new Tx(publicInputs, proof, encryptedLogs, unencryptedLogs, enqueuedPublicFunctions);
+    const tx = new Tx(publicInputs, proof, encryptedLogs, unencryptedLogs, enqueuedPublicFunctions);
+    return new SimulatedTx(tx, [executionResult.returnValues]);
   }
 
   /**
@@ -681,55 +697,62 @@ export class PXEService implements PXE {
     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.end.publicCallStack.find(item => item.equals(enqueued)),
+      publicInputs.forPublic!.end.publicCallStack.find(item => item.equals(enqueued)),
     );
 
-    const revertibleStackSize = arrayNonEmptyLength(publicInputs.end.publicCallStack, item => item.isEmpty());
+    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.end.publicCallStack.map(i => i.toString()).join(', ')}`,
+          .join(', ')}\nPublic call stack: ${publicInputs.forPublic.end.publicCallStack
+          .map(i => i.toString())
+          .join(', ')}`,
       );
     }
 
     // Override kernel output
-    publicInputs.end.publicCallStack = padArrayEnd(
+    publicInputs.forPublic.end.publicCallStack = padArrayEnd(
       enqueuedRevertiblePublicCallStackItems,
       CallRequest.empty(),
-      MAX_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
     );
 
     // Do the same for non-revertible
 
     const enqueuedNonRevertiblePublicCallStackItems = enqueuedPublicCallStackItems.filter(enqueued =>
-      publicInputs.endNonRevertibleData.publicCallStack.find(item => item.equals(enqueued)),
+      publicInputs.forPublic!.endNonRevertibleData.publicCallStack.find(item => item.equals(enqueued)),
     );
 
-    const nonRevertibleStackSize = arrayNonEmptyLength(publicInputs.endNonRevertibleData.publicCallStack, item =>
-      item.isEmpty(),
+    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.endNonRevertibleData.publicCallStack
+          .join(', ')}\nPublic call stack: ${publicInputs.forPublic.endNonRevertibleData.publicCallStack
           .map(i => i.toString())
           .join(', ')}`,
       );
     }
 
     // Override kernel output
-    publicInputs.endNonRevertibleData.publicCallStack = padArrayEnd(
+    publicInputs.forPublic.endNonRevertibleData.publicCallStack = padArrayEnd(
       enqueuedNonRevertiblePublicCallStackItems,
       CallRequest.empty(),
-      MAX_NON_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
     );
   }
 

package/src/pxe_service/test/pxe_test_suite.ts

@@ -135,12 +135,12 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
         authWitnesses: [],
       });
 
-      await expect(async () => await pxe.simulateTx(txExecutionRequest, false)).rejects.toThrow(
+      await expect(async () => await pxe.proveTx(txExecutionRequest, false)).rejects.toThrow(
         'Public entrypoints are not allowed',
       );
     });
 
-    // Note: Not testing a successful run of `simulateTx`, `sendTx`, `getTxReceipt` and `viewTx` here as it requires
+    // Note: Not testing a successful run of `proveTx`, `sendTx`, `getTxReceipt` and `viewTx` here as it requires
     //       a larger setup and it's sufficiently tested in the e2e tests.
 
     it('throws when getting public storage for non-existent contract', async () => {