@aztec/bb-prover 0.0.0-test.0

package/src/bb/index.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env -S node --no-warnings
+import { createConsoleLogger } from '@aztec/foundation/log';
+
+import 'source-map-support/register.js';
+
+import { getProgram } from './cli.js';
+
+const log = createConsoleLogger();
+
+/** CLI main entrypoint */
+async function main() {
+  process.once('SIGINT', () => process.exit(0));
+  process.once('SIGTERM', () => process.exit(0));
+
+  const program = getProgram(log);
+  await program.parseAsync(process.argv);
+}
+
+main().catch(err => {
+  log(`Error in command execution`);
+  log(err);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,13 @@
+export interface BBConfig {
+  bbBinaryPath: string;
+  bbWorkingDirectory: string;
+  /** Whether to skip tmp dir cleanup for debugging purposes */
+  bbSkipCleanup: boolean;
+}
+
+export interface ACVMConfig {
+  /** The path to the ACVM binary */
+  acvmBinaryPath: string;
+  /** The working directory to use for simulation/proving */
+  acvmWorkingDirectory: string;
+}

package/src/honk.ts

@@ -0,0 +1,30 @@
+import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
+
+export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_rollup_honk';
+
+const UltraKeccakHonkCircuits = ['RootRollupArtifact'] as const satisfies ServerProtocolArtifact[];
+const UltraHonkCircuits = ['BaseParityArtifact', 'RootParityArtifact'] as const satisfies ServerProtocolArtifact[];
+
+export type UltraKeccakHonkServerProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number];
+export type UltraHonkServerProtocolArtifact = (typeof UltraHonkCircuits)[number];
+export type UltraRollupHonkServerProtocolArtifact = Exclude<
+  Exclude<ServerProtocolArtifact, UltraKeccakHonkServerProtocolArtifact>,
+  UltraHonkServerProtocolArtifact
+>;
+
+export function getUltraHonkFlavorForCircuit(artifact: UltraKeccakHonkServerProtocolArtifact): 'ultra_keccak_honk';
+export function getUltraHonkFlavorForCircuit(artifact: UltraHonkServerProtocolArtifact): 'ultra_honk';
+export function getUltraHonkFlavorForCircuit(artifact: UltraRollupHonkServerProtocolArtifact): 'ultra_rollup_honk';
+export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor;
+export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor {
+  if (isUltraKeccakHonkCircuit(artifact)) {
+    return 'ultra_keccak_honk';
+  } else if (UltraHonkCircuits.includes(artifact as UltraHonkServerProtocolArtifact)) {
+    return 'ultra_honk';
+  }
+  return 'ultra_rollup_honk';
+}
+
+function isUltraKeccakHonkCircuit(artifact: ServerProtocolArtifact): artifact is UltraKeccakHonkServerProtocolArtifact {
+  return UltraKeccakHonkCircuits.includes(artifact as UltraKeccakHonkServerProtocolArtifact);
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './prover/index.js';
+export * from './test/index.js';
+export * from './verifier/index.js';
+export * from './config.js';
+export * from './bb/execute.js';
+export * from './honk.js';
+
+export { type ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';

package/src/instrumentation.ts

@@ -0,0 +1,144 @@
+import type { Timer } from '@aztec/foundation/timer';
+import type { CircuitName } from '@aztec/stdlib/stats';
+import {
+  Attributes,
+  type Gauge,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type Tracer,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+/**
+ * Instrumentation class for Prover implementations.
+ */
+export class ProverInstrumentation {
+  private simulationDuration: Histogram;
+  private witGenDuration: Histogram;
+  private provingDuration: Histogram;
+
+  private witGenInputSize: Gauge;
+  private witGenOutputSize: Gauge;
+
+  private proofSize: Gauge;
+  private circuitSize: Gauge;
+  private circuitPublicInputCount: Gauge;
+
+  public readonly tracer: Tracer;
+
+  constructor(telemetry: TelemetryClient, name: string) {
+    this.tracer = telemetry.getTracer(name);
+    const meter = telemetry.getMeter(name);
+
+    this.simulationDuration = meter.createHistogram(Metrics.CIRCUIT_SIMULATION_DURATION, {
+      description: 'Records how long it takes to simulate a circuit',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.witGenDuration = meter.createHistogram(Metrics.CIRCUIT_WITNESS_GEN_DURATION, {
+      description: 'Records how long it takes to generate the partial witness for a circuit',
+      unit: 's',
+      valueType: ValueType.DOUBLE,
+    });
+
+    this.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION, {
+      unit: 's',
+      description: 'Records how long it takes to prove a circuit',
+      valueType: ValueType.DOUBLE,
+    });
+
+    this.witGenInputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_INPUT_SIZE, {
+      unit: 'By',
+      description: 'Records the size of the input to the witness generation',
+      valueType: ValueType.INT,
+    });
+
+    this.witGenOutputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_OUTPUT_SIZE, {
+      unit: 'By',
+      description: 'Records the size of the output of the witness generation',
+      valueType: ValueType.INT,
+    });
+
+    this.proofSize = meter.createGauge(Metrics.CIRCUIT_PROVING_PROOF_SIZE, {
+      unit: 'By',
+      description: 'Records the size of the proof generated for a circuit',
+      valueType: ValueType.INT,
+    });
+
+    this.circuitPublicInputCount = meter.createGauge(Metrics.CIRCUIT_PUBLIC_INPUTS_COUNT, {
+      description: 'Records the number of public inputs in a circuit',
+      valueType: ValueType.INT,
+    });
+
+    this.circuitSize = meter.createGauge(Metrics.CIRCUIT_SIZE, {
+      description: 'Records the size of the circuit in gates',
+      valueType: ValueType.INT,
+    });
+  }
+
+  /**
+   * Records the duration of a circuit operation.
+   * @param metric - The metric to record
+   * @param circuitName - The name of the circuit
+   * @param timerOrMS - The duration
+   */
+  recordDuration(
+    metric: 'simulationDuration' | 'witGenDuration' | 'provingDuration',
+    circuitName: CircuitName | 'tubeCircuit',
+    timerOrMS: Timer | number,
+  ) {
+    const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+    this[metric].record(s, {
+      [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+      [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+    });
+  }
+
+  /**
+   * Records the duration of an AVM circuit operation.
+   * @param metric - The metric to record
+   * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+   * @param timerOrMS - The duration
+   */
+  recordAvmDuration(metric: 'witGenDuration' | 'provingDuration', appCircuitName: string, timerOrMS: Timer | number) {
+    const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+    this[metric].record(s, {
+      [Attributes.APP_CIRCUIT_NAME]: appCircuitName,
+    });
+  }
+
+  /**
+   * Records the size of a circuit operation.
+   * @param metric - Records the size of a circuit operation.
+   * @param circuitName - The name of the circuit
+   * @param size - The size
+   */
+  recordSize(
+    metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
+    circuitName: CircuitName | 'tubeCircuit',
+    size: number,
+  ) {
+    this[metric].record(Math.ceil(size), {
+      [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+      [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+    });
+  }
+
+  /**
+   * Records the size of an AVM circuit operation.
+   * @param metric - The metric to record
+   * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+   * @param size - The size
+   */
+  recordAvmSize(
+    metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
+    appCircuitName: string,
+    size: number,
+  ) {
+    this[metric].record(Math.ceil(size), {
+      [Attributes.APP_CIRCUIT_NAME]: appCircuitName,
+    });
+  }
+}

package/src/prover/bb_native_private_kernel_prover.ts

@@ -0,0 +1,119 @@
+import { runInDirectory } from '@aztec/foundation/fs';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
+import type { SimulationProvider } from '@aztec/simulator/server';
+import type { ClientIvcProof } from '@aztec/stdlib/proofs';
+
+import { encode } from '@msgpack/msgpack';
+import { serializeWitness } from '@noir-lang/noirc_abi';
+import type { WitnessMap } from '@noir-lang/types';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+import { BB_RESULT, computeGateCountForCircuit, executeBbClientIvcProof } from '../bb/execute.js';
+import type { BBConfig } from '../config.js';
+import { BBPrivateKernelProver } from './bb_private_kernel_prover.js';
+import { readFromOutputDirectory } from './client_ivc_proof_utils.js';
+
+/**
+ * This proof creator implementation uses the native bb binary.
+ */
+export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
+  private constructor(
+    private bbBinaryPath: string,
+    private bbWorkingDirectory: string,
+    private skipCleanup: boolean,
+    protected override simulationProvider: SimulationProvider,
+    protected override log = createLogger('bb-prover:native'),
+  ) {
+    super(new BundleArtifactProvider(), simulationProvider, log);
+  }
+
+  public static async new(config: BBConfig, simulationProvider: SimulationProvider, log?: Logger) {
+    await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
+    return new BBNativePrivateKernelProver(
+      config.bbBinaryPath,
+      config.bbWorkingDirectory,
+      !!config.bbSkipCleanup,
+      simulationProvider,
+      log,
+    );
+  }
+
+  private async _createClientIvcProof(
+    directory: string,
+    acirs: Buffer[],
+    witnessStack: WitnessMap[],
+  ): Promise<ClientIvcProof> {
+    // TODO(#7371): Longer term we won't use this hacked together msgpack format
+    // and instead properly create the bincode serialization from rust
+    await fs.writeFile(path.join(directory, 'acir.msgpack'), encode(acirs));
+    await fs.writeFile(
+      path.join(directory, 'witnesses.msgpack'),
+      encode(witnessStack.map(map => serializeWitness(map))),
+    );
+    const provingResult = await executeBbClientIvcProof(
+      this.bbBinaryPath,
+      directory,
+      path.join(directory, 'acir.msgpack'),
+      path.join(directory, 'witnesses.msgpack'),
+      this.log.info,
+    );
+
+    if (provingResult.status === BB_RESULT.FAILURE) {
+      this.log.error(`Failed to generate client ivc proof`);
+      throw new Error(provingResult.reason);
+    }
+
+    const proof = await readFromOutputDirectory(directory);
+
+    this.log.info(`Generated IVC proof`, {
+      duration: provingResult.durationMs,
+      eventName: 'circuit-proving',
+    });
+
+    return proof;
+  }
+
+  public override async createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+    this.log.info(`Generating Client IVC proof`);
+    const operation = async (directory: string) => {
+      return await this._createClientIvcProof(directory, acirs, witnessStack);
+    };
+    return await this.runInDirectory(operation);
+  }
+
+  public override 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);
+    }
+
+    return result.circuitSize as number;
+  }
+
+  private runInDirectory<T>(fn: (dir: string) => Promise<T>) {
+    const log = this.log;
+    return runInDirectory(
+      this.bbWorkingDirectory,
+      (dir: string) =>
+        fn(dir).catch(err => {
+          log.error(`Error running operation at ${dir}: ${err}`);
+          throw err;
+        }),
+      this.skipCleanup,
+      this.log,
+    );
+  }
+}

package/src/prover/bb_private_kernel_prover.ts

@@ -0,0 +1,249 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import {
+  convertPrivateKernelInitInputsToWitnessMapWithAbi,
+  convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+  convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelResetInputsToWitnessMapWithAbi,
+  convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailInputsToWitnessMapWithAbi,
+  convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+  getPrivateKernelResetArtifactName,
+  updateResetCircuitSampleInputs,
+} from '@aztec/noir-protocol-circuits-types/client';
+import type { ArtifactProvider, ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import type { SimulationProvider } from '@aztec/simulator/client';
+import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
+import type {
+  PrivateKernelCircuitPublicInputs,
+  PrivateKernelInitCircuitPrivateInputs,
+  PrivateKernelInnerCircuitPrivateInputs,
+  PrivateKernelResetCircuitPrivateInputs,
+  PrivateKernelSimulateOutput,
+  PrivateKernelTailCircuitPrivateInputs,
+  PrivateKernelTailCircuitPublicInputs,
+} from '@aztec/stdlib/kernel';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { ClientIvcProof } from '@aztec/stdlib/proofs';
+import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
+
+import type { Abi, WitnessMap } from '@noir-lang/types';
+
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+
+export abstract class BBPrivateKernelProver implements PrivateKernelProver {
+  constructor(
+    protected artifactProvider: ArtifactProvider,
+    protected simulationProvider: SimulationProvider,
+    protected log = createLogger('bb-prover'),
+  ) {}
+
+  public async generateInitOutput(
+    inputs: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInitArtifact',
+      convertPrivateKernelInitInputsToWitnessMapWithAbi,
+      convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateInit(
+    inputs: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelInitArtifact',
+      convertPrivateKernelInitInputsToWitnessMapWithAbi,
+      convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateInnerOutput(
+    inputs: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInnerArtifact',
+      convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+      convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateInner(
+    inputs: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelInnerArtifact',
+      convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+      convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateResetOutput(
+    inputs: PrivateKernelResetCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    const variantInputs = inputs.trimToSizes();
+    const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
+    return await this.generateCircuitOutput(
+      variantInputs,
+      artifactName,
+      convertPrivateKernelResetInputsToWitnessMapWithAbi,
+      convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateReset(
+    inputs: PrivateKernelResetCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    updateResetCircuitSampleInputs(inputs);
+    const variantInputs = inputs.trimToSizes();
+    const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
+    return await this.simulateCircuitOutput(
+      variantInputs,
+      artifactName,
+      convertPrivateKernelResetInputsToWitnessMapWithAbi,
+      convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateTailOutput(
+    inputs: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (!inputs.isForPublic()) {
+      return await this.generateCircuitOutput(
+        inputs,
+        'PrivateKernelTailArtifact',
+        convertPrivateKernelTailInputsToWitnessMapWithAbi,
+        convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+      );
+    }
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelTailToPublicArtifact',
+      convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateTail(
+    inputs: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (!inputs.isForPublic()) {
+      return await this.simulateCircuitOutput(
+        inputs,
+        'PrivateKernelTailArtifact',
+        convertPrivateKernelTailInputsToWitnessMapWithAbi,
+        convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+      );
+    }
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelTailToPublicArtifact',
+      convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateCircuitOutput<
+    I extends { toBuffer: () => Buffer },
+    O extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
+  >(
+    inputs: I,
+    circuitType: ClientProtocolArtifact,
+    convertInputs: (inputs: I, abi: Abi) => WitnessMap,
+    convertOutputs: (outputs: WitnessMap, abi: Abi) => O,
+  ): Promise<PrivateKernelSimulateOutput<O>> {
+    const compiledCircuit: NoirCompiledCircuit = await this.artifactProvider.getSimulatedClientCircuitArtifactByName(
+      circuitType,
+    );
+
+    const witnessMap = convertInputs(inputs, compiledCircuit.abi);
+
+    const timer = new Timer();
+    const outputWitness = await this.simulationProvider
+      .executeProtocolCircuit(witnessMap, compiledCircuit)
+      .catch((err: Error) => {
+        this.log.debug(`Failed to simulate ${circuitType}`, {
+          circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+          error: err,
+        });
+        throw err;
+      });
+    const output = convertOutputs(outputWitness, compiledCircuit.abi);
+
+    this.log.debug(`Simulated ${circuitType}`, {
+      eventName: 'circuit-simulation',
+      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+      duration: timer.ms(),
+      inputSize: inputs.toBuffer().length,
+      outputSize: output.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+
+    return this.makeEmptyKernelSimulateOutput<O>(output, circuitType);
+  }
+
+  public async generateCircuitOutput<
+    I extends { toBuffer: () => Buffer },
+    O extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
+  >(
+    inputs: I,
+    circuitType: ClientProtocolArtifact,
+    convertInputs: (inputs: I, abi: Abi) => WitnessMap,
+    convertOutputs: (outputs: WitnessMap, abi: Abi) => O,
+  ): Promise<PrivateKernelSimulateOutput<O>> {
+    this.log.debug(`Generating witness for ${circuitType}`);
+    const compiledCircuit: NoirCompiledCircuit = await this.artifactProvider.getClientCircuitArtifactByName(
+      circuitType,
+    );
+
+    const witnessMap = convertInputs(inputs, compiledCircuit.abi);
+    const timer = new Timer();
+    const outputWitness = await this.simulationProvider.executeProtocolCircuit(witnessMap, compiledCircuit);
+    const output = convertOutputs(outputWitness, compiledCircuit.abi);
+
+    this.log.debug(`Generated witness for ${circuitType}`, {
+      eventName: 'circuit-witness-generation',
+      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+      duration: timer.ms(),
+      inputSize: inputs.toBuffer().length,
+      outputSize: output.toBuffer().length,
+    } satisfies CircuitWitnessGenerationStats);
+
+    const verificationKey = (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields;
+    const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+
+    const kernelOutput: PrivateKernelSimulateOutput<O> = {
+      publicInputs: output,
+      verificationKey,
+      outputWitness,
+      bytecode,
+    };
+    return kernelOutput;
+  }
+
+  public async makeEmptyKernelSimulateOutput<
+    PublicInputsType extends PrivateKernelTailCircuitPublicInputs | PrivateKernelCircuitPublicInputs,
+  >(publicInputs: PublicInputsType, circuitType: ClientProtocolArtifact) {
+    const kernelProofOutput: PrivateKernelSimulateOutput<PublicInputsType> = {
+      publicInputs,
+      verificationKey: (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields,
+      outputWitness: new Map(),
+      bytecode: Buffer.from([]),
+    };
+    return kernelProofOutput;
+  }
+
+  public createClientIvcProof(_acirs: Buffer[], _witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+    throw new Error('Not implemented');
+  }
+
+  public computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number> {
+    throw new Error('Not implemented');
+  }
+}