@aztec/simulator 0.37.0 → 0.39.0

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

@@ -1,32 +1,21 @@
 // All code in this file needs to die once the public executor is phased out in favor of the AVM.
-import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
+import { UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
   CallContext,
-  ContractStorageRead,
-  ContractStorageUpdateRequest,
   FunctionData,
-  Gas,
+  type Gas,
   type GasSettings,
   type GlobalVariables,
   type Header,
-  L2ToL1Message,
-  NoteHash,
-  Nullifier,
-  ReadRequest,
-  SideEffect,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import { type AvmContext } from '../avm/avm_context.js';
 import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
-import { type AvmMachineState } from '../avm/avm_machine_state.js';
-import { AvmContractCallResults } from '../avm/avm_message_call_result.js';
-import { type JournalData } from '../avm/journal/journal.js';
+import { type AvmContractCallResults } from '../avm/avm_message_call_result.js';
 import { Mov } from '../avm/opcodes/memory.js';
 import { createSimulationError } from '../common/errors.js';
-import { PackedValuesCache, SideEffectCounter } from '../index.js';
 import { type PublicExecution, type PublicExecutionResult } from './execution.js';
-import { PublicExecutionContext } from './public_execution_context.js';
 
 /**
  * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
@@ -60,184 +49,57 @@ export function createAvmExecutionEnvironment(
   );
 }
 
-export function createPublicExecutionContext(avmContext: AvmContext, calldata: Fr[]): PublicExecutionContext {
-  const sideEffectCounter = avmContext.persistableState.trace.accessCounter;
+export function createPublicExecution(
+  startSideEffectCounter: number,
+  avmEnvironment: AvmExecutionEnvironment,
+  calldata: Fr[],
+): PublicExecution {
   const callContext = CallContext.from({
-    msgSender: avmContext.environment.sender,
-    storageContractAddress: avmContext.environment.storageAddress,
-    functionSelector: avmContext.environment.temporaryFunctionSelector,
-    isDelegateCall: avmContext.environment.isDelegateCall,
-    isStaticCall: avmContext.environment.isStaticCall,
-    sideEffectCounter: sideEffectCounter,
+    msgSender: avmEnvironment.sender,
+    storageContractAddress: avmEnvironment.storageAddress,
+    functionSelector: avmEnvironment.temporaryFunctionSelector,
+    isDelegateCall: avmEnvironment.isDelegateCall,
+    isStaticCall: avmEnvironment.isStaticCall,
+    sideEffectCounter: startSideEffectCounter,
   });
-  const functionData = new FunctionData(avmContext.environment.temporaryFunctionSelector, /*isPrivate=*/ false);
+  const functionData = new FunctionData(avmEnvironment.temporaryFunctionSelector, /*isPrivate=*/ false);
   const execution: PublicExecution = {
-    contractAddress: avmContext.environment.address,
+    contractAddress: avmEnvironment.address,
     callContext,
     args: calldata,
     functionData,
   };
-  const packedArgs = PackedValuesCache.create([]);
-
-  const context = new PublicExecutionContext(
-    execution,
-    avmContext.environment.header,
-    avmContext.environment.globals,
-    packedArgs,
-    new SideEffectCounter(sideEffectCounter),
-    avmContext.persistableState.hostStorage.publicStateDb,
-    avmContext.persistableState.hostStorage.contractsDb,
-    avmContext.persistableState.hostStorage.commitmentsDb,
-    Gas.from(avmContext.machineState.gasLeft),
-    avmContext.environment.transactionFee,
-    avmContext.environment.gasSettings,
-  );
-
-  return context;
+  return execution;
 }
 
-/**
- * Convert the result of an AVM contract call to a PublicExecutionResult for the public kernel
- *
- * @param execution
- * @param newWorldState
- * @param result
- * @returns
- */
-export async function convertAvmResults(
-  executionContext: PublicExecutionContext,
-  newWorldState: JournalData,
-  result: AvmContractCallResults,
-  endMachineState: AvmMachineState,
-): Promise<PublicExecutionResult> {
-  const execution = executionContext.execution;
-
-  const contractStorageReads: ContractStorageRead[] = newWorldState.storageReads.map(
-    read => new ContractStorageRead(read.slot, read.value, read.counter.toNumber(), read.storageAddress),
-  );
-  const contractStorageUpdateRequests: ContractStorageUpdateRequest[] = newWorldState.storageWrites.map(
-    write => new ContractStorageUpdateRequest(write.slot, write.value, write.counter.toNumber(), write.storageAddress),
-  );
-  // We need to write the storage updates to the DB, because that's what the ACVM expects.
-  // Assumes the updates are in the right order.
-  for (const write of newWorldState.storageWrites) {
-    await executionContext.stateDb.storageWrite(write.storageAddress, write.slot, write.value);
-  }
-
-  const newNoteHashes = newWorldState.newNoteHashes.map(
-    noteHash => new NoteHash(noteHash.noteHash, noteHash.counter.toNumber()),
-  );
-  const nullifierReadRequests: ReadRequest[] = newWorldState.nullifierChecks
-    .filter(nullifierCheck => nullifierCheck.exists)
-    .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
-  const nullifierNonExistentReadRequests: ReadRequest[] = newWorldState.nullifierChecks
-    .filter(nullifierCheck => !nullifierCheck.exists)
-    .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
-  const newNullifiers: Nullifier[] = newWorldState.newNullifiers.map(
-    tracedNullifier =>
-      new Nullifier(
-        /*value=*/ tracedNullifier.nullifier,
-        tracedNullifier.counter.toNumber(),
-        /*noteHash=*/ Fr.ZERO, // NEEDED?
-      ),
-  );
-  const unencryptedLogs: UnencryptedFunctionL2Logs = new UnencryptedFunctionL2Logs(
-    newWorldState.newLogs.map(log => new UnencryptedL2Log(log.contractAddress, log.selector, log.data)),
-  );
-  const unencryptedLogsHashes = newWorldState.newLogsHashes.map(
-    logHash => new SideEffect(logHash.logHash, logHash.counter),
-  );
-  const newL2ToL1Messages = newWorldState.newL1Messages.map(m => new L2ToL1Message(m.recipient, m.content));
-
-  const returnValues = result.output;
-
-  // TODO: Support nested executions.
-  const nestedExecutions: PublicExecutionResult[] = [];
-  // TODO keep track of side effect counters
-  const startSideEffectCounter = Fr.ZERO;
-  const endSideEffectCounter = Fr.ZERO;
+export function convertAvmResultsToPxResult(
+  avmResult: AvmContractCallResults,
+  startSideEffectCounter: number,
+  fromPx: PublicExecution,
+  startGas: Gas,
+  endAvmContext: AvmContext,
+): PublicExecutionResult {
+  const endPersistableState = endAvmContext.persistableState;
+  const endMachineState = endAvmContext.machineState;
 
   return {
-    execution,
-    nullifierReadRequests,
-    nullifierNonExistentReadRequests,
-    newNoteHashes,
-    newL2ToL1Messages,
-    startSideEffectCounter,
-    endSideEffectCounter,
-    newNullifiers,
-    contractStorageReads,
-    contractStorageUpdateRequests,
-    returnValues,
-    nestedExecutions,
-    unencryptedLogsHashes,
-    unencryptedLogs,
-    reverted: result.reverted,
-    revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
-    startGasLeft: executionContext.availableGas,
+    ...endPersistableState.transitionalExecutionResult, // includes nestedExecutions
+    execution: fromPx,
+    returnValues: avmResult.output,
+    startSideEffectCounter: new Fr(startSideEffectCounter),
+    endSideEffectCounter: new Fr(endPersistableState.trace.accessCounter),
+    unencryptedLogs: new UnencryptedFunctionL2Logs(endPersistableState.transitionalExecutionResult.unencryptedLogs),
+    allUnencryptedLogs: new UnencryptedFunctionL2Logs(
+      endPersistableState.transitionalExecutionResult.allUnencryptedLogs,
+    ),
+    reverted: avmResult.reverted,
+    revertReason: avmResult.revertReason ? createSimulationError(avmResult.revertReason) : undefined,
+    startGasLeft: startGas,
     endGasLeft: endMachineState.gasLeft,
-    transactionFee: executionContext.transactionFee,
+    transactionFee: endAvmContext.environment.transactionFee,
   };
 }
 
-export function convertPublicExecutionResult(res: PublicExecutionResult): AvmContractCallResults {
-  return new AvmContractCallResults(res.reverted, res.returnValues, res.revertReason);
-}
-
-export function updateAvmContextFromPublicExecutionResult(ctx: AvmContext, result: PublicExecutionResult): void {
-  // We have to push these manually and not use the trace* functions
-  // so that we respect the side effect counters.
-  for (const readRequest of result.contractStorageReads) {
-    ctx.persistableState.trace.publicStorageReads.push({
-      storageAddress: ctx.environment.storageAddress,
-      exists: true, // FIXME
-      slot: readRequest.storageSlot,
-      value: readRequest.currentValue,
-      counter: new Fr(readRequest.sideEffectCounter ?? Fr.ZERO),
-    });
-  }
-
-  for (const updateRequest of result.contractStorageUpdateRequests) {
-    ctx.persistableState.trace.publicStorageWrites.push({
-      storageAddress: ctx.environment.storageAddress,
-      slot: updateRequest.storageSlot,
-      value: updateRequest.newValue,
-      counter: new Fr(updateRequest.sideEffectCounter ?? Fr.ZERO),
-    });
-
-    // We need to manually populate the cache.
-    ctx.persistableState.publicStorage.write(
-      ctx.environment.storageAddress,
-      updateRequest.storageSlot,
-      updateRequest.newValue,
-    );
-  }
-
-  for (const nullifier of result.newNullifiers) {
-    ctx.persistableState.trace.newNullifiers.push({
-      storageAddress: ctx.environment.storageAddress,
-      nullifier: nullifier.value,
-      counter: new Fr(nullifier.counter),
-    });
-  }
-
-  for (const noteHash of result.newNoteHashes) {
-    ctx.persistableState.trace.newNoteHashes.push({
-      storageAddress: ctx.environment.storageAddress,
-      noteHash: noteHash.value,
-      counter: new Fr(noteHash.counter),
-    });
-  }
-
-  for (const message of result.newL2ToL1Messages) {
-    ctx.persistableState.newL1Messages.push(message);
-  }
-
-  for (const log of result.unencryptedLogs.logs) {
-    ctx.persistableState.newLogs.push(new UnencryptedL2Log(log.contractAddress, log.selector, log.data));
-  }
-}
-
 const AVM_MAGIC_SUFFIX = Buffer.from([
   Mov.opcode, // opcode
   0x00, // indirect

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