@aztec/bb-prover 0.67.1 → 0.68.0

package/src/bb/execute.ts

@@ -889,6 +889,7 @@ export async function computeGateCountForCircuit(
   circuitName: string,
   bytecode: Buffer,
   flavor: UltraHonkFlavor | 'mega_honk',
+  log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
   try {
@@ -912,6 +913,7 @@ export async function computeGateCountForCircuit(
   let stdout = '';
   const logHandler = (message: string) => {
     stdout += message;
+    log(message);
   };
 
   try {
@@ -921,7 +923,7 @@ export async function computeGateCountForCircuit(
 
     const result = await executeBB(
       pathToBB,
-      flavor === 'mega_honk' ? `gates_mega_honk` : `gates`,
+      flavor === 'mega_honk' ? `gates_for_ivc` : `gates`,
       ['-b', bytecodePath, '-v'],
       logHandler,
     );

package/src/prover/bb_private_kernel_prover.ts

@@ -1,22 +1,14 @@
+import { type PrivateKernelProver, type PrivateKernelSimulateOutput } from '@aztec/circuit-types';
+import { type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
-  type AppCircuitSimulateOutput,
-  type PrivateKernelProver,
-  type PrivateKernelSimulateOutput,
-} from '@aztec/circuit-types';
-import { type CircuitSimulationStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
-import {
-  AGGREGATION_OBJECT_LENGTH,
-  ClientIvcProof,
-  Fr,
+  type ClientIvcProof,
   type PrivateKernelCircuitPublicInputs,
   type PrivateKernelInitCircuitPrivateInputs,
   type PrivateKernelInnerCircuitPrivateInputs,
   type PrivateKernelResetCircuitPrivateInputs,
   type PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
-  Proof,
-  RecursiveProof,
-  type VerificationKeyAsFields,
+  type Proof,
   type VerificationKeyData,
 } from '@aztec/circuits.js';
 import { runInDirectory } from '@aztec/foundation/fs';
@@ -39,7 +31,7 @@ import {
   convertPrivateKernelTailToPublicInputsToWitnessMap,
   getPrivateKernelResetArtifactName,
 } from '@aztec/noir-protocol-circuits-types';
-import { WASMSimulator } from '@aztec/simulator';
+import { WASMSimulatorWithBlobs } from '@aztec/simulator';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { encode } from '@msgpack/msgpack';
@@ -48,19 +40,12 @@ import { type WitnessMap } from '@noir-lang/types';
 import { promises as fs } from 'fs';
 import path from 'path';
 
-import {
-  BB_RESULT,
-  PROOF_FIELDS_FILENAME,
-  PROOF_FILENAME,
-  computeGateCountForCircuit,
-  computeVerificationKey,
-  executeBbClientIvcProof,
-  verifyProof,
-} from '../bb/execute.js';
+import { BB_RESULT, computeGateCountForCircuit, executeBbClientIvcProof, verifyProof } from '../bb/execute.js';
 import { type BBConfig } from '../config.js';
 import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../honk.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
+import { readFromOutputDirectory } from './client_ivc_proof_utils.js';
 
 /**
  * This proof creator implementation uses the native bb binary.
@@ -68,7 +53,7 @@ import { extractVkData } from '../verification_key/verification_key_data.js';
  * TODO(#7368): this class grew 'organically' aka it could use a look at its resposibilities
  */
 export class BBNativePrivateKernelProver implements PrivateKernelProver {
-  private simulator = new WASMSimulator();
+  private simulator = new WASMSimulatorWithBlobs();
 
   private verificationKeys: Map<ClientProtocolArtifact, Promise<VerificationKeyData>> = new Map<
     ClientProtocolArtifact,
@@ -112,7 +97,7 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
       throw new Error(provingResult.reason);
     }
 
-    const proof = await ClientIvcProof.readFromOutputDirectory(directory);
+    const proof = await readFromOutputDirectory(directory);
 
     this.log.info(`Generated IVC proof`, {
       duration: provingResult.durationMs,
@@ -184,22 +169,6 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     );
   }
 
-  public async computeAppCircuitVerificationKey(
-    bytecode: Buffer,
-    appCircuitName?: string,
-  ): Promise<AppCircuitSimulateOutput> {
-    const operation = async (directory: string) => {
-      this.log.debug(`Proving app circuit`);
-      // App circuits are always recursive; the #[recursive] attribute used to be applied automatically
-      // by the `private` comptime macro in noir-projects/aztec-nr/aztec/src/macros/functions/mod.nr
-      // Yet, inside `computeVerificationKey` the `mega_honk` flavor is used, which doesn't use the recursive flag.
-      const recursive = true;
-      return await this.computeVerificationKey(directory, bytecode, recursive, 'App', appCircuitName);
-    };
-
-    return await this.runInDirectory(operation);
-  }
-
   /**
    * Verifies a proof, will generate the verification key if one is not cached internally
    * @param circuitType - The type of circuit whose proof is to be verified
@@ -230,12 +199,17 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
   }
 
   public async computeGateCountForCircuit(bytecode: Buffer, circuitName: string): Promise<number> {
+    const logFunction = (message: string) => {
+      this.log.debug(`$bb gates ${circuitName} - ${message}`);
+    };
+
     const result = await computeGateCountForCircuit(
       this.bbBinaryPath,
       this.bbWorkingDirectory,
       circuitName,
       bytecode,
       'mega_honk',
+      logFunction,
     );
     if (result.status === BB_RESULT.FAILURE) {
       throw new Error(result.reason);
@@ -313,99 +287,6 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     return kernelOutput;
   }
 
-  private async computeVerificationKey(
-    directory: string,
-    bytecode: Buffer,
-    recursive: boolean,
-    circuitType: ClientProtocolArtifact | 'App',
-    appCircuitName?: string,
-  ): Promise<{
-    verificationKey: VerificationKeyAsFields;
-  }> {
-    const dbgCircuitName = appCircuitName ? `(${appCircuitName})` : '';
-    this.log.info(`Computing VK of ${circuitType}${dbgCircuitName} circuit...`);
-
-    const timer = new Timer();
-
-    const vkResult = await computeVerificationKey(
-      this.bbBinaryPath,
-      directory,
-      circuitType,
-      bytecode,
-      recursive,
-      circuitType === 'App' ? 'mega_honk' : getUltraHonkFlavorForCircuit(circuitType),
-      this.log.debug,
-    );
-
-    if (vkResult.status === BB_RESULT.FAILURE) {
-      this.log.error(`Failed to generate verification key for ${circuitType}${dbgCircuitName}: ${vkResult.reason}`);
-      throw new Error(vkResult.reason);
-    }
-
-    this.log.info(`Generated ${circuitType}${dbgCircuitName} VK in ${Math.ceil(timer.ms())} ms`);
-
-    if (circuitType === 'App') {
-      const vkData = await extractVkData(directory);
-
-      this.log.debug(`Computed verification key`, {
-        circuitName: 'app-circuit',
-        duration: vkResult.durationMs,
-        eventName: 'circuit-simulation',
-        inputSize: bytecode.length,
-        outputSize: vkData.keyAsBytes.length,
-        circuitSize: vkData.circuitSize,
-        numPublicInputs: vkData.numPublicInputs,
-      } as CircuitSimulationStats);
-
-      return { verificationKey: vkData.keyAsFields };
-    }
-
-    const vkData = await this.updateVerificationKeyAfterSimulation(directory, circuitType);
-
-    this.log.debug(`Computed verification key`, {
-      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-      duration: vkResult.durationMs,
-      eventName: 'circuit-simulation',
-      inputSize: bytecode.length,
-      outputSize: vkData.keyAsBytes.length,
-      circuitSize: vkData.circuitSize,
-      numPublicInputs: vkData.numPublicInputs,
-    } as CircuitSimulationStats);
-
-    return { verificationKey: vkData.keyAsFields };
-  }
-
-  /**
-   * Parses and returns the proof data stored at the specified directory
-   * @param filePath - The directory containing the proof data
-   * @param circuitType - The type of circuit proven
-   * @returns The proof
-   */
-  private async readProofAsFields<PROOF_LENGTH extends number>(
-    filePath: string,
-    circuitType: ClientProtocolArtifact | 'App',
-    vkData: VerificationKeyData,
-  ): Promise<RecursiveProof<PROOF_LENGTH>> {
-    const [binaryProof, proofString] = await Promise.all([
-      fs.readFile(`${filePath}/${PROOF_FILENAME}`),
-      fs.readFile(`${filePath}/${PROOF_FIELDS_FILENAME}`, { encoding: 'utf-8' }),
-    ]);
-    const json = JSON.parse(proofString);
-    const fields = json.map(Fr.fromHexString);
-    const numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-    const fieldsWithoutPublicInputs = fields.slice(numPublicInputs);
-    this.log.info(
-      `Circuit type: ${circuitType}, complete proof length: ${fields.length}, without public inputs: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`,
-    );
-    const proof = new RecursiveProof<PROOF_LENGTH>(
-      fieldsWithoutPublicInputs,
-      new Proof(binaryProof, vkData.numPublicInputs),
-      true,
-      fieldsWithoutPublicInputs.length,
-    );
-    return proof;
-  }
-
   private runInDirectory<T>(fn: (dir: string) => Promise<T>) {
     const log = this.log;
     return runInDirectory(

package/src/prover/bb_prover.ts

@@ -12,35 +12,37 @@ import {
   AGGREGATION_OBJECT_LENGTH,
   AVM_PROOF_LENGTH_IN_FIELDS,
   type AvmCircuitInputs,
-  type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
-  type BlockMergeRollupInputs,
-  type BlockRootOrBlockMergePublicInputs,
-  type BlockRootRollupInputs,
-  type EmptyBlockRootRollupInputs,
   EmptyNestedCircuitInputs,
   EmptyNestedData,
   Fr,
   type KernelCircuitPublicInputs,
-  type MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
   type ParityPublicInputs,
-  type PrivateBaseRollupInputs,
   type PrivateKernelEmptyInputData,
   PrivateKernelEmptyInputs,
   Proof,
-  type PublicBaseRollupInputs,
   RECURSIVE_PROOF_LENGTH,
   RecursiveProof,
   type RootParityInputs,
-  type RootRollupInputs,
-  type RootRollupPublicInputs,
   TUBE_PROOF_LENGTH,
-  type TubeInputs,
   type VerificationKeyAsFields,
   type VerificationKeyData,
   makeRecursiveProofFromBinary,
 } from '@aztec/circuits.js';
+import {
+  type BaseOrMergeRollupPublicInputs,
+  type BlockMergeRollupInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  type BlockRootRollupInputs,
+  type EmptyBlockRootRollupInputs,
+  type MergeRollupInputs,
+  type PrivateBaseRollupInputs,
+  type PublicBaseRollupInputs,
+  type RootRollupInputs,
+  type RootRollupPublicInputs,
+  type TubeInputs,
+} from '@aztec/circuits.js/rollup';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
@@ -99,6 +101,7 @@ import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../honk.js';
 import { ProverInstrumentation } from '../instrumentation.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractAvmVkData, extractVkData } from '../verification_key/verification_key_data.js';
+import { writeToOutputDirectory } from './client_ivc_proof_utils.js';
 
 const logger = createLogger('bb-prover');
 
@@ -551,7 +554,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     const hasher = crypto.createHash('sha256');
     hasher.update(input.toBuffer());
 
-    await input.clientIVCData.writeToOutputDirectory(bbWorkingDirectory);
+    await writeToOutputDirectory(input.clientIVCData, bbWorkingDirectory);
     const provingResult = await generateTubeProof(this.config.bbBinaryPath, bbWorkingDirectory, logger.verbose);
 
     if (provingResult.status === BB_RESULT.FAILURE) {

package/src/prover/client_ivc_proof_utils.ts

@@ -0,0 +1,39 @@
+import { ClientIvcProof } from '@aztec/circuits.js';
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+
+/**
+ * TODO(#7371): eventually remove client_ivc_prove_output_all_msgpack and properly handle these accumulators and VKs
+ * Create a ClientIvcProof from the result of client_ivc_prove_output_all or client_ivc_prove_output_all_msgpack
+ * @param directory the directory of results
+ * @returns the encapsulated client ivc proof
+ */
+export async function readFromOutputDirectory(directory: string) {
+  const [clientIvcVkBuffer, clientIvcProofBuffer] = await Promise.all(
+    ['client_ivc_vk', 'client_ivc_proof'].map(fileName => fs.readFile(join(directory, fileName))),
+  );
+  return new ClientIvcProof(clientIvcProofBuffer, clientIvcVkBuffer);
+}
+
+/**
+ * TODO(#7371): eventually remove client_ivc_prove_output_all_msgpack and properly handle these accumulators and VKs
+ * Serialize a ClientIvcProof to the files expected by prove_tube
+ *
+ * Example usage:
+ *  await runInDirectory(bbWorkingDirectory, async (dir: string) => {
+ *    await privateTx.clientIvcProof!.writeToOutputDirectory(bbWorkingDirectory);
+ *    const result = await generateTubeProof(bbPath, dir, logger.info)
+ *    expect(result.status).toBe(BB_RESULT.SUCCESS)
+ *  });
+ * @param proof the ClientIvcProof from readFromOutputDirectory
+ * @param directory the directory of results
+ */
+export async function writeToOutputDirectory(clientIvcProof: ClientIvcProof, directory: string) {
+  const { clientIvcProofBuffer, clientIvcVkBuffer } = clientIvcProof;
+  const fileData = [
+    ['client_ivc_proof', clientIvcProofBuffer],
+    ['client_ivc_vk', clientIvcVkBuffer],
+  ] as const;
+  await Promise.all(fileData.map(([fileName, buffer]) => fs.writeFile(join(directory, fileName), buffer)));
+}

package/src/prover/index.ts

@@ -1,2 +1,3 @@
 export * from './bb_prover.js';
 export * from './bb_private_kernel_prover.js';
+export * from './client_ivc_proof_utils.js';

package/src/test/test_circuit_prover.ts

@@ -9,32 +9,34 @@ import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   type AvmCircuitInputs,
-  type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
-  type BlockMergeRollupInputs,
-  type BlockRootOrBlockMergePublicInputs,
-  type BlockRootRollupInputs,
-  type EmptyBlockRootRollupInputs,
   EmptyNestedData,
   type KernelCircuitPublicInputs,
-  type MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
   type ParityPublicInputs,
-  type PrivateBaseRollupInputs,
   type PrivateKernelEmptyInputData,
   PrivateKernelEmptyInputs,
   type Proof,
-  type PublicBaseRollupInputs,
   RECURSIVE_PROOF_LENGTH,
   type RootParityInputs,
-  type RootRollupInputs,
-  type RootRollupPublicInputs,
   TUBE_PROOF_LENGTH,
-  type TubeInputs,
   VerificationKeyData,
   makeEmptyRecursiveProof,
   makeRecursiveProof,
 } from '@aztec/circuits.js';
+import {
+  type BaseOrMergeRollupPublicInputs,
+  type BlockMergeRollupInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  type BlockRootRollupInputs,
+  type EmptyBlockRootRollupInputs,
+  type MergeRollupInputs,
+  type PrivateBaseRollupInputs,
+  type PublicBaseRollupInputs,
+  type RootRollupInputs,
+  type RootRollupPublicInputs,
+  type TubeInputs,
+} from '@aztec/circuits.js/rollup';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
@@ -46,8 +48,6 @@ import {
   convertBaseParityOutputsFromWitnessMap,
   convertBlockMergeRollupInputsToWitnessMap,
   convertBlockMergeRollupOutputsFromWitnessMap,
-  convertBlockRootRollupInputsToWitnessMap,
-  convertBlockRootRollupOutputsFromWitnessMap,
   convertEmptyBlockRootRollupInputsToWitnessMap,
   convertEmptyBlockRootRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
@@ -57,13 +57,15 @@ import {
   convertRootParityOutputsFromWitnessMap,
   convertRootRollupInputsToWitnessMap,
   convertRootRollupOutputsFromWitnessMap,
+  convertSimulatedBlockRootRollupInputsToWitnessMap,
+  convertSimulatedBlockRootRollupOutputsFromWitnessMap,
   convertSimulatedPrivateBaseRollupInputsToWitnessMap,
   convertSimulatedPrivateBaseRollupOutputsFromWitnessMap,
   convertSimulatedPrivateKernelEmptyOutputsFromWitnessMap,
   convertSimulatedPublicBaseRollupInputsToWitnessMap,
   convertSimulatedPublicBaseRollupOutputsFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
-import { type SimulationProvider, WASMSimulator, emitCircuitSimulationStats } from '@aztec/simulator';
+import { type SimulationProvider, WASMSimulatorWithBlobs, emitCircuitSimulationStats } from '@aztec/simulator';
 import { type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { type WitnessMap } from '@noir-lang/types';
@@ -76,7 +78,7 @@ import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
  * Simulates circuits using the most efficient method and performs no proving.
  */
 export class TestCircuitProver implements ServerCircuitProver {
-  private wasmSimulator = new WASMSimulator();
+  private wasmSimulator = new WASMSimulatorWithBlobs();
   private instrumentation: ProverInstrumentation;
   private logger = createLogger('bb-prover:test-prover');
 
@@ -215,8 +217,8 @@ export class TestCircuitProver implements ServerCircuitProver {
       input,
       'BlockRootRollupArtifact',
       NESTED_RECURSIVE_PROOF_LENGTH,
-      convertBlockRootRollupInputsToWitnessMap,
-      convertBlockRootRollupOutputsFromWitnessMap,
+      convertSimulatedBlockRootRollupInputsToWitnessMap,
+      convertSimulatedBlockRootRollupOutputsFromWitnessMap,
     );
   }
 
@@ -313,7 +315,12 @@ export class TestCircuitProver implements ServerCircuitProver {
     const witnessMap = convertInput(input);
     const circuitName = mapProtocolArtifactNameToCircuitName(artifactName);
 
-    const simulationProvider = this.simulationProvider ?? this.wasmSimulator;
+    let simulationProvider = this.simulationProvider ?? this.wasmSimulator;
+    if (artifactName == 'BlockRootRollupArtifact') {
+      // TODO(#10323): temporarily force block root to use wasm while we simulate
+      // the blob operations with an oracle. Appears to be no way to provide nativeACVM with a foreign call hander.
+      simulationProvider = this.wasmSimulator;
+    }
     const witness = await simulationProvider.simulateCircuit(witnessMap, SimulatedServerCircuitArtifacts[artifactName]);
 
     const result = convertOutput(witness);

package/src/verifier/bb_verifier.ts

@@ -23,6 +23,7 @@ import {
 } from '../bb/execute.js';
 import { type BBConfig } from '../config.js';
 import { type UltraKeccakHonkProtocolArtifact, getUltraHonkFlavorForCircuit } from '../honk.js';
+import { writeToOutputDirectory } from '../prover/client_ivc_proof_utils.js';
 import { isProtocolArtifactRecursive, mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
 
@@ -162,7 +163,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
           this.logger.debug(`${circuit} BB out - ${message}`);
         };
 
-        await tx.clientIvcProof.writeToOutputDirectory(bbWorkingDirectory);
+        await writeToOutputDirectory(tx.clientIvcProof, bbWorkingDirectory);
         const result = await verifyClientIvcProof(this.config.bbBinaryPath, bbWorkingDirectory, logFunction);
 
         if (result.status === BB_RESULT.FAILURE) {

package/src/wasm/index.ts

@@ -0,0 +1,155 @@
+import { AztecClientBackend } from '@aztec/bb.js';
+import { type PrivateKernelProver, type PrivateKernelSimulateOutput } from '@aztec/circuit-types';
+import {
+  ClientIvcProof,
+  type PrivateKernelCircuitPublicInputs,
+  type PrivateKernelInitCircuitPrivateInputs,
+  type PrivateKernelInnerCircuitPrivateInputs,
+  type PrivateKernelResetCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPublicInputs,
+} from '@aztec/circuits.js';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import {
+  ClientCircuitArtifacts,
+  ClientCircuitVks,
+  type ClientProtocolArtifact,
+  convertPrivateKernelInitInputsToWitnessMap,
+  convertPrivateKernelInitOutputsFromWitnessMap,
+  convertPrivateKernelInnerInputsToWitnessMap,
+  convertPrivateKernelInnerOutputsFromWitnessMap,
+  convertPrivateKernelResetInputsToWitnessMap,
+  convertPrivateKernelResetOutputsFromWitnessMap,
+  convertPrivateKernelTailForPublicOutputsFromWitnessMap,
+  convertPrivateKernelTailInputsToWitnessMap,
+  convertPrivateKernelTailOutputsFromWitnessMap,
+  convertPrivateKernelTailToPublicInputsToWitnessMap,
+  getPrivateKernelResetArtifactName,
+} from '@aztec/noir-protocol-circuits-types/client';
+import { WASMSimulator } from '@aztec/simulator/client';
+import { type NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { type WitnessMap } from '@noir-lang/noir_js';
+import { serializeWitness } from '@noir-lang/noirc_abi';
+import { ungzip } from 'pako';
+
+export class BBWasmPrivateKernelProver implements PrivateKernelProver {
+  private simulator = new WASMSimulator();
+
+  constructor(private threads: number = 1, private log = createLogger('bb-prover:wasm')) {}
+
+  public async simulateProofInit(
+    inputs: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulate(
+      inputs,
+      'PrivateKernelInitArtifact',
+      convertPrivateKernelInitInputsToWitnessMap,
+      convertPrivateKernelInitOutputsFromWitnessMap,
+    );
+  }
+
+  public async simulateProofInner(
+    inputs: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulate(
+      inputs,
+      'PrivateKernelInnerArtifact',
+      convertPrivateKernelInnerInputsToWitnessMap,
+      convertPrivateKernelInnerOutputsFromWitnessMap,
+    );
+  }
+
+  public async simulateProofReset(
+    inputs: PrivateKernelResetCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    const variantInputs = inputs.trimToSizes();
+    const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
+    return await this.simulate(
+      variantInputs,
+      artifactName,
+      variantInputs => convertPrivateKernelResetInputsToWitnessMap(variantInputs, artifactName),
+      output => convertPrivateKernelResetOutputsFromWitnessMap(output, artifactName),
+    );
+  }
+
+  public async simulateProofTail(
+    inputs: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (!inputs.isForPublic()) {
+      return await this.simulate(
+        inputs,
+        'PrivateKernelTailArtifact',
+        convertPrivateKernelTailInputsToWitnessMap,
+        convertPrivateKernelTailOutputsFromWitnessMap,
+      );
+    }
+    return await this.simulate(
+      inputs,
+      'PrivateKernelTailToPublicArtifact',
+      convertPrivateKernelTailToPublicInputsToWitnessMap,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMap,
+    );
+  }
+
+  private async simulate<
+    I extends { toBuffer: () => Buffer },
+    O extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
+  >(
+    inputs: I,
+    circuitType: ClientProtocolArtifact,
+    convertInputs: (inputs: I) => WitnessMap,
+    convertOutputs: (outputs: WitnessMap) => O,
+  ): Promise<PrivateKernelSimulateOutput<O>> {
+    this.log.debug(`Generating witness for ${circuitType}`);
+    const compiledCircuit: NoirCompiledCircuit = ClientCircuitArtifacts[circuitType];
+
+    const witnessMap = convertInputs(inputs);
+    const timer = new Timer();
+    const outputWitness = await this.simulator.simulateCircuit(witnessMap, compiledCircuit);
+    const output = convertOutputs(outputWitness);
+
+    this.log.debug(`Generated witness for ${circuitType}`, {
+      eventName: 'circuit-witness-generation',
+      circuitName: circuitType,
+      duration: timer.ms(),
+      inputSize: inputs.toBuffer().length,
+      outputSize: output.toBuffer().length,
+    });
+
+    const verificationKey = ClientCircuitVks[circuitType].keyAsFields;
+    const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+
+    const kernelOutput: PrivateKernelSimulateOutput<O> = {
+      publicInputs: output,
+      verificationKey,
+      outputWitness,
+      bytecode,
+    };
+    return kernelOutput;
+  }
+
+  async createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+    const timer = new Timer();
+    this.log.info(`Generating ClientIVC proof...`);
+    const backend = new AztecClientBackend(
+      acirs.map(acir => ungzip(acir)),
+      { threads: this.threads },
+    );
+
+    const [proof, vk] = await backend.prove(witnessStack.map(witnessMap => ungzip(serializeWitness(witnessMap))));
+    await backend.destroy();
+    this.log.info(`Generated ClientIVC proof`, {
+      eventName: 'client-ivc-proof-generation',
+      duration: timer.ms(),
+      proofSize: proof.length,
+      vkSize: vk.length,
+    });
+    return new ClientIvcProof(Buffer.from(proof), Buffer.from(vk));
+  }
+
+  computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number> {
+    return Promise.resolve(0);
+  }
+}