@aztec/sequencer-client 0.26.3 → 0.26.5

package/src/block_builder/solo_block_builder.ts

@@ -1,4 +1,5 @@
 import { Body, ContractData, L2Block, MerkleTreeId, PublicDataWrite, TxEffect, TxL2Logs } from '@aztec/circuit-types';
+import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
   ARCHIVE_HEIGHT,
   AppendOnlyTreeSnapshot,
@@ -52,6 +53,7 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { elapsed } from '@aztec/foundation/timer';
 import { MerkleTreeOperations } from '@aztec/world-state';
 
 import chunk from 'lodash.chunk';
@@ -138,11 +140,11 @@ export class SoloBlockBuilder implements BlockBuilder {
       body: blockBody,
     });
 
-    if (!l2Block.body.getCalldataHash().equals(circuitsOutput.header.contentCommitment.txsHash)) {
+    if (!l2Block.body.getTxsEffectsHash().equals(circuitsOutput.header.contentCommitment.txsEffectsHash)) {
       throw new Error(
-        `Calldata hash mismatch, ${l2Block.body
-          .getCalldataHash()
-          .toString('hex')} == ${circuitsOutput.header.contentCommitment.txsHash.toString('hex')} `,
+        `Txs effects hash mismatch, ${l2Block.body
+          .getTxsEffectsHash()
+          .toString('hex')} == ${circuitsOutput.header.contentCommitment.txsEffectsHash.toString('hex')} `,
       );
     }
 
@@ -189,22 +191,66 @@ export class SoloBlockBuilder implements BlockBuilder {
     // padArrayEnd throws if the array is already full. Otherwise it pads till we reach the required size
     const newL1ToL2MessagesTuple = padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
 
-    // Run the base rollup circuits for the txs
-    const baseRollupOutputs: [BaseOrMergeRollupPublicInputs, Proof][] = [];
+    // Perform all tree insertions and retrieve snapshots for all base rollups
+    const baseRollupInputs: BaseRollupInputs[] = [];
+    const treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>[] = [];
     for (const tx of txs) {
-      baseRollupOutputs.push(await this.baseRollupCircuit(tx, globalVariables));
+      const input = await this.buildBaseRollupInput(tx, globalVariables);
+      baseRollupInputs.push(input);
+      const promises = [
+        MerkleTreeId.NOTE_HASH_TREE,
+        MerkleTreeId.CONTRACT_TREE,
+        MerkleTreeId.NULLIFIER_TREE,
+        MerkleTreeId.PUBLIC_DATA_TREE,
+      ].map(async (id: MerkleTreeId) => {
+        return { key: id, value: await this.getTreeSnapshot(id) };
+      });
+      const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
+        (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
+      );
+      treeSnapshots.push(snapshots);
+    }
+
+    // Run the base rollup circuits for the txs in parallel
+    const baseRollupOutputs: Promise<[BaseOrMergeRollupPublicInputs, Proof]>[] = [];
+    for (let i = 0; i < txs.length; i++) {
+      baseRollupOutputs.push(this.baseRollupCircuit(txs[i], baseRollupInputs[i], treeSnapshots[i]));
     }
 
     // Run merge rollups in layers until we have only two outputs
-    let mergeRollupInputs: [BaseOrMergeRollupPublicInputs, Proof][] = baseRollupOutputs;
-    let mergeRollupOutputs: [BaseOrMergeRollupPublicInputs, Proof][] = [];
+    // All merge circuits for each layer are simulated in parallel
+    const [duration, mergeInputs] = await elapsed(() => Promise.all(baseRollupOutputs));
+    for (let i = 0; i < mergeInputs.length; i++) {
+      this.debug(`Simulated base rollup circuit`, {
+        eventName: 'circuit-simulation',
+        circuitName: 'base-rollup',
+        duration: duration / mergeInputs.length,
+        inputSize: baseRollupInputs[i].toBuffer().length,
+        outputSize: mergeInputs[i][0].toBuffer().length,
+      } satisfies CircuitSimulationStats);
+    }
+    let mergeRollupInputs: [BaseOrMergeRollupPublicInputs, Proof][] = mergeInputs;
     while (mergeRollupInputs.length > 2) {
+      const mergeInputStructs: MergeRollupInputs[] = [];
       for (const pair of chunk(mergeRollupInputs, 2)) {
         const [r1, r2] = pair;
-        mergeRollupOutputs.push(await this.mergeRollupCircuit(r1, r2));
+        mergeInputStructs.push(this.createMergeRollupInputs(r1, r2));
+      }
+
+      const [duration, mergeOutputs] = await elapsed(() =>
+        Promise.all(mergeInputStructs.map(async input => await this.mergeRollupCircuit(input))),
+      );
+
+      for (let i = 0; i < mergeOutputs.length; i++) {
+        this.debug(`Simulated merge rollup circuit`, {
+          eventName: 'circuit-simulation',
+          circuitName: 'merge-rollup',
+          duration: duration / mergeOutputs.length,
+          inputSize: mergeInputStructs[i].toBuffer().length,
+          outputSize: mergeOutputs[i][0].toBuffer().length,
+        } satisfies CircuitSimulationStats);
       }
-      mergeRollupInputs = mergeRollupOutputs;
-      mergeRollupOutputs = [];
+      mergeRollupInputs = mergeOutputs;
     }
 
     // Run the root rollup with the last two merge rollups (or base, if no merge layers)
@@ -214,26 +260,29 @@ export class SoloBlockBuilder implements BlockBuilder {
 
   protected async baseRollupCircuit(
     tx: ProcessedTx,
-    globalVariables: GlobalVariables,
+    inputs: BaseRollupInputs,
+    treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
   ): Promise<[BaseOrMergeRollupPublicInputs, Proof]> {
     this.debug(`Running base rollup for ${tx.hash}`);
-    const rollupInput = await this.buildBaseRollupInput(tx, globalVariables);
-    const rollupOutput = await this.simulator.baseRollupCircuit(rollupInput);
-    await this.validatePartialState(rollupOutput.end);
-    const proof = await this.prover.getBaseRollupProof(rollupInput, rollupOutput);
+    const rollupOutput = await this.simulator.baseRollupCircuit(inputs);
+    this.validatePartialState(rollupOutput.end, treeSnapshots);
+    const proof = await this.prover.getBaseRollupProof(inputs, rollupOutput);
     return [rollupOutput, proof];
   }
 
-  protected async mergeRollupCircuit(
+  protected createMergeRollupInputs(
     left: [BaseOrMergeRollupPublicInputs, Proof],
     right: [BaseOrMergeRollupPublicInputs, Proof],
-  ): Promise<[BaseOrMergeRollupPublicInputs, Proof]> {
+  ) {
     const vk = this.getVerificationKey(left[0].rollupType);
     const mergeInputs = new MergeRollupInputs([
       this.getPreviousRollupDataFromPublicInputs(left[0], left[1], vk),
       this.getPreviousRollupDataFromPublicInputs(right[0], right[1], vk),
     ]);
+    return mergeInputs;
+  }
 
+  protected async mergeRollupCircuit(mergeInputs: MergeRollupInputs): Promise<[BaseOrMergeRollupPublicInputs, Proof]> {
     this.debug(`Running merge rollup circuit`);
     const output = await this.simulator.mergeRollupCircuit(mergeInputs);
     const proof = await this.prover.getMergeRollupProof(mergeInputs, output);
@@ -279,40 +328,50 @@ export class SoloBlockBuilder implements BlockBuilder {
     return [rootOutput, rootProof];
   }
 
-  protected async validatePartialState(partialState: PartialStateReference) {
-    await Promise.all([
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE),
-        partialState.noteHashTree,
-        'NoteHashTree',
-      ),
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE),
-        partialState.nullifierTree,
-        'NullifierTree',
-      ),
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.CONTRACT_TREE),
-        partialState.contractTree,
-        'ContractTree',
-      ),
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE),
-        partialState.publicDataTree,
-        'PublicDataTree',
-      ),
-    ]);
+  protected validatePartialState(
+    partialState: PartialStateReference,
+    treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
+  ) {
+    this.validateSimulatedTree(
+      treeSnapshots.get(MerkleTreeId.NOTE_HASH_TREE)!,
+      partialState.noteHashTree,
+      'NoteHashTree',
+    );
+    this.validateSimulatedTree(
+      treeSnapshots.get(MerkleTreeId.NULLIFIER_TREE)!,
+      partialState.nullifierTree,
+      'NullifierTree',
+    );
+    this.validateSimulatedTree(
+      treeSnapshots.get(MerkleTreeId.CONTRACT_TREE)!,
+      partialState.contractTree,
+      'ContractTree',
+    );
+    this.validateSimulatedTree(
+      treeSnapshots.get(MerkleTreeId.PUBLIC_DATA_TREE)!,
+      partialState.publicDataTree,
+      'PublicDataTree',
+    );
   }
 
   protected async validateState(state: StateReference) {
-    await Promise.all([
-      this.validateSimulatedTree(
-        await this.getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
-        state.l1ToL2MessageTree,
-        'L1ToL2MessageTree',
-      ),
-      this.validatePartialState(state.partial),
-    ]);
+    const promises = [
+      MerkleTreeId.NOTE_HASH_TREE,
+      MerkleTreeId.CONTRACT_TREE,
+      MerkleTreeId.NULLIFIER_TREE,
+      MerkleTreeId.PUBLIC_DATA_TREE,
+    ].map(async (id: MerkleTreeId) => {
+      return { key: id, value: await this.getTreeSnapshot(id) };
+    });
+    const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
+      (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
+    );
+    this.validatePartialState(state.partial, snapshots);
+    this.validateSimulatedTree(
+      await this.getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+      state.l1ToL2MessageTree,
+      'L1ToL2MessageTree',
+    );
   }
 
   // Validate that the roots of all local trees match the output of the root circuit simulation

package/src/client/sequencer-client.ts

@@ -1,7 +1,10 @@
 import { ContractDataSource, L1ToL2MessageSource, L2BlockSource } from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
 import { P2P } from '@aztec/p2p';
 import { WorldStateSynchronizer } from '@aztec/world-state';
 
+import * as fs from 'fs/promises';
+
 import { SoloBlockBuilder } from '../block_builder/solo_block_builder.js';
 import { SequencerClientConfig } from '../config.js';
 import { getGlobalVariableBuilder } from '../global_variable_builder/index.js';
@@ -10,7 +13,32 @@ import { EmptyRollupProver } from '../prover/empty.js';
 import { getL1Publisher } from '../publisher/index.js';
 import { Sequencer, SequencerConfig } from '../sequencer/index.js';
 import { PublicProcessorFactory } from '../sequencer/public_processor.js';
+import { NativeACVMSimulator } from '../simulator/acvm_native.js';
+import { WASMSimulator } from '../simulator/acvm_wasm.js';
 import { RealRollupCircuitSimulator } from '../simulator/rollup.js';
+import { SimulationProvider } from '../simulator/simulation_provider.js';
+
+const logger = createDebugLogger('aztec:sequencer-client');
+
+/**
+ * Factory function to create a simulation provider. Will attempt to use native binary simulation falling back to WASM if unavailable.
+ * @param config - The provided sequencer client configuration
+ * @returns The constructed simulation provider
+ */
+async function getSimulationProvider(config: SequencerClientConfig): Promise<SimulationProvider> {
+  if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
+    try {
+      await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
+      await fs.mkdir(config.acvmWorkingDirectory, { recursive: true });
+      logger(`Using native ACVM at ${config.acvmBinaryPath}`);
+      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath);
+    } catch {
+      logger(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
+    }
+  }
+  logger('Using WASM ACVM simulation');
+  return new WASMSimulator();
+}
 
 /**
  * Encapsulates the full sequencer and publisher.
@@ -40,14 +68,21 @@ export class SequencerClient {
     const globalsBuilder = getGlobalVariableBuilder(config);
     const merkleTreeDb = worldStateSynchronizer.getLatest();
 
+    const simulationProvider = await getSimulationProvider(config);
+
     const blockBuilder = new SoloBlockBuilder(
       merkleTreeDb,
       getVerificationKeys(),
-      new RealRollupCircuitSimulator(),
+      new RealRollupCircuitSimulator(simulationProvider),
       new EmptyRollupProver(),
     );
 
-    const publicProcessorFactory = new PublicProcessorFactory(merkleTreeDb, contractDataSource, l1ToL2MessageSource);
+    const publicProcessorFactory = new PublicProcessorFactory(
+      merkleTreeDb,
+      contractDataSource,
+      l1ToL2MessageSource,
+      simulationProvider,
+    );
 
     const sequencer = new Sequencer(
       publisher,

package/src/config.ts

@@ -48,6 +48,8 @@ export function getConfigEnvVars(): SequencerClientConfig {
     OUTBOX_CONTRACT_ADDRESS,
     COINBASE,
     FEE_RECIPIENT,
+    ACVM_WORKING_DIRECTORY,
+    ACVM_BINARY_PATH,
   } = process.env;
 
   const publisherPrivateKey: Hex = SEQ_PUBLISHER_PRIVATE_KEY
@@ -82,5 +84,7 @@ export function getConfigEnvVars(): SequencerClientConfig {
     // TODO: undefined should not be allowed for the following 2 values in PROD
     coinbase: COINBASE ? EthAddress.fromString(COINBASE) : undefined,
     feeRecipient: FEE_RECIPIENT ? AztecAddress.fromString(FEE_RECIPIENT) : undefined,
+    acvmWorkingDirectory: ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : undefined,
+    acvmBinaryPath: ACVM_BINARY_PATH ? ACVM_BINARY_PATH : undefined,
   };
 }

package/src/index.ts

@@ -12,4 +12,6 @@ export * from './global_variable_builder/index.js';
 export { RealRollupCircuitSimulator } from './simulator/rollup.js';
 export { EmptyRollupProver } from './prover/empty.js';
 export { SoloBlockBuilder } from './block_builder/solo_block_builder.js';
+export { WASMSimulator } from './simulator/acvm_wasm.js';
+export { SimulationProvider } from './simulator/simulation_provider.js';
 export { makeProcessedTx, makeEmptyProcessedTx } from './sequencer/processed_tx.js';

package/src/publisher/l1-publisher.ts

@@ -172,15 +172,15 @@ export class L1Publisher implements L2BlockReceiver {
       }
 
       if (receipt.status) {
-        let txsHash;
+        let txsEffectsHash;
         if (receipt.logs.length === 1) {
-          // txsHash from IAvailabilityOracle.TxsPublished event
-          txsHash = receipt.logs[0].data;
+          // txsEffectsHash from IAvailabilityOracle.TxsPublished event
+          txsEffectsHash = receipt.logs[0].data;
         } else {
           this.log(`Expected 1 log, got ${receipt.logs.length}`);
         }
 
-        this.log.info(`Block txs effects published, txsHash: ${txsHash}`);
+        this.log.info(`Block txs effects published, txsEffectsHash: ${txsEffectsHash}`);
         break;
       }
 

package/src/publisher/viem-tx-sender.ts

@@ -87,7 +87,7 @@ export class ViemTxSender implements L1PublisherTxSender {
   }
 
   checkIfTxsAreAvailable(block: L2Block): Promise<boolean> {
-    const args = [`0x${block.body.getCalldataHash().toString('hex')}`] as const;
+    const args = [`0x${block.body.getTxsEffectsHash().toString('hex')}`] as const;
     return this.availabilityOracleContract.read.isAvailable(args);
   }
 

package/src/sequencer/public_processor.ts

@@ -11,6 +11,7 @@ import { PublicProver } from '../prover/index.js';
 import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
 import { RealPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
+import { SimulationProvider } from '../simulator/simulation_provider.js';
 import { AbstractPhaseManager } from './abstract_phase_manager.js';
 import { PhaseManagerFactory } from './phase_manager_factory.js';
 import { FailedTx, ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
@@ -23,6 +24,7 @@ export class PublicProcessorFactory {
     private merkleTree: MerkleTreeOperations,
     private contractDataSource: ContractDataSource,
     private l1Tol2MessagesDataSource: L1ToL2MessageSource,
+    private simulator: SimulationProvider,
   ) {}
 
   /**
@@ -45,7 +47,7 @@ export class PublicProcessorFactory {
     return new PublicProcessor(
       this.merkleTree,
       publicExecutor,
-      new RealPublicKernelCircuitSimulator(),
+      new RealPublicKernelCircuitSimulator(this.simulator),
       new EmptyPublicProver(),
       globalVariables,
       historicalHeader,

package/src/sequencer/sequencer.ts

@@ -255,12 +255,12 @@ export class Sequencer {
       return;
     }
 
-    const blockCalldataHash = block.body.getCalldataHash();
+    const txsEffectsHash = block.body.getTxsEffectsHash();
     this.log.info(`Publishing ${newContracts.length} contracts in block ${block.number}`);
 
     const publishedContractData = await this.publisher.processNewContractData(
       block.number,
-      blockCalldataHash,
+      txsEffectsHash,
       newContracts,
     );
 

package/src/simulator/acvm_native.ts

@@ -0,0 +1,112 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { WitnessMap } from '@noir-lang/types';
+import * as proc from 'child_process';
+import fs from 'fs/promises';
+
+import { SimulationProvider } from './simulation_provider.js';
+
+/**
+ * Parses a TOML format witness map string into a Map structure
+ * @param outputString - The witness map in TOML format
+ * @returns The parsed witness map
+ */
+function parseIntoWitnessMap(outputString: string) {
+  const lines = outputString.split('\n');
+  return new Map<number, string>(
+    lines
+      .filter((line: string) => line.length)
+      .map((line: string) => {
+        const pair = line.replaceAll(' ', '').split('=');
+        return [Number(pair[0]), pair[1].replaceAll('"', '')];
+      }),
+  );
+}
+
+/**
+ *
+ * @param inputWitness - The circuit's input witness
+ * @param bytecode - The circuit buytecode
+ * @param workingDirectory - A directory to use for temporary files by the ACVM
+ * @param pathToAcvm - The path to the ACVm binary
+ * @returns The completed partial witness outputted from the circuit
+ */
+export async function executeNativeCircuit(
+  inputWitness: WitnessMap,
+  bytecode: Buffer,
+  workingDirectory: string,
+  pathToAcvm: string,
+) {
+  const bytecodeFilename = 'bytecode';
+  const witnessFilename = 'input_witness.toml';
+
+  // convert the witness map to TOML format
+  let witnessMap = '';
+  inputWitness.forEach((value: string, key: number) => {
+    witnessMap = witnessMap.concat(`${key} = '${value}'\n`);
+  });
+
+  // In case the directory is still around from some time previously, remove it
+  await fs.rm(workingDirectory, { recursive: true, force: true });
+  // Create the new working directory
+  await fs.mkdir(workingDirectory, { recursive: true });
+  // Write the bytecode and input witness to the working directory
+  await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
+  await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
+
+  // Execute the ACVM using the given args
+  const args = [
+    `execute`,
+    `--working-directory`,
+    `${workingDirectory}`,
+    `--bytecode`,
+    `${bytecodeFilename}`,
+    `--input-witness`,
+    `${witnessFilename}`,
+    `--print`,
+  ];
+  const processPromise = new Promise<string>((resolve, reject) => {
+    let outputWitness = Buffer.alloc(0);
+    let errorBuffer = Buffer.alloc(0);
+    const acvm = proc.spawn(pathToAcvm, args);
+    acvm.stdout.on('data', data => {
+      outputWitness = Buffer.concat([outputWitness, data]);
+    });
+    acvm.stderr.on('data', data => {
+      errorBuffer = Buffer.concat([errorBuffer, data]);
+    });
+    acvm.on('close', code => {
+      if (code === 0) {
+        resolve(outputWitness.toString('utf-8'));
+      } else {
+        reject(errorBuffer.toString('utf-8'));
+      }
+    });
+  });
+
+  try {
+    const output = await processPromise;
+    return parseIntoWitnessMap(output);
+  } finally {
+    // Clean up the working directory before we leave
+    await fs.rm(workingDirectory, { recursive: true, force: true });
+  }
+}
+
+export class NativeACVMSimulator implements SimulationProvider {
+  constructor(private workingDirectory: string, private pathToAcvm: string) {}
+  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    // Execute the circuit on those initial witness values
+
+    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+
+    // Provide a unique working directory so we don't get clashes with parallel executions
+    const directory = `${this.workingDirectory}/${randomBytes(32).toString('hex')}`;
+    // Execute the circuit
+    const _witnessMap = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm);
+
+    return _witnessMap;
+  }
+}

package/src/simulator/acvm_wasm.ts

@@ -0,0 +1,31 @@
+import { NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { WasmBlackBoxFunctionSolver, createBlackBoxSolver, executeCircuitWithBlackBoxSolver } from '@noir-lang/acvm_js';
+import { WitnessMap } from '@noir-lang/types';
+
+import { SimulationProvider } from './simulation_provider.js';
+
+let solver: Promise<WasmBlackBoxFunctionSolver>;
+
+const getSolver = (): Promise<WasmBlackBoxFunctionSolver> => {
+  if (!solver) {
+    solver = createBlackBoxSolver();
+  }
+  return solver;
+};
+
+export class WASMSimulator implements SimulationProvider {
+  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    // Execute the circuit on those initial witness values
+    //
+    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+    //
+    // Execute the circuit
+    const _witnessMap = await executeCircuitWithBlackBoxSolver(await getSolver(), decodedBytecode, input, () => {
+      throw Error('unexpected oracle during execution');
+    });
+
+    return _witnessMap;
+  }
+}

package/src/simulator/index.ts

@@ -55,3 +55,4 @@ export interface PublicKernelCircuitSimulator {
    */
   publicKernelCircuitTeardown(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
 }
+export * from './acvm_wasm.js';

package/src/simulator/public_kernel.ts

@@ -3,12 +3,19 @@ import { PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs } fro
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
-  executePublicKernelAppLogic,
-  executePublicKernelSetup,
-  executePublicKernelTeardown,
+  PublicKernelAppLogicArtifact,
+  PublicKernelSetupArtifact,
+  PublicKernelTeardownArtifact,
+  convertPublicInnerRollupInputsToWitnessMap,
+  convertPublicInnerRollupOutputFromWitnessMap,
+  convertPublicSetupRollupInputsToWitnessMap,
+  convertPublicSetupRollupOutputFromWitnessMap,
+  convertPublicTailRollupInputsToWitnessMap,
+  convertPublicTailRollupOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 
-import { PublicKernelCircuitSimulator } from './index.js';
+import { PublicKernelCircuitSimulator, WASMSimulator } from './index.js';
+import { SimulationProvider } from './simulation_provider.js';
 
 /**
  * Implements the PublicKernelCircuitSimulator.
@@ -16,6 +23,11 @@ import { PublicKernelCircuitSimulator } from './index.js';
 export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimulator {
   private log = createDebugLogger('aztec:public-kernel-simulator');
 
+  // Some circuits are so small it is faster to use WASM
+  private wasmSimulator: WASMSimulator = new WASMSimulator();
+
+  constructor(private simulator: SimulationProvider) {}
+
   /**
    * Simulates the public kernel setup circuit from its inputs.
    * @param input - Inputs to the circuit.
@@ -27,7 +39,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsSetup) {
       throw new Error(`Expected previous kernel inputs to need setup`);
     }
-    const [duration, result] = await elapsed(() => executePublicKernelSetup(input));
+    const inputWitness = convertPublicSetupRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelSetupArtifact),
+    );
+    const result = convertPublicSetupRollupOutputFromWitnessMap(witness);
     this.log(`Simulated public kernel setup circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-setup',
@@ -49,7 +65,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsAppLogic) {
       throw new Error(`Expected previous kernel inputs to need app logic`);
     }
-    const [duration, result] = await elapsed(() => executePublicKernelAppLogic(input));
+    const inputWitness = convertPublicInnerRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelAppLogicArtifact),
+    );
+    const result = convertPublicInnerRollupOutputFromWitnessMap(witness);
     this.log(`Simulated public kernel app logic circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-app-logic',
@@ -71,7 +91,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsTeardown) {
       throw new Error(`Expected previous kernel inputs to need teardown`);
     }
-    const [duration, result] = await elapsed(() => executePublicKernelTeardown(input));
+    const inputWitness = convertPublicTailRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTeardownArtifact),
+    );
+    const result = convertPublicTailRollupOutputFromWitnessMap(witness);
     this.log(`Simulated public kernel teardown circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-teardown',