@aztec/simulator 0.38.0 → 0.39.0

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);
+}