@aztec/pxe 0.32.0 → 0.33.0

package/src/kernel_prover/proof_creator.ts

@@ -1,19 +1,19 @@
-import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
-  PrivateCircuitPublicInputs,
-  PrivateKernelInitCircuitPrivateInputs,
-  PrivateKernelInnerCircuitPrivateInputs,
-  PrivateKernelInnerCircuitPublicInputs,
-  PrivateKernelTailCircuitPrivateInputs,
-  PrivateKernelTailCircuitPublicInputs,
-  Proof,
+  type PrivateCircuitPublicInputs,
+  type PrivateKernelCircuitPublicInputs,
+  type PrivateKernelInitCircuitPrivateInputs,
+  type PrivateKernelInnerCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPublicInputs,
+  type Proof,
   makeEmptyProof,
 } from '@aztec/circuits.js';
 import { siloNoteHash } from '@aztec/circuits.js/hash';
-import { Fr } from '@aztec/foundation/fields';
+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/kernel_prover/proving_data_oracle.ts

@@ -1,16 +1,16 @@
-import { NullifierMembershipWitness } from '@aztec/circuit-types';
+import { type NullifierMembershipWitness } from '@aztec/circuit-types';
 import {
-  FUNCTION_TREE_HEIGHT,
-  Fr,
-  FunctionSelector,
-  GrumpkinPrivateKey,
-  MembershipWitness,
-  NOTE_HASH_TREE_HEIGHT,
-  Point,
-  VK_TREE_HEIGHT,
-  VerificationKey,
+  type FUNCTION_TREE_HEIGHT,
+  type Fr,
+  type FunctionSelector,
+  type GrumpkinPrivateKey,
+  type MembershipWitness,
+  type NOTE_HASH_TREE_HEIGHT,
+  type Point,
+  type VK_TREE_HEIGHT,
+  type VerificationKey,
 } from '@aztec/circuits.js';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { type AztecAddress } from '@aztec/foundation/aztec-address';
 
 /**
  * Provides functionality to fetch membership witnesses for verification keys,

package/src/note_processor/note_processor.ts

@@ -1,22 +1,22 @@
 import {
-  AztecNode,
-  EncryptedL2BlockL2Logs,
-  KeyStore,
+  type AztecNode,
+  type EncryptedL2BlockL2Logs,
+  type KeyStore,
   L1NotePayload,
-  L2BlockContext,
+  type L2Block,
   TaggedNote,
 } from '@aztec/circuit-types';
-import { NoteProcessorStats } from '@aztec/circuit-types/stats';
-import { INITIAL_L2_BLOCK_NUM, MAX_NEW_NOTE_HASHES_PER_TX, PublicKey } from '@aztec/circuits.js';
+import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
+import { INITIAL_L2_BLOCK_NUM, MAX_NEW_NOTE_HASHES_PER_TX, type PublicKey } from '@aztec/circuits.js';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
-import { Fr } from '@aztec/foundation/fields';
+import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ContractNotFoundError } from '@aztec/simulator';
 
 import { DeferredNoteDao } from '../database/deferred_note_dao.js';
-import { PxeDatabase } from '../database/index.js';
-import { NoteDao } from '../database/note_dao.js';
+import { type PxeDatabase } from '../database/index.js';
+import { type NoteDao } from '../database/note_dao.js';
 import { getAcirSimulator } from '../simulator/index.js';
 import { produceNoteDao } from './produce_note_dao.js';
 
@@ -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/note_processor/produce_note_dao.ts

@@ -1,7 +1,7 @@
-import { L1NotePayload, TxHash } from '@aztec/circuit-types';
-import { Fr, PublicKey } from '@aztec/circuits.js';
+import { type L1NotePayload, type TxHash } from '@aztec/circuit-types';
+import { Fr, type PublicKey } from '@aztec/circuits.js';
 import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/hash';
-import { AcirSimulator } from '@aztec/simulator';
+import { type AcirSimulator } from '@aztec/simulator';
 
 import { NoteDao } from '../database/note_dao.js';
 

package/src/pxe_http/pxe_http_server.ts

@@ -8,7 +8,8 @@ import {
   LogId,
   Note,
   NullifierMembershipWitness,
-  PXE,
+  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/create_pxe_service.ts

@@ -1,4 +1,4 @@
-import { AztecNode } from '@aztec/circuit-types';
+import { type AztecNode } from '@aztec/circuit-types';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { TestKeyStore } from '@aztec/key-store';
@@ -11,7 +11,7 @@ import { getCanonicalMultiCallEntrypointContract } from '@aztec/protocol-contrac
 
 import { join } from 'path';
 
-import { PXEServiceConfig } from '../config/index.js';
+import { type PXEServiceConfig } from '../config/index.js';
 import { KVPxeDatabase } from '../database/kv_pxe_database.js';
 import { PXEService } from './pxe_service.js';
 

package/src/pxe_service/pxe_service.ts

@@ -1,61 +1,61 @@
 import {
-  AuthWitness,
-  AztecNode,
+  type AuthWitness,
+  type AztecNode,
   EncryptedTxL2Logs,
   ExtendedNote,
-  FunctionCall,
-  GetUnencryptedLogsResponse,
-  KeyStore,
-  L2Block,
-  LogFilter,
+  type FunctionCall,
+  type GetUnencryptedLogsResponse,
+  type KeyStore,
+  type L2Block,
+  type LogFilter,
   MerkleTreeId,
-  NoteFilter,
-  PXE,
+  type NoteFilter,
+  type PXE,
+  SimulatedTx,
   SimulationError,
   Tx,
-  TxEffect,
-  TxExecutionRequest,
-  TxHash,
-  TxReceipt,
+  type TxEffect,
+  type TxExecutionRequest,
+  type TxHash,
+  type TxReceipt,
   UnencryptedTxL2Logs,
   isNoirCallStackUnresolved,
 } from '@aztec/circuit-types';
-import { TxPXEProcessingStats } from '@aztec/circuit-types/stats';
+import { type TxPXEProcessingStats } from '@aztec/circuit-types/stats';
 import {
   AztecAddress,
   CallRequest,
   CompleteAddress,
   FunctionData,
-  GrumpkinPrivateKey,
-  MAX_NON_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  MAX_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  PartialAddress,
-  PrivateKernelTailCircuitPublicInputs,
-  PublicCallRequest,
+  type GrumpkinPrivateKey,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+  type PartialAddress,
+  type PrivateKernelTailCircuitPublicInputs,
+  type PublicCallRequest,
   computeContractClassId,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/hash';
-import { ContractArtifact, DecodedReturn, FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
+import { type ContractArtifact, type DecodedReturn, FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
 import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { SerialQueue } from '@aztec/foundation/fifo';
-import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import {
-  AcirSimulator,
-  ExecutionResult,
+  type AcirSimulator,
+  type ExecutionResult,
   collectEncryptedLogs,
   collectEnqueuedPublicFunctionCalls,
   collectUnencryptedLogs,
   resolveOpcodeLocations,
 } from '@aztec/simulator';
-import { ContractClassWithId, ContractInstanceWithAddress } from '@aztec/types/contracts';
-import { NodeInfo } from '@aztec/types/interfaces';
+import { type ContractClassWithId, type ContractInstanceWithAddress } from '@aztec/types/contracts';
+import { type NodeInfo } from '@aztec/types/interfaces';
 
-import { PXEServiceConfig, getPackageInfo } from '../config/index.js';
+import { type PXEServiceConfig, getPackageInfo } from '../config/index.js';
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
-import { PxeDatabase } from '../database/index.js';
+import { type PxeDatabase } from '../database/index.js';
 import { NoteDao } from '../database/note_dao.js';
 import { KernelOracle } from '../kernel_oracle/index.js';
 import { KernelProver } from '../kernel_prover/kernel_prover.js';
@@ -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

@@ -1,5 +1,5 @@
 import {
-  PXE,
+  type PXE,
   TxExecutionRequest,
   randomContractArtifact,
   randomContractInstanceWithAddress,
@@ -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 () => {

package/src/simulator/index.ts

@@ -1,8 +1,8 @@
-import { AztecNode, KeyStore } from '@aztec/circuit-types';
+import { type AztecNode, type KeyStore } from '@aztec/circuit-types';
 import { AcirSimulator } from '@aztec/simulator';
 
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
-import { PxeDatabase } from '../database/pxe_database.js';
+import { type PxeDatabase } from '../database/pxe_database.js';
 import { SimulatorOracle } from '../simulator_oracle/index.js';
 
 /**

package/src/simulator_oracle/index.ts

@@ -1,30 +1,30 @@
 import {
-  AztecNode,
-  KeyStore,
-  L2Block,
+  type AztecNode,
+  type KeyStore,
+  type L2Block,
   MerkleTreeId,
-  NoteStatus,
-  NullifierMembershipWitness,
-  PublicDataWitness,
-  SiblingPath,
+  type NoteStatus,
+  type NullifierMembershipWitness,
+  type PublicDataWitness,
+  type SiblingPath,
 } from '@aztec/circuit-types';
 import {
-  AztecAddress,
-  CompleteAddress,
-  EthAddress,
-  Fr,
-  FunctionSelector,
-  Header,
-  L1_TO_L2_MSG_TREE_HEIGHT,
+  type AztecAddress,
+  type CompleteAddress,
+  type EthAddress,
+  type Fr,
+  type FunctionSelector,
+  type Header,
+  type L1_TO_L2_MSG_TREE_HEIGHT,
 } from '@aztec/circuits.js';
 import { computeL1ToL2MessageNullifier } from '@aztec/circuits.js/hash';
-import { FunctionArtifactWithDebugMetadata, getFunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
+import { type FunctionArtifactWithDebugMetadata, getFunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { DBOracle, KeyPair, MessageLoadOracleInputs } from '@aztec/simulator';
-import { ContractInstance } from '@aztec/types/contracts';
+import { type DBOracle, type KeyPair, MessageLoadOracleInputs } from '@aztec/simulator';
+import { type ContractInstance } from '@aztec/types/contracts';
 
-import { ContractDataOracle } from '../contract_data_oracle/index.js';
-import { PxeDatabase } from '../database/index.js';
+import { type ContractDataOracle } from '../contract_data_oracle/index.js';
+import { type PxeDatabase } from '../database/index.js';
 
 /**
  * A data oracle that provides information needed for simulating a transaction.