@aztec/simulator 0.38.0 → 0.40.0

package/src/client/view_data_oracle.ts

@@ -166,16 +166,6 @@ export class ViewDataOracle extends TypedOracle {
     return this.db.popCapsule();
   }
 
-  /**
-   * Gets public keys for an address.
-   * @param The address to look up
-   * @returns The public keys for a specific address
-   * TODO(#5834): Replace with `getCompleteAddress`.
-   */
-  public override getPublicKeysForAddress(address: AztecAddress) {
-    return this.db.getPublicKeysForAddress(address);
-  }
-
   /**
    * Gets some notes for a contract address and storage slot.
    * Returns a flattened array containing filtered notes.

package/src/common/errors.ts

@@ -2,6 +2,11 @@ import { type FailingFunction, type NoirCallStack, SimulationError } from '@azte
 
 /**
  * An error that occurred during the execution of a function.
+ * @param message - the error message
+ * @param failingFunction - the Aztec function that failed
+ * @param noirCallStack - the internal call stack of the function that failed (within the failing Aztec function)
+ * @param options - additional error options (an optional "cause" entry allows for a recursive error stack where
+ *                  an error's cause may be an ExecutionError itself)
  */
 export class ExecutionError extends Error {
   constructor(

package/src/index.ts

@@ -4,3 +4,4 @@ export * from './common/index.js';
 export * from './public/index.js';
 export * from './simulator/index.js';
 export * from './mocks/index.js';
+export * from './stats/index.js';

package/src/public/abstract_phase_manager.ts

@@ -2,6 +2,7 @@ import {
   MerkleTreeId,
   type ProcessReturnValues,
   type PublicKernelRequest,
+  PublicKernelType,
   type SimulationError,
   type Tx,
   type UnencryptedFunctionL2Logs,
@@ -31,7 +32,6 @@ import {
   MembershipWitness,
   NoteHash,
   Nullifier,
-  type PrivateKernelTailCircuitPublicInputs,
   type Proof,
   PublicCallData,
   type PublicCallRequest,
@@ -81,6 +81,20 @@ export const PhaseIsRevertible: Record<PublicKernelPhase, boolean> = {
   [PublicKernelPhase.TAIL]: false,
 };
 
+// REFACTOR: Unify both enums and move to types or circuit-types.
+export function publicKernelPhaseToKernelType(phase: PublicKernelPhase): PublicKernelType {
+  switch (phase) {
+    case PublicKernelPhase.SETUP:
+      return PublicKernelType.SETUP;
+    case PublicKernelPhase.APP_LOGIC:
+      return PublicKernelType.APP_LOGIC;
+    case PublicKernelPhase.TEARDOWN:
+      return PublicKernelType.TEARDOWN;
+    case PublicKernelPhase.TAIL:
+      return PublicKernelType.TAIL;
+  }
+}
+
 export abstract class AbstractPhaseManager {
   protected hintsBuilder: HintsBuilder;
   protected log: DebugLogger;
@@ -127,13 +141,12 @@ export abstract class AbstractPhaseManager {
      */
     revertReason: SimulationError | undefined;
     returnValues: ProcessReturnValues;
+    /** Gas used during the execution this particular phase. */
+    gasUsed: Gas | undefined;
   }>;
 
-  public static extractEnqueuedPublicCallsByPhase(
-    publicInputs: PrivateKernelTailCircuitPublicInputs,
-    enqueuedPublicFunctionCalls: PublicCallRequest[],
-  ): Record<PublicKernelPhase, PublicCallRequest[]> {
-    const data = publicInputs.forPublic;
+  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelPhase, PublicCallRequest[]> {
+    const data = tx.data.forPublic;
     if (!data) {
       return {
         [PublicKernelPhase.SETUP]: [],
@@ -142,7 +155,7 @@ export abstract class AbstractPhaseManager {
         [PublicKernelPhase.TAIL]: [],
       };
     }
-    const publicCallsStack = enqueuedPublicFunctionCalls.slice().reverse();
+    const publicCallsStack = tx.enqueuedPublicFunctionCalls.slice().reverse();
     const nonRevertibleCallStack = data.endNonRevertibleData.publicCallStack.filter(i => !i.isEmpty());
     const revertibleCallStack = data.end.publicCallStack.filter(i => !i.isEmpty());
 
@@ -169,39 +182,40 @@ export abstract class AbstractPhaseManager {
       c => revertibleCallStack.findIndex(p => p.equals(c)) !== -1,
     );
 
+    const teardownCallStack = tx.publicTeardownFunctionCall.isEmpty() ? [] : [tx.publicTeardownFunctionCall];
+
     if (firstRevertibleCallIndex === 0) {
       return {
         [PublicKernelPhase.SETUP]: [],
         [PublicKernelPhase.APP_LOGIC]: publicCallsStack,
-        [PublicKernelPhase.TEARDOWN]: [],
+        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
         [PublicKernelPhase.TAIL]: [],
       };
     } else if (firstRevertibleCallIndex === -1) {
       // there's no app logic, split the functions between setup (many) and teardown (just one function call)
       return {
-        [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, -1),
+        [PublicKernelPhase.SETUP]: publicCallsStack,
         [PublicKernelPhase.APP_LOGIC]: [],
-        [PublicKernelPhase.TEARDOWN]: [publicCallsStack[publicCallsStack.length - 1]],
+        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
         [PublicKernelPhase.TAIL]: [],
       };
     } else {
       return {
-        [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex - 1),
+        [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex),
         [PublicKernelPhase.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
-        [PublicKernelPhase.TEARDOWN]: [publicCallsStack[firstRevertibleCallIndex - 1]],
+        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
         [PublicKernelPhase.TAIL]: [],
       };
     }
   }
 
   protected extractEnqueuedPublicCalls(tx: Tx): PublicCallRequest[] {
-    const calls = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx.data, tx.enqueuedPublicFunctionCalls)[
-      this.phase
-    ];
+    const calls = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx)[this.phase];
 
     return calls;
   }
 
+  // REFACTOR: Do not return an array and instead return a struct with similar shape to that returned by `handle`
   protected async processEnqueuedPublicCalls(
     tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
@@ -214,6 +228,7 @@ export abstract class AbstractPhaseManager {
       UnencryptedFunctionL2Logs[],
       SimulationError | undefined,
       ProcessReturnValues,
+      Gas,
     ]
   > {
     let kernelOutput = previousPublicKernelOutput;
@@ -223,7 +238,7 @@ export abstract class AbstractPhaseManager {
     const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
 
     if (!enqueuedCalls || !enqueuedCalls.length) {
-      return [[], kernelOutput, kernelProof, [], undefined, undefined];
+      return [[], kernelOutput, kernelProof, [], undefined, undefined, Gas.empty()];
     }
 
     const newUnencryptedFunctionLogs: UnencryptedFunctionL2Logs[] = [];
@@ -236,6 +251,7 @@ export abstract class AbstractPhaseManager {
     // and submitted separately to the base rollup?
 
     let returns: ProcessReturnValues = undefined;
+    let gasUsed = Gas.empty();
 
     for (const enqueuedCall of enqueuedCalls) {
       const executionStack: (PublicExecution | PublicExecutionResult)[] = [enqueuedCall];
@@ -263,7 +279,18 @@ export abstract class AbstractPhaseManager {
             )
           : current;
 
+        // Sanity check for a current upstream assumption.
+        // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
         const functionSelector = result.execution.functionData.selector.toString();
+        if (result.reverted && !result.revertReason) {
+          throw new Error(
+            `Simulation of ${result.execution.contractAddress.toString()}:${functionSelector} reverted with no reason.`,
+          );
+        }
+
+        // Accumulate gas used in this execution
+        gasUsed = gasUsed.add(Gas.from(result.startGasLeft).sub(Gas.from(result.endGasLeft)));
+
         if (result.reverted && !PhaseIsRevertible[this.phase]) {
           this.log.debug(
             `Simulation error on ${result.execution.contractAddress.toString()}:${functionSelector} with reason: ${
@@ -306,7 +333,8 @@ export abstract class AbstractPhaseManager {
               result.revertReason
             }`,
           );
-          return [[], kernelOutput, kernelProof, [], result.revertReason, undefined];
+          // TODO(@spalladino): Check gasUsed is correct. The AVM should take care of setting gasLeft to zero upon a revert.
+          return [[], kernelOutput, kernelProof, [], result.revertReason, undefined, gasUsed];
         }
 
         if (!enqueuedExecutionResult) {
@@ -322,7 +350,7 @@ export abstract class AbstractPhaseManager {
     // TODO(#3675): This should be done in a public kernel circuit
     removeRedundantPublicDataWrites(kernelOutput, this.phase);
 
-    return [publicKernelInputs, kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined, returns];
+    return [publicKernelInputs, kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined, returns, gasUsed];
   }
 
   /** Returns all pending private and public nullifiers.  */

package/src/public/app_logic_phase_manager.ts

@@ -47,6 +47,7 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
       newUnencryptedFunctionLogs,
       revertReason,
       returnValues,
+      gasUsed,
     ] = await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
       // if we throw for any reason other than simulation, we need to rollback and drop the TX
       async err => {
@@ -71,6 +72,6 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
       };
       return request;
     });
-    return { kernelRequests, publicKernelOutput, publicKernelProof, revertReason, returnValues };
+    return { kernelRequests, publicKernelOutput, publicKernelProof, revertReason, returnValues, gasUsed };
   }
 }

package/src/public/executor.ts

@@ -168,10 +168,6 @@ async function executePublicFunctionAcvm(
   })();
 
   if (reverted) {
-    if (!revertReason) {
-      throw new Error('Reverted but no revert reason');
-    }
-
     return {
       execution,
       returnValues: [],

package/src/public/hints_builder.ts

@@ -15,11 +15,11 @@ import {
   type PublicDataRead,
   type PublicDataTreeLeafPreimage,
   type PublicDataUpdateRequest,
-  type ReadRequestContext,
+  type ScopedReadRequest,
   buildNullifierNonExistentReadRequestHints,
-  buildNullifierReadRequestHints,
   buildPublicDataHints,
   buildPublicDataReadRequestHints,
+  buildSiloedNullifierReadRequestHints,
 } from '@aztec/circuits.js';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { type IndexedTreeId, type MerkleTreeOperations } from '@aztec/world-state';
@@ -28,14 +28,14 @@ export class HintsBuilder {
   constructor(private db: MerkleTreeOperations) {}
 
   getNullifierReadRequestHints(
-    nullifierReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
-    return buildNullifierReadRequestHints(this, nullifierReadRequests, pendingNullifiers);
+    return buildSiloedNullifierReadRequestHints(this, nullifierReadRequests, pendingNullifiers);
   }
 
   getNullifierNonExistentReadRequestHints(
-    nullifierNonExistentReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
+    nullifierNonExistentReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
     pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
     return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);

package/src/public/public_execution_context.ts

@@ -12,7 +12,7 @@ import {
 } from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 import { type ContractInstance } from '@aztec/types/contracts';
 
 import { TypedOracle, toACVMWitness } from '../acvm/index.js';
@@ -281,4 +281,9 @@ export class PublicExecutionContext extends TypedOracle {
     }
     return instance;
   }
+
+  public override debugLog(message: string, fields: Fr[]): void {
+    const formattedStr = applyStringFormatting(message, fields);
+    this.log.verbose(`debug_log ${formattedStr}`);
+  }
 }

package/src/public/public_processor.ts

@@ -20,7 +20,11 @@ import { PublicExecutor, type PublicStateDB, type SimulationProvider } from '@az
 import { type ContractDataSource } from '@aztec/types/contracts';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { type AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import {
+  type AbstractPhaseManager,
+  PublicKernelPhase,
+  publicKernelPhaseToKernelType,
+} from './abstract_phase_manager.js';
 import { PhaseManagerFactory } from './phase_manager_factory.js';
 import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from './public_executor.js';
 import { RealPublicKernelCircuitSimulator } from './public_kernel.js';
@@ -169,8 +173,10 @@ export class PublicProcessor {
     let finalKernelOutput: KernelCircuitPublicInputs | undefined;
     let revertReason: SimulationError | undefined;
     const timer = new Timer();
+    const gasUsed: ProcessedTx['gasUsed'] = {};
     while (phase) {
       const output = await phase.handle(tx, publicKernelPublicInput, proof);
+      gasUsed[publicKernelPhaseToKernelType(phase.phase)] = output.gasUsed;
       if (phase.phase === PublicKernelPhase.APP_LOGIC) {
         returnValues = output.returnValues;
       }
@@ -196,7 +202,7 @@ export class PublicProcessor {
       throw new Error('Final public kernel was not executed.');
     }
 
-    const processedTx = makeProcessedTx(tx, finalKernelOutput, proof, publicRequests, revertReason);
+    const processedTx = makeProcessedTx(tx, finalKernelOutput, proof, publicRequests, revertReason, gasUsed);
 
     this.log.debug(`Processed public part of ${tx.getTxHash()}`, {
       eventName: 'tx-sequencer-processing',

package/src/public/setup_phase_manager.ts

@@ -35,14 +35,21 @@ export class SetupPhaseManager extends AbstractPhaseManager {
     previousPublicKernelProof: Proof,
   ) {
     this.log.verbose(`Processing tx ${tx.getTxHash()}`);
-    const [kernelInputs, publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
-        // the abstract phase manager throws if simulation gives error in a non-revertible phase
-        async err => {
-          await this.publicStateDB.rollbackToCommit();
-          throw err;
-        },
-      );
+    const [
+      kernelInputs,
+      publicKernelOutput,
+      publicKernelProof,
+      newUnencryptedFunctionLogs,
+      revertReason,
+      _returnValues,
+      gasUsed,
+    ] = await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
+      // the abstract phase manager throws if simulation gives error in a non-revertible phase
+      async err => {
+        await this.publicStateDB.rollbackToCommit();
+        throw err;
+      },
+    );
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
     await this.publicStateDB.checkpoint();
 
@@ -61,6 +68,7 @@ export class SetupPhaseManager extends AbstractPhaseManager {
       publicKernelProof,
       revertReason,
       returnValues: undefined,
+      gasUsed,
     };
   }
 }

package/src/public/tail_phase_manager.ts

@@ -39,7 +39,11 @@ export class TailPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
 
-  async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
+  override async handle(
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousPublicKernelProof: Proof,
+  ) {
     this.log.verbose(`Processing tx ${tx.getTxHash()}`);
     const [inputs, finalKernelOutput] = await this.runTailKernelCircuit(
       previousPublicKernelOutput,
@@ -67,6 +71,7 @@ export class TailPhaseManager extends AbstractPhaseManager {
       publicKernelProof: makeEmptyProof(),
       revertReason: undefined,
       returnValues: undefined,
+      gasUsed: undefined,
     };
   }
 

package/src/public/teardown_phase_manager.ts

@@ -39,14 +39,21 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
     previousPublicKernelProof: Proof,
   ) {
     this.log.verbose(`Processing tx ${tx.getTxHash()}`);
-    const [kernelInputs, publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
-        // the abstract phase manager throws if simulation gives error in a non-revertible phase
-        async err => {
-          await this.publicStateDB.rollbackToCommit();
-          throw err;
-        },
-      );
+    const [
+      kernelInputs,
+      publicKernelOutput,
+      publicKernelProof,
+      newUnencryptedFunctionLogs,
+      revertReason,
+      _returnValues,
+      gasUsed,
+    ] = await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
+      // the abstract phase manager throws if simulation gives error in a non-revertible phase
+      async err => {
+        await this.publicStateDB.rollbackToCommit();
+        throw err;
+      },
+    );
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
     await this.publicStateDB.checkpoint();
 
@@ -65,6 +72,7 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
       publicKernelProof,
       revertReason,
       returnValues: undefined,
+      gasUsed,
     };
   }
 

package/src/public/transitional_adaptors.ts

@@ -81,6 +81,7 @@ export function convertAvmResultsToPxResult(
 ): PublicExecutionResult {
   const endPersistableState = endAvmContext.persistableState;
   const endMachineState = endAvmContext.machineState;
+
   return {
     ...endPersistableState.transitionalExecutionResult, // includes nestedExecutions
     execution: fromPx,

package/src/rollup/index.ts

@@ -0,0 +1 @@
+export * from './rollup.js';

package/src/rollup/rollup.ts

@@ -0,0 +1,160 @@
+import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import {
+  type BaseOrMergeRollupPublicInputs,
+  type BaseParityInputs,
+  type BaseRollupInputs,
+  type MergeRollupInputs,
+  type ParityPublicInputs,
+  type RootParityInputs,
+  type RootRollupInputs,
+  type RootRollupPublicInputs,
+} from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
+import {
+  BaseParityArtifact,
+  MergeRollupArtifact,
+  RootParityArtifact,
+  RootRollupArtifact,
+  SimulatedBaseRollupArtifact,
+  convertBaseParityInputsToWitnessMap,
+  convertBaseParityOutputsFromWitnessMap,
+  convertMergeRollupInputsToWitnessMap,
+  convertMergeRollupOutputsFromWitnessMap,
+  convertRootParityInputsToWitnessMap,
+  convertRootParityOutputsFromWitnessMap,
+  convertRootRollupInputsToWitnessMap,
+  convertRootRollupOutputsFromWitnessMap,
+  convertSimulatedBaseRollupInputsToWitnessMap,
+  convertSimulatedBaseRollupOutputsFromWitnessMap,
+} from '@aztec/noir-protocol-circuits-types';
+import { type SimulationProvider, WASMSimulator } from '@aztec/simulator';
+
+/**
+ * Circuit simulator for the rollup circuits.
+ */
+export interface RollupSimulator {
+  /**
+   * Simulates the base parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */
+  baseParityCircuit(inputs: BaseParityInputs): Promise<ParityPublicInputs>;
+  /**
+   * Simulates the root parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */
+  rootParityCircuit(inputs: RootParityInputs): Promise<ParityPublicInputs>;
+  /**
+   * Simulates the base rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  baseRollupCircuit(input: BaseRollupInputs): Promise<BaseOrMergeRollupPublicInputs>;
+  /**
+   * Simulates the merge rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs>;
+  /**
+   * Simulates the root rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  rootRollupCircuit(input: RootRollupInputs): Promise<RootRollupPublicInputs>;
+}
+
+/**
+ * Implements the rollup circuit simulator.
+ */
+export class RealRollupCircuitSimulator implements RollupSimulator {
+  private log = createDebugLogger('aztec:rollup-simulator');
+
+  // Some circuits are so small it is faster to use WASM
+  private wasmSimulator: WASMSimulator = new WASMSimulator();
+
+  constructor(private simulationProvider: SimulationProvider) {}
+
+  /**
+   * Simulates the base parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */
+  public async baseParityCircuit(inputs: BaseParityInputs): Promise<ParityPublicInputs> {
+    const witnessMap = convertBaseParityInputsToWitnessMap(inputs);
+
+    const witness = await this.simulationProvider.simulateCircuit(witnessMap, BaseParityArtifact);
+
+    const result = convertBaseParityOutputsFromWitnessMap(witness);
+
+    return Promise.resolve(result);
+  }
+
+  /**
+   * Simulates the root parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */
+  public async rootParityCircuit(inputs: RootParityInputs): Promise<ParityPublicInputs> {
+    const witnessMap = convertRootParityInputsToWitnessMap(inputs);
+
+    const witness = await this.simulationProvider.simulateCircuit(witnessMap, RootParityArtifact);
+
+    const result = convertRootParityOutputsFromWitnessMap(witness);
+
+    return Promise.resolve(result);
+  }
+
+  /**
+   * Simulates the base rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async baseRollupCircuit(input: BaseRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
+    const witnessMap = convertSimulatedBaseRollupInputsToWitnessMap(input);
+
+    const witness = await this.simulationProvider.simulateCircuit(witnessMap, SimulatedBaseRollupArtifact);
+
+    const result = convertSimulatedBaseRollupOutputsFromWitnessMap(witness);
+
+    return Promise.resolve(result);
+  }
+  /**
+   * Simulates the merge rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
+    const witnessMap = convertMergeRollupInputsToWitnessMap(input);
+
+    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, MergeRollupArtifact);
+
+    const result = convertMergeRollupOutputsFromWitnessMap(witness);
+
+    return result;
+  }
+
+  /**
+   * Simulates the root rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async rootRollupCircuit(input: RootRollupInputs): Promise<RootRollupPublicInputs> {
+    const witnessMap = convertRootRollupInputsToWitnessMap(input);
+
+    const [duration, witness] = await elapsed(() => this.wasmSimulator.simulateCircuit(witnessMap, RootRollupArtifact));
+
+    const result = convertRootRollupOutputsFromWitnessMap(witness);
+
+    this.log.debug(`Simulated root rollup circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'root-rollup',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return result;
+  }
+}

package/src/stats/index.ts

@@ -0,0 +1 @@
+export * from './stats.js';

package/src/stats/stats.ts

@@ -0,0 +1,20 @@
+import { type CircuitName, type CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import { type Logger } from '@aztec/foundation/log';
+
+export function emitCircuitSimulationStats(
+  circuitName: CircuitName,
+  duration: number,
+  inputSize: number,
+  outputSize: number,
+  logger: Logger,
+) {
+  const stats: CircuitSimulationStats = {
+    eventName: 'circuit-simulation',
+    circuitName,
+    inputSize,
+    outputSize,
+    duration,
+  };
+
+  logger.debug('Circuit simulation stats', stats);
+}