@aztec/bb-prover 0.69.1 → 0.70.0

package/src/prover/bb_private_kernel_prover.ts

@@ -1,5 +1,5 @@
 import { type PrivateKernelProver, type PrivateKernelSimulateOutput } from '@aztec/circuit-types';
-import { type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
+import { type CircuitSimulationStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
   type ClientIvcProof,
   type PrivateKernelCircuitPublicInputs,
@@ -8,264 +8,196 @@ import {
   type PrivateKernelResetCircuitPrivateInputs,
   type PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
-  type Proof,
-  type VerificationKeyData,
 } from '@aztec/circuits.js';
-import { runInDirectory } from '@aztec/foundation/fs';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import {
-  ClientCircuitArtifacts,
-  ClientCircuitVks,
-  type ClientProtocolArtifact,
-  ProtocolCircuitVks,
-  convertPrivateKernelInitInputsToWitnessMap,
-  convertPrivateKernelInitOutputsFromWitnessMap,
-  convertPrivateKernelInnerInputsToWitnessMap,
-  convertPrivateKernelInnerOutputsFromWitnessMap,
-  convertPrivateKernelResetInputsToWitnessMap,
-  convertPrivateKernelResetOutputsFromWitnessMap,
-  convertPrivateKernelTailForPublicOutputsFromWitnessMap,
-  convertPrivateKernelTailInputsToWitnessMap,
-  convertPrivateKernelTailOutputsFromWitnessMap,
-  convertPrivateKernelTailToPublicInputsToWitnessMap,
+  convertPrivateKernelInitInputsToWitnessMapWithAbi,
+  convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+  convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelResetInputsToWitnessMapWithAbi,
+  convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailInputsToWitnessMapWithAbi,
+  convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
   getPrivateKernelResetArtifactName,
-} from '@aztec/noir-protocol-circuits-types';
-import { WASMSimulatorWithBlobs } from '@aztec/simulator';
+  updateResetCircuitSampleInputs,
+} from '@aztec/noir-protocol-circuits-types/client';
+import { type ArtifactProvider, type ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import { ClientCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
+import { type SimulationProvider } from '@aztec/simulator/client';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
-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 { type Abi, type WitnessMap } from '@noir-lang/types';
 
-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.
- * This is a temporary implementation until we make the WASM version work.
- * TODO(#7368): this class grew 'organically' aka it could use a look at its resposibilities
- */
-export class BBNativePrivateKernelProver implements PrivateKernelProver {
-  private simulator = new WASMSimulatorWithBlobs();
-
-  private verificationKeys: Map<ClientProtocolArtifact, Promise<VerificationKeyData>> = new Map<
-    ClientProtocolArtifact,
-    Promise<VerificationKeyData>
-  >();
-
-  private constructor(
-    private bbBinaryPath: string,
-    private bbWorkingDirectory: string,
-    private skipCleanup: boolean,
-    private log = createLogger('bb-prover:native'),
+export abstract class BBPrivateKernelProver implements PrivateKernelProver {
+  constructor(
+    protected artifactProvider: ArtifactProvider,
+    protected simulationProvider: SimulationProvider,
+    protected log = createLogger('bb-prover'),
   ) {}
 
-  public static async new(config: BBConfig, log?: Logger) {
-    await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
-    return new BBNativePrivateKernelProver(config.bbBinaryPath, config.bbWorkingDirectory, !!config.bbSkipCleanup, 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,
+  public async generateInitOutput(
+    inputs: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInitArtifact',
+      convertPrivateKernelInitInputsToWitnessMapWithAbi,
+      convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
     );
-
-    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;
   }
 
-  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 async simulateProofInit(
+  public async simulateInit(
     inputs: PrivateKernelInitCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
-    return await this.simulate(
+    return await this.simulateCircuitOutput(
       inputs,
       'PrivateKernelInitArtifact',
-      convertPrivateKernelInitInputsToWitnessMap,
-      convertPrivateKernelInitOutputsFromWitnessMap,
+      convertPrivateKernelInitInputsToWitnessMapWithAbi,
+      convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateInnerOutput(
+    inputs: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInnerArtifact',
+      convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+      convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
     );
   }
 
-  public async simulateProofInner(
+  public async simulateInner(
     inputs: PrivateKernelInnerCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
-    return await this.simulate(
+    return await this.simulateCircuitOutput(
       inputs,
       'PrivateKernelInnerArtifact',
-      convertPrivateKernelInnerInputsToWitnessMap,
-      convertPrivateKernelInnerOutputsFromWitnessMap,
+      convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+      convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
     );
   }
 
-  public async simulateProofReset(
+  public async generateResetOutput(
     inputs: PrivateKernelResetCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
     const variantInputs = inputs.trimToSizes();
     const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
-    return await this.simulate(
+    return await this.generateCircuitOutput(
       variantInputs,
       artifactName,
-      variantInputs => convertPrivateKernelResetInputsToWitnessMap(variantInputs, artifactName),
-      output => convertPrivateKernelResetOutputsFromWitnessMap(output, artifactName),
+      convertPrivateKernelResetInputsToWitnessMapWithAbi,
+      convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
     );
   }
 
-  public async simulateProofTail(
+  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.simulate(
+      return await this.generateCircuitOutput(
         inputs,
         'PrivateKernelTailArtifact',
-        convertPrivateKernelTailInputsToWitnessMap,
-        convertPrivateKernelTailOutputsFromWitnessMap,
+        convertPrivateKernelTailInputsToWitnessMapWithAbi,
+        convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
       );
     }
-    return await this.simulate(
+    return await this.generateCircuitOutput(
       inputs,
       'PrivateKernelTailToPublicArtifact',
-      convertPrivateKernelTailToPublicInputsToWitnessMap,
-      convertPrivateKernelTailForPublicOutputsFromWitnessMap,
+      convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
     );
   }
 
-  /**
-   * 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
-   * @param proof - The proof to be verified
-   */
-  public async verifyProofForProtocolCircuit(circuitType: ClientProtocolArtifact, proof: Proof) {
-    const verificationKey = ProtocolCircuitVks[circuitType];
-
-    this.log.debug(`Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
-
-    const logFunction = (message: string) => {
-      this.log.debug(`${circuitType} BB out - ${message}`);
-    };
-
-    const result = await this.verifyProofFromKey(
-      getUltraHonkFlavorForCircuit(circuitType),
-      verificationKey.keyAsBytes,
-      proof,
-      logFunction,
-    );
-
-    if (result.status === BB_RESULT.FAILURE) {
-      const errorMessage = `Failed to verify ${circuitType} proof!`;
-      throw new Error(errorMessage);
+  public async simulateTail(
+    inputs: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (!inputs.isForPublic()) {
+      return await this.simulateCircuitOutput(
+        inputs,
+        'PrivateKernelTailArtifact',
+        convertPrivateKernelTailInputsToWitnessMapWithAbi,
+        convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+      );
     }
-
-    this.log.info(`Successfully verified ${circuitType} proof in ${Math.ceil(result.durationMs)} ms`);
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelTailToPublicArtifact',
+      convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+    );
   }
 
-  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,
+  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,
     );
-    if (result.status === BB_RESULT.FAILURE) {
-      throw new Error(result.reason);
-    }
 
-    return result.circuitSize as number;
-  }
+    const witnessMap = convertInputs(inputs, compiledCircuit.abi);
 
-  private async verifyProofFromKey(
-    flavor: UltraHonkFlavor,
-    verificationKey: Buffer,
-    proof: Proof,
-    logFunction: (message: string) => void = () => {},
-  ) {
-    const operation = async (bbWorkingDirectory: string) => {
-      const proofFileName = `${bbWorkingDirectory}/proof`;
-      const verificationKeyPath = `${bbWorkingDirectory}/vk`;
+    const timer = new Timer();
+    const outputWitness = await this.simulationProvider.executeProtocolCircuit(witnessMap, compiledCircuit);
+    const output = convertOutputs(outputWitness, compiledCircuit.abi);
 
-      await fs.writeFile(proofFileName, proof.buffer);
-      await fs.writeFile(verificationKeyPath, verificationKey);
-      return await verifyProof(this.bbBinaryPath, proofFileName, verificationKeyPath!, flavor, logFunction);
-    };
-    return await this.runInDirectory(operation);
-  }
+    this.log.debug(`Simulated ${circuitType}`, {
+      eventName: 'circuit-simulation',
+      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+      duration: timer.ms(),
+      inputSize: inputs.toBuffer().length,
+      outputSize: output.toBuffer().length,
+    } satisfies CircuitSimulationStats);
 
-  /**
-   * Ensures our verification key cache includes the key data located at the specified directory
-   * @param filePath - The directory containing the verification key data files
-   * @param circuitType - The type of circuit to which the verification key corresponds
-   */
-  private async updateVerificationKeyAfterSimulation(filePath: string, circuitType: ClientProtocolArtifact) {
-    let promise = this.verificationKeys.get(circuitType);
-    if (!promise) {
-      promise = extractVkData(filePath);
-      this.log.debug(`Updated verification key for circuit: ${circuitType}`);
-      this.verificationKeys.set(circuitType, promise);
-    }
-    return await promise;
+    return this.makeEmptyKernelSimulateOutput<O>(output, circuitType);
   }
 
-  private async simulate<
+  public async generateCircuitOutput<
     I extends { toBuffer: () => Buffer },
     O extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
   >(
     inputs: I,
     circuitType: ClientProtocolArtifact,
-    convertInputs: (inputs: I) => WitnessMap,
-    convertOutputs: (outputs: WitnessMap) => O,
+    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 = ClientCircuitArtifacts[circuitType];
+    const compiledCircuit: NoirCompiledCircuit = await this.artifactProvider.getClientCircuitArtifactByName(
+      circuitType,
+    );
 
-    const witnessMap = convertInputs(inputs);
+    const witnessMap = convertInputs(inputs, compiledCircuit.abi);
     const timer = new Timer();
-    const outputWitness = await this.simulator.simulateCircuit(witnessMap, compiledCircuit);
-    const output = convertOutputs(outputWitness);
+    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',
@@ -287,16 +219,23 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     return kernelOutput;
   }
 
-  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,
-    );
+  public makeEmptyKernelSimulateOutput<
+    PublicInputsType extends PrivateKernelTailCircuitPublicInputs | PrivateKernelCircuitPublicInputs,
+  >(publicInputs: PublicInputsType, circuitType: ClientProtocolArtifact) {
+    const kernelProofOutput: PrivateKernelSimulateOutput<PublicInputsType> = {
+      publicInputs,
+      verificationKey: ClientCircuitVks[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');
   }
 }

package/src/prover/bb_prover.ts

@@ -13,19 +13,13 @@ import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   type AvmCircuitInputs,
   type BaseParityInputs,
-  EmptyNestedCircuitInputs,
-  EmptyNestedData,
   Fr,
   IPA_CLAIM_LENGTH,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   type ParityPublicInputs,
-  type PrivateKernelEmptyInputData,
-  PrivateKernelEmptyInputs,
-  type PrivateToRollupKernelCircuitPublicInputs,
   Proof,
   RECURSIVE_PROOF_LENGTH,
-  RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RecursiveProof,
   type RootParityInputs,
   TUBE_PROOF_LENGTH,
@@ -44,6 +38,7 @@ import {
   type PublicBaseRollupInputs,
   type RootRollupInputs,
   type RootRollupPublicInputs,
+  type SingleTxBlockRootRollupInputs,
   type TubeInputs,
 } from '@aztec/circuits.js/rollup';
 import { runInDirectory } from '@aztec/foundation/fs';
@@ -51,7 +46,6 @@ import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { Timer } from '@aztec/foundation/timer';
 import {
-  ProtocolCircuitVks,
   ServerCircuitArtifacts,
   type ServerProtocolArtifact,
   convertBaseParityInputsToWitnessMap,
@@ -66,20 +60,19 @@ import {
   convertMergeRollupOutputsFromWitnessMap,
   convertPrivateBaseRollupInputsToWitnessMap,
   convertPrivateBaseRollupOutputsFromWitnessMap,
-  convertPrivateKernelEmptyInputsToWitnessMap,
-  convertPrivateKernelEmptyOutputsFromWitnessMap,
   convertPublicBaseRollupInputsToWitnessMap,
   convertPublicBaseRollupOutputsFromWitnessMap,
   convertRootParityInputsToWitnessMap,
   convertRootParityOutputsFromWitnessMap,
   convertRootRollupInputsToWitnessMap,
   convertRootRollupOutputsFromWitnessMap,
-} from '@aztec/noir-protocol-circuits-types';
-import { NativeACVMSimulator } from '@aztec/simulator';
+  convertSingleTxBlockRootRollupInputsToWitnessMap,
+  convertSingleTxBlockRootRollupOutputsFromWitnessMap,
+} from '@aztec/noir-protocol-circuits-types/server';
+import { NativeACVMSimulator } from '@aztec/simulator/server';
 import { Attributes, type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import { abiEncode } from '@noir-lang/noirc_abi';
-import { type Abi, type WitnessMap } from '@noir-lang/types';
+import { type WitnessMap } from '@noir-lang/types';
 import { assert } from 'console';
 import crypto from 'crypto';
 import { promises as fs } from 'fs';
@@ -313,6 +306,26 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
   }
 
+  public async getSingleTxBlockRootRollupProof(
+    input: SingleTxBlockRootRollupInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    const { circuitOutput, proof } = await this.createRecursiveProof(
+      input,
+      'SingleTxBlockRootRollupArtifact',
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+      convertSingleTxBlockRootRollupInputsToWitnessMap,
+      convertSingleTxBlockRootRollupOutputsFromWitnessMap,
+    );
+
+    const verificationKey = await this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
+
+    await this.verifyProof('SingleTxBlockRootRollupArtifact', proof.binaryProof);
+
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+  }
+
   /**
    * Simulates the empty block root rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
@@ -387,67 +400,6 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, verificationKey);
   }
 
-  public async getEmptyPrivateKernelProof(
-    inputs: PrivateKernelEmptyInputData,
-  ): Promise<
-    PublicInputsAndRecursiveProof<
-      PrivateToRollupKernelCircuitPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >
-  > {
-    const emptyNested = await this.getEmptyNestedProof();
-    const emptyPrivateKernelProof = await this.getEmptyPrivateKernelProofFromEmptyNested(
-      PrivateKernelEmptyInputs.from({
-        ...inputs,
-        emptyNested,
-      }),
-    );
-
-    return emptyPrivateKernelProof;
-  }
-
-  private async getEmptyNestedProof(): Promise<EmptyNestedData> {
-    const inputs = new EmptyNestedCircuitInputs();
-    const { proof } = await this.createRecursiveProof(
-      inputs,
-      'EmptyNestedArtifact',
-      RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      (nothing: any) => abiEncode(ServerCircuitArtifacts.EmptyNestedArtifact.abi as Abi, { _inputs: nothing as any }),
-      () => new EmptyNestedCircuitInputs(),
-    );
-
-    const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyNestedArtifact');
-    await this.verifyProof('EmptyNestedArtifact', proof.binaryProof);
-    // logger.debug(`EmptyNestedData proof size: ${proof.proof.length}`);
-    // logger.debug(`EmptyNestedData proof: ${proof.proof}`);
-    // logger.debug(`EmptyNestedData vk size: ${verificationKey.keyAsFields.key.length}`);
-    // logger.debug(`EmptyNestedData vk: ${verificationKey.keyAsFields.key}`);
-
-    return new EmptyNestedData(proof, verificationKey.keyAsFields);
-  }
-
-  private async getEmptyPrivateKernelProofFromEmptyNested(
-    inputs: PrivateKernelEmptyInputs,
-  ): Promise<
-    PublicInputsAndRecursiveProof<
-      PrivateToRollupKernelCircuitPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >
-  > {
-    const { circuitOutput, proof } = await this.createRecursiveProof(
-      inputs,
-      'PrivateKernelEmptyArtifact',
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertPrivateKernelEmptyInputsToWitnessMap,
-      convertPrivateKernelEmptyOutputsFromWitnessMap,
-    );
-    //info(`proof: ${proof.proof}`);
-    const verificationKey = ProtocolCircuitVks['PrivateKernelEmptyArtifact'];
-    await this.verifyProof('PrivateKernelEmptyArtifact', proof.binaryProof);
-
-    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-  }
-
   private async generateProofWithBB<
     Input extends { toBuffer: () => Buffer },
     Output extends { toBuffer: () => Buffer },
@@ -475,7 +427,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     const inputWitness = convertInput(input);
     const timer = new Timer();
-    const outputWitness = await simulator.simulateCircuit(inputWitness, artifact);
+    const outputWitness = await simulator.executeProtocolCircuit(inputWitness, artifact);
     const output = convertOutput(outputWitness);
 
     const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
@@ -728,13 +680,13 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
   public async verifyAvmProof(proof: Proof, verificationKey: VerificationKeyData) {
     return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) =>
-      verifyAvmProof(this.config.bbBinaryPath, proofPath, vkPath, logger.debug),
+      verifyAvmProof(this.config.bbBinaryPath, proofPath, vkPath, logger),
     );
   }
 
   public async verifyWithKey(flavor: UltraHonkFlavor, verificationKey: VerificationKeyData, proof: Proof) {
     return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) =>
-      verifyProof(this.config.bbBinaryPath, proofPath, vkPath, flavor, logger.debug),
+      verifyProof(this.config.bbBinaryPath, proofPath, vkPath, flavor, logger),
     );
   }
 

package/src/prover/index.ts

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

package/src/stats.ts

@@ -1,9 +1,7 @@
 import type { CircuitName } from '@aztec/circuit-types/stats';
-import { type ClientProtocolArtifact, type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
 
-export function mapProtocolArtifactNameToCircuitName(
-  artifact: ServerProtocolArtifact | ClientProtocolArtifact,
-): CircuitName {
+export function mapProtocolArtifactNameToCircuitName(artifact: ProtocolArtifact): CircuitName {
   switch (artifact) {
     case 'BaseParityArtifact':
       return 'base-parity';
@@ -17,6 +15,8 @@ export function mapProtocolArtifactNameToCircuitName(
       return 'merge-rollup';
     case 'BlockRootRollupArtifact':
       return 'block-root-rollup';
+    case 'SingleTxBlockRootRollupArtifact':
+      return 'single-tx-block-root-rollup';
     case 'EmptyBlockRootRollupArtifact':
       return 'empty-block-root-rollup';
     case 'BlockMergeRollupArtifact':
@@ -31,10 +31,6 @@ export function mapProtocolArtifactNameToCircuitName(
       return 'private-kernel-tail';
     case 'PrivateKernelTailToPublicArtifact':
       return 'private-kernel-tail-to-public';
-    case 'EmptyNestedArtifact':
-      return 'empty-nested';
-    case 'PrivateKernelEmptyArtifact':
-      return 'private-kernel-empty';
     default: {
       if (artifact.startsWith('PrivateKernelReset')) {
         return 'private-kernel-reset';
@@ -44,16 +40,15 @@ export function mapProtocolArtifactNameToCircuitName(
   }
 }
 
-export function isProtocolArtifactRecursive(artifact: ServerProtocolArtifact | ClientProtocolArtifact): boolean {
+export function isProtocolArtifactRecursive(artifact: ProtocolArtifact): boolean {
   switch (artifact) {
-    case 'EmptyNestedArtifact':
-    case 'PrivateKernelEmptyArtifact':
     case 'BaseParityArtifact':
     case 'RootParityArtifact':
     case 'PrivateBaseRollupArtifact':
     case 'PublicBaseRollupArtifact':
     case 'MergeRollupArtifact':
     case 'BlockRootRollupArtifact':
+    case 'SingleTxBlockRootRollupArtifact':
     case 'EmptyBlockRootRollupArtifact':
     case 'BlockMergeRollupArtifact':
     case 'RootRollupArtifact':