@aztec/bb-prover 3.0.0-devnet.2 → 3.0.0-devnet.2-patch.1

package/src/avm_proving_tests/avm_proving_tester.ts

@@ -8,7 +8,7 @@ import {
   type TestPrivateInsertions,
 } from '@aztec/simulator/public/fixtures';
 import type { PublicTxResult } from '@aztec/simulator/server';
-import { type AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
+import { AvmCircuitInputs, AvmCircuitPublicInputs, PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import type { GlobalVariables } from '@aztec/stdlib/tx';
@@ -88,6 +88,16 @@ class InterceptingLogger implements Logger {
   }
 }
 
+// Config with collectHints enabled for proving tests
+const provingConfig: PublicSimulatorConfig = PublicSimulatorConfig.from({
+  skipFeeEnforcement: false,
+  collectCallMetadata: true, // For results.
+  collectDebugLogs: false,
+  collectHints: true, // Required for proving!
+  collectPublicInputs: true, // Required for proving!
+  collectStatistics: false,
+});
+
 export class AvmProvingTester extends PublicTxSimulationTester {
   private bbWorkingDirectory: string = '';
 
@@ -98,7 +108,8 @@ export class AvmProvingTester extends PublicTxSimulationTester {
     globals?: GlobalVariables,
     metrics?: TestExecutorMetrics,
   ) {
-    super(merkleTrees, contractDataSource, globals, metrics);
+    // simulator factory is undefined because for proving, we use the default C++ simulator
+    super(merkleTrees, contractDataSource, globals, metrics, /*simulatorFactory=*/ undefined, provingConfig);
   }
 
   static async new(
@@ -211,6 +222,7 @@ export class AvmProvingTester extends PublicTxSimulationTester {
     txLabel: string = 'unlabeledTx',
     disableRevertCheck: boolean = false,
   ): Promise<PublicTxResult> {
+    const simTimer = new Timer();
     const simRes = await this.simulateTx(
       sender,
       setupCalls,
@@ -220,6 +232,8 @@ export class AvmProvingTester extends PublicTxSimulationTester {
       privateInsertions,
       txLabel,
     );
+    const simDuration = simTimer.ms();
+    this.logger.info(`Simulation took ${simDuration} ms for tx ${txLabel}`);
 
     if (!disableRevertCheck) {
       expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
@@ -227,7 +241,7 @@ export class AvmProvingTester extends PublicTxSimulationTester {
 
     const opString = this.checkCircuitOnly ? 'Check circuit' : 'Proving and verification';
 
-    const avmCircuitInputs = simRes.avmProvingRequest.inputs;
+    const avmCircuitInputs = new AvmCircuitInputs(simRes.hints!, simRes.publicInputs!);
     const timer = new Timer();
     await this.proveVerify(avmCircuitInputs, txLabel);
     this.logger.info(`${opString} took ${timer.ms()} ms for tx ${txLabel}`);

package/src/bb/execute.ts

@@ -1,4 +1,4 @@
-import { sha256 } from '@aztec/foundation/crypto';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
@@ -6,6 +6,7 @@ import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
 import { basename, dirname, join } from 'path';
+import readline from 'readline';
 
 import type { UltraHonkFlavor } from '../honk.js';
 
@@ -85,6 +86,7 @@ export function executeBB(
     logger(`BB concurrency: ${env.HARDWARE_CONCURRENCY}`);
     logger(`Executing BB with: ${pathToBB} ${command} ${args.join(' ')}`);
     const bb = proc.spawn(pathToBB, [command, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe'],
       env,
     });
 
@@ -99,14 +101,9 @@ export function executeBB(
       }, timeout);
     }
 
-    bb.stdout.on('data', data => {
-      const message = data.toString('utf-8').replace(/\n$/, '');
-      logger(message);
-    });
-    bb.stderr.on('data', data => {
-      const message = data.toString('utf-8').replace(/\n$/, '');
-      logger(message);
-    });
+    readline.createInterface({ input: bb.stdout }).on('line', logger);
+    readline.createInterface({ input: bb.stderr }).on('line', logger);
+
     bb.on('close', (exitCode: number, signal?: string) => {
       if (timeoutId) {
         clearTimeout(timeoutId);
@@ -120,7 +117,7 @@ export function executeBB(
   }).catch(_ => ({ status: BB_RESULT.FAILURE, exitCode: -1, signal: undefined }));
 }
 
-export async function executeBbClientIvcProof(
+export async function executeBbChonkProof(
   pathToBB: string,
   workingDirectory: string,
   inputsPath: string,
@@ -153,7 +150,7 @@ export async function executeBbClientIvcProof(
       log(`bb - ${message}`);
     };
 
-    const args = ['-o', outputPath, '--ivc_inputs_path', inputsPath, '-v', '--scheme', 'client_ivc'];
+    const args = ['-o', outputPath, '--ivc_inputs_path', inputsPath, '-v', '--scheme', 'chonk'];
     if (writeVk) {
       args.push('--write_vk');
     }
@@ -424,7 +421,7 @@ export async function verifyAvmProof(
 }
 
 /**
- * Verifies a ClientIvcProof
+ * Verifies a ChonkProof
  * TODO(#7370) The verification keys should be supplied separately
  * @param pathToBB - The full path to the bb binary
  * @param targetPath - The path to the folder with the proof, accumulator, and verification keys
@@ -432,7 +429,7 @@ export async function verifyAvmProof(
  * @param concurrency - The number of threads to use for the verification
  * @returns An object containing a result indication and duration taken
  */
-export async function verifyClientIvcProof(
+export async function verifyChonkProof(
   pathToBB: string,
   proofPath: string,
   keyPath: string,
@@ -448,7 +445,7 @@ export async function verifyClientIvcProof(
   }
 
   try {
-    const args = ['--scheme', 'client_ivc', '-p', proofPath, '-k', keyPath, '-v'];
+    const args = ['--scheme', 'chonk', '-p', proofPath, '-k', keyPath, '-v'];
     const timer = new Timer();
     const command = 'verify';
 
@@ -638,7 +635,7 @@ export async function computeGateCountForCircuit(
     const result = await executeBB(
       pathToBB,
       'gates',
-      ['--scheme', flavor === 'mega_honk' ? 'client_ivc' : 'ultra_honk', '-b', bytecodePath, '-v'],
+      ['--scheme', flavor === 'mega_honk' ? 'chonk' : 'ultra_honk', '-b', bytecodePath, '-v'],
       logHandler,
     );
     const duration = timer.ms();

package/src/prover/client/bb_private_kernel_prover.ts

@@ -1,4 +1,7 @@
-import { createLogger } from '@aztec/foundation/log';
+import { AztecClientBackend, type BackendOptions, Barretenberg } from '@aztec/bb.js';
+import { type LogLevel, type Logger, createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { serializeWitness } from '@aztec/noir-noirc_abi';
 import {
   convertHidingKernelPublicInputsToWitnessMapWithAbi,
   convertHidingKernelToRollupInputsToWitnessMapWithAbi,
@@ -37,15 +40,22 @@ import type {
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
 import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
-import type { ClientIvcProofWithPublicInputs } from '@aztec/stdlib/proofs';
+import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
 import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 
+import { ungzip } from 'pako';
+
+export type BBPrivateKernelProverOptions = Omit<BackendOptions, 'logger'> & { logger?: Logger };
 export abstract class BBPrivateKernelProver implements PrivateKernelProver {
+  private log: Logger;
+
   constructor(
     protected artifactProvider: ArtifactProvider,
     protected simulator: CircuitSimulator,
-    protected log = createLogger('bb-prover'),
-  ) {}
+    protected options: BBPrivateKernelProverOptions = {},
+  ) {
+    this.log = options.logger || createLogger('bb-prover:private-kernel');
+  }
 
   public async generateInitOutput(
     inputs: PrivateKernelInitCircuitPrivateInputs,
@@ -263,11 +273,38 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     return kernelProofOutput;
   }
 
-  public createClientIvcProof(_executionSteps: PrivateExecutionStep[]): Promise<ClientIvcProofWithPublicInputs> {
-    throw new Error('Not implemented');
+  public async createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs> {
+    const timer = new Timer();
+    this.log.info(`Generating ClientIVC proof...`);
+    const barretenberg = await Barretenberg.initSingleton({
+      ...this.options,
+      logger: this.options.logger?.[(process.env.LOG_LEVEL as LogLevel) || 'verbose'],
+    });
+    const backend = new AztecClientBackend(
+      executionSteps.map(step => ungzip(step.bytecode)),
+      barretenberg,
+    );
+
+    const [proof] = await backend.prove(
+      executionSteps.map(step => ungzip(serializeWitness(step.witness))),
+      executionSteps.map(step => step.vk),
+    );
+    this.log.info(`Generated ClientIVC proof`, {
+      eventName: 'client-ivc-proof-generation',
+      duration: timer.ms(),
+      proofSize: proof.length,
+    });
+    return ChonkProofWithPublicInputs.fromBufferArray(proof);
   }
 
-  public computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number> {
-    throw new Error('Not implemented');
+  public async computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number> {
+    // Note we do not pass the vk to the backend. This is unneeded for gate counts.
+    const barretenberg = await Barretenberg.initSingleton({
+      ...this.options,
+      logger: this.options.logger?.[(process.env.LOG_LEVEL as LogLevel) || 'verbose'],
+    });
+    const backend = new AztecClientBackend([ungzip(_bytecode)], barretenberg);
+    const gateCount = await backend.gates();
+    return gateCount[0];
   }
 }

package/src/prover/client/bundle.ts

@@ -0,0 +1,10 @@
+import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
+import type { CircuitSimulator } from '@aztec/simulator/client';
+
+import { BBPrivateKernelProver, type BBPrivateKernelProverOptions } from './bb_private_kernel_prover.js';
+
+export class BBBundlePrivateKernelProver extends BBPrivateKernelProver {
+  constructor(simulator: CircuitSimulator, options: BBPrivateKernelProverOptions = {}) {
+    super(new BundleArtifactProvider(), simulator, options);
+  }
+}

package/src/prover/client/lazy.ts

@@ -0,0 +1,10 @@
+import { LazyArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/lazy';
+import type { CircuitSimulator } from '@aztec/simulator/client';
+
+import { BBPrivateKernelProver, type BBPrivateKernelProverOptions } from './bb_private_kernel_prover.js';
+
+export class BBLazyPrivateKernelProver extends BBPrivateKernelProver {
+  constructor(simulator: CircuitSimulator, options: BBPrivateKernelProverOptions = {}) {
+    super(new LazyArtifactProvider(), simulator, options);
+  }
+}

package/src/prover/proof_utils.ts

@@ -1,5 +1,5 @@
 import {
-  CIVC_PROOF_LENGTH,
+  CHONK_PROOF_LENGTH,
   HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE,
   IPA_CLAIM_SIZE,
   NESTED_RECURSIVE_PROOF_LENGTH,
@@ -7,9 +7,9 @@ import {
   PAIRING_POINTS_SIZE,
   ULTRA_KECCAK_PROOF_LENGTH,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
-import { ClientIvcProofWithPublicInputs, Proof, RecursiveProof } from '@aztec/stdlib/proofs';
+import { ChonkProofWithPublicInputs, Proof, RecursiveProof } from '@aztec/stdlib/proofs';
 import type { VerificationKeyData } from '@aztec/stdlib/vks';
 
 import assert from 'assert';
@@ -19,33 +19,33 @@ import * as path from 'path';
 import { PROOF_FILENAME, PUBLIC_INPUTS_FILENAME } from '../bb/execute.js';
 
 /**
- * Create a ClientIvcProof proof file.
+ * Create a ChonkProof proof file.
  *
  * @param directory the directory to read the proof from.
- * @returns the encapsulated client ivc proof
+ * @returns the encapsulated chonk proof
  */
-export async function readClientIVCProofFromOutputDirectory(directory: string) {
+export async function readChonkProofFromOutputDirectory(directory: string) {
   const proofFilename = path.join(directory, PROOF_FILENAME);
   const binaryProof = await fs.readFile(proofFilename);
   const proofFields = splitBufferIntoFields(binaryProof);
-  return new ClientIvcProofWithPublicInputs(proofFields);
+  return new ChonkProofWithPublicInputs(proofFields);
 }
 
 /**
- * Serialize a ClientIvcProof to a proof file.
+ * Serialize a ChonkProof to a proof file.
  *
- * @param proof the ClientIvcProof from object
+ * @param proof the ChonkProof from object
  * @param directory the directory to write in
  */
-export async function writeClientIVCProofToPath(clientIvcProof: ClientIvcProofWithPublicInputs, outputPath: string) {
-  // NB: Don't use clientIvcProof.toBuffer here because it will include the proof length.
-  const fieldsBuf = Buffer.concat(clientIvcProof.fieldsWithPublicInputs.map(field => field.toBuffer()));
+export async function writeChonkProofToPath(chonkProof: ChonkProofWithPublicInputs, outputPath: string) {
+  // NB: Don't use chonkProof.toBuffer here because it will include the proof length.
+  const fieldsBuf = Buffer.concat(chonkProof.fieldsWithPublicInputs.map(field => field.toBuffer()));
   await fs.writeFile(outputPath, fieldsBuf);
 }
 
 function getNumCustomPublicInputs(proofLength: number, vkData: VerificationKeyData) {
   let numPublicInputs = vkData.numPublicInputs;
-  if (proofLength == CIVC_PROOF_LENGTH) {
+  if (proofLength == CHONK_PROOF_LENGTH) {
     numPublicInputs -= HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE;
   } else {
     numPublicInputs -= PAIRING_POINTS_SIZE;
@@ -71,7 +71,7 @@ export async function readProofsFromOutputDirectory<PROOF_LENGTH extends number>
   logger: Logger,
 ): Promise<RecursiveProof<PROOF_LENGTH>> {
   assert(
-    proofLength == CIVC_PROOF_LENGTH ||
+    proofLength == CHONK_PROOF_LENGTH ||
       proofLength == NESTED_RECURSIVE_PROOF_LENGTH ||
       proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH ||
       proofLength == ULTRA_KECCAK_PROOF_LENGTH,
@@ -81,17 +81,17 @@ export async function readProofsFromOutputDirectory<PROOF_LENGTH extends number>
   const publicInputsFilename = path.join(directory, PUBLIC_INPUTS_FILENAME);
   const proofFilename = path.join(directory, PROOF_FILENAME);
 
-  // Handle CIVC separately because bb outputs the proof fields with public inputs for CIVC.
-  const isCIVC = proofLength == CIVC_PROOF_LENGTH;
+  // Handle CHONK separately because bb outputs the proof fields with public inputs for CHONK.
+  const isChonk = proofLength == CHONK_PROOF_LENGTH;
 
   const [binaryPublicInputs, binaryProof] = await Promise.all([
-    isCIVC ? Buffer.alloc(0) : fs.readFile(publicInputsFilename),
+    isChonk ? Buffer.alloc(0) : fs.readFile(publicInputsFilename),
     fs.readFile(proofFilename),
   ]);
 
   const numPublicInputs = getNumCustomPublicInputs(proofLength, vkData);
   let fieldsWithoutPublicInputs = splitBufferIntoFields(binaryProof);
-  if (isCIVC) {
+  if (isChonk) {
     fieldsWithoutPublicInputs = fieldsWithoutPublicInputs.slice(numPublicInputs);
   }
 

package/src/prover/server/bb_prover.ts

@@ -6,7 +6,7 @@ import {
   RECURSIVE_PROOF_LENGTH,
   ULTRA_KECCAK_PROOF_LENGTH,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
@@ -38,8 +38,8 @@ import {
   convertParityRootPrivateInputsToWitnessMap,
   convertPrivateTxBaseRollupOutputsFromWitnessMap,
   convertPrivateTxBaseRollupPrivateInputsToWitnessMap,
-  convertPublicTubeOutputsFromWitnessMap,
-  convertPublicTubePrivateInputsToWitnessMap,
+  convertPublicChonkVerifierOutputsFromWitnessMap,
+  convertPublicChonkVerifierPrivateInputsToWitnessMap,
   convertPublicTxBaseRollupOutputsFromWitnessMap,
   convertPublicTxBaseRollupPrivateInputsToWitnessMap,
   convertRootRollupOutputsFromWitnessMap,
@@ -77,8 +77,8 @@ import {
   CheckpointRootRollupPrivateInputs,
   CheckpointRootSingleBlockRollupPrivateInputs,
   type PrivateTxBaseRollupPrivateInputs,
-  PublicTubePrivateInputs,
-  PublicTubePublicInputs,
+  PublicChonkVerifierPrivateInputs,
+  PublicChonkVerifierPublicInputs,
   PublicTxBaseRollupPrivateInputs,
   type RootRollupPrivateInputs,
   type RootRollupPublicInputs,
@@ -202,17 +202,19 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     return proofAndVk;
   }
 
-  public async getPublicTubeProof(
-    inputs: PublicTubePrivateInputs,
-  ): Promise<PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
-    const artifactName = 'PublicTube';
+  public async getPublicChonkVerifierProof(
+    inputs: PublicChonkVerifierPrivateInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    const artifactName = 'PublicChonkVerifier';
 
     const { circuitOutput, proof } = await this.createRecursiveProof(
       inputs,
       artifactName,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      convertPublicTubePrivateInputsToWitnessMap,
-      convertPublicTubeOutputsFromWitnessMap,
+      convertPublicChonkVerifierPrivateInputsToWitnessMap,
+      convertPublicChonkVerifierOutputsFromWitnessMap,
     );
 
     const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
@@ -585,7 +587,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     convertInput: (input: CircuitInputType) => WitnessMap,
     convertOutput: (outputWitness: WitnessMap) => CircuitOutputType,
   ): Promise<{ circuitOutput: CircuitOutputType; proof: RecursiveProof<PROOF_LENGTH> }> {
-    // this probably is gonna need to call client ivc
+    // this probably is gonna need to call chonk
     const operation = async (bbWorkingDirectory: string) => {
       const { provingResult, circuitOutput: output } = await this.generateProofWithBB(
         input,

package/src/test/delay_values.ts

@@ -1,43 +1,43 @@
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 export const WITGEN_DELAY_MS: Record<ProvingRequestType, number> = {
-  [ProvingRequestType.PARITY_BASE]: 60,
-  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 650,
-  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 60_000,
-  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 40_000,
-  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 20_000,
+  [ProvingRequestType.PARITY_BASE]: 2_000,
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 30,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 45,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 27,
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 18,
   [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 40_000,
   [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 20_000,
   [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 40_000,
-  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 20_000,
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 36_600,
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
-  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 650,
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 30,
   [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
-  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 400_000,
-  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 470_000,
-  [ProvingRequestType.PARITY_ROOT]: 100,
-  [ProvingRequestType.ROOT_ROLLUP]: 650,
-  [ProvingRequestType.PUBLIC_TUBE]: 0,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 2_500, // Guess based on public
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 2_500,
+  [ProvingRequestType.PARITY_ROOT]: 40,
+  [ProvingRequestType.ROOT_ROLLUP]: 35,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 60,
   [ProvingRequestType.PUBLIC_VM]: 0,
 };
 
 export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
-  [ProvingRequestType.PARITY_BASE]: 3_000,
+  [ProvingRequestType.PARITY_BASE]: 16_300,
   [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 15_000,
-  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 55_000,
-  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 35_000,
-  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 15_000,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 16_500,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 9_210,
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 4_560,
   [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 35_000,
   [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 15_000,
   [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 35_000,
-  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 15_000,
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 38_800,
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
-  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 15_000,
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 9_760,
   [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
-  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 145_000,
-  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 160_000,
-  [ProvingRequestType.PARITY_ROOT]: 30_000,
-  [ProvingRequestType.ROOT_ROLLUP]: 15_000,
-  [ProvingRequestType.PUBLIC_TUBE]: 30_000,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 45_000, // Guess based on public
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 45_000,
+  [ProvingRequestType.PARITY_ROOT]: 18_600,
+  [ProvingRequestType.ROOT_ROLLUP]: 84_000,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 16_300,
   [ProvingRequestType.PUBLIC_VM]: 0,
 };

package/src/test/test_circuit_prover.ts

@@ -73,8 +73,8 @@ import {
   type CheckpointRootRollupPrivateInputs,
   type CheckpointRootSingleBlockRollupPrivateInputs,
   type PrivateTxBaseRollupPrivateInputs,
-  type PublicTubePrivateInputs,
-  PublicTubePublicInputs,
+  type PublicChonkVerifierPrivateInputs,
+  PublicChonkVerifierPublicInputs,
   type PublicTxBaseRollupPrivateInputs,
   type RootRollupPrivateInputs,
   type RootRollupPublicInputs,
@@ -158,14 +158,16 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
-  public getPublicTubeProof(
-    inputs: PublicTubePrivateInputs,
-  ): Promise<PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
-    return this.applyDelay(ProvingRequestType.PUBLIC_TUBE, () =>
+  public getPublicChonkVerifierProof(
+    inputs: PublicChonkVerifierPrivateInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return this.applyDelay(ProvingRequestType.PUBLIC_CHONK_VERIFIER, () =>
       makePublicInputsAndRecursiveProof(
-        new PublicTubePublicInputs(inputs.hidingKernelProofData.publicInputs, inputs.proverId),
+        new PublicChonkVerifierPublicInputs(inputs.hidingKernelProofData.publicInputs, inputs.proverId),
         makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-        ProtocolCircuitVks.PublicTube,
+        ProtocolCircuitVks.PublicChonkVerifier,
       ),
     );
   }

package/src/test/test_verifier.ts

@@ -2,7 +2,15 @@ import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '
 import type { Tx } from '@aztec/stdlib/tx';
 
 export class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
+  constructor(private verificationDelayMs?: number) {}
   verifyProof(_tx: Tx): Promise<IVCProofVerificationResult> {
+    if (this.verificationDelayMs !== undefined && this.verificationDelayMs > 0) {
+      return new Promise(resolve => {
+        setTimeout(() => {
+          resolve({ valid: true, durationMs: this.verificationDelayMs!, totalDurationMs: this.verificationDelayMs! });
+        }, this.verificationDelayMs);
+      });
+    }
     return Promise.resolve({ valid: true, durationMs: 0, totalDurationMs: 0 });
   }
 

package/src/verification_key/verification_key_data.ts

@@ -1,5 +1,5 @@
 import { AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
 

package/src/verifier/bb_verifier.ts

@@ -22,12 +22,12 @@ import {
   PROOF_FILENAME,
   PUBLIC_INPUTS_FILENAME,
   VK_FILENAME,
-  verifyClientIvcProof,
+  verifyChonkProof,
   verifyProof,
 } from '../bb/execute.js';
 import type { BBConfig } from '../config.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
-import { writeClientIVCProofToPath } from '../prover/proof_utils.js';
+import { writeChonkProofToPath } from '../prover/proof_utils.js';
 
 export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
   private constructor(
@@ -40,6 +40,9 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
   }
 
   public static async new(config: BBConfig, logger = createLogger('bb-prover:verifier')) {
+    if (!config.bbWorkingDirectory) {
+      throw new Error(`Barretenberg working directory (BB_WORKING_DIRECTORY) is not set`);
+    }
     await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
     return new BBCircuitVerifier(config, logger);
   }
@@ -90,7 +93,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
   }
 
   public async verifyProof(tx: Tx): Promise<IVCProofVerificationResult> {
-    const proofType = 'ClientIVC';
+    const proofType = 'Chonk';
     try {
       const totalTimer = new Timer();
       let verificationDuration = 0;
@@ -104,17 +107,14 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
         };
 
         const proofPath = path.join(bbWorkingDirectory, PROOF_FILENAME);
-        await writeClientIVCProofToPath(
-          tx.clientIvcProof.attachPublicInputs(tx.data.publicInputs().toFields()),
-          proofPath,
-        );
+        await writeChonkProofToPath(tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields()), proofPath);
 
         const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
         const verificationKey = this.getVerificationKeyData(circuit);
         await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
 
         const timer = new Timer();
-        const result = await verifyClientIvcProof(
+        const result = await verifyChonkProof(
           this.config.bbBinaryPath,
           proofPath,
           verificationKeyPath,
@@ -132,7 +132,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
           circuitName: mapProtocolArtifactNameToCircuitName(circuit),
           duration: result.durationMs,
           eventName: 'circuit-verification',
-          proofType: 'client-ivc',
+          proofType: 'chonk',
         } satisfies CircuitVerificationStats);
       };
       await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);

package/src/verifier/index.ts

@@ -1,2 +1,2 @@
 export * from './bb_verifier.js';
-export * from './queued_ivc_verifier.js';
+export * from './queued_chonk_verifier.js';

package/src/verifier/{queued_ivc_verifier.ts → queued_chonk_verifier.ts}

@@ -38,13 +38,13 @@ class IVCVerifierMetrics {
 
     this.ivcVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TIME, {
       unit: 'ms',
-      description: 'Duration to verify client IVC proofs',
+      description: 'Duration to verify chonk proofs',
       valueType: ValueType.INT,
     });
 
     this.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME, {
       unit: 'ms',
-      description: 'Total duration to verify client IVC proofs, including serde',
+      description: 'Total duration to verify chonk proofs, including serde',
       valueType: ValueType.INT,
     });
 
@@ -120,7 +120,7 @@ export class QueuedIVCVerifier implements ClientProtocolCircuitVerifier {
     config: BBConfig,
     private verifier: ClientProtocolCircuitVerifier,
     private telemetry: TelemetryClient = getTelemetryClient(),
-    private logger = createLogger('bb-prover:queued_ivc_verifier'),
+    private logger = createLogger('bb-prover:queued_chonk_verifier'),
   ) {
     this.metrics = new IVCVerifierMetrics(this.telemetry, 'QueuedIVCVerifier');
     this.queue = new SerialQueue();

package/dest/prover/client/native/bb_native_private_kernel_prover.d.ts

@@ -1,23 +0,0 @@
-import { type Logger } from '@aztec/foundation/log';
-import type { CircuitSimulator } from '@aztec/simulator/server';
-import { type PrivateExecutionStep } from '@aztec/stdlib/kernel';
-import type { ClientIvcProofWithPublicInputs } from '@aztec/stdlib/proofs';
-import type { BBConfig } from '../../../config.js';
-import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
-/**
- * This proof creator implementation uses the native bb binary.
- */
-export declare class BBNativePrivateKernelProver extends BBPrivateKernelProver {
-    private bbBinaryPath;
-    private bbWorkingDirectory;
-    private skipCleanup;
-    protected simulator: CircuitSimulator;
-    protected log: Logger;
-    private constructor();
-    static new(config: BBConfig, simulator: CircuitSimulator, log?: Logger): Promise<BBNativePrivateKernelProver>;
-    private _createClientIvcProof;
-    createClientIvcProof(executionSteps: PrivateExecutionStep[]): Promise<ClientIvcProofWithPublicInputs>;
-    computeGateCountForCircuit(bytecode: Buffer, circuitName: string): Promise<number>;
-    private runInDirectory;
-}
-//# sourceMappingURL=bb_native_private_kernel_prover.d.ts.map