@aztec/bb-prover 3.0.3 → 4.0.0-devnet.1-patch.0

package/dest/verifier/queued_chonk_verifier.js

@@ -1,6 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
-import { Attributes, Metrics, ValueType, getTelemetryClient } from '@aztec/telemetry-client';
+import { Attributes, Metrics, createUpDownCounterWithDefault, getTelemetryClient } from '@aztec/telemetry-client';
 import { createHistogram } from 'node:perf_hooks';
 class IVCVerifierMetrics {
     ivcVerificationHistogram;
@@ -17,46 +17,15 @@ class IVCVerifierMetrics {
     aggDurationMetrics;
     constructor(client, name = 'QueuedIVCVerifier'){
         const meter = client.getMeter(name);
-        this.ivcVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TIME, {
-            unit: 'ms',
-            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 chonk proofs, including serde',
-            valueType: ValueType.INT
-        });
-        this.ivcFailureCount = meter.createUpDownCounter(Metrics.IVC_VERIFIER_FAILURE_COUNT, {
-            description: 'Count of failed IVC proof verifications',
-            valueType: ValueType.INT
-        });
+        this.ivcVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TIME);
+        this.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME);
+        this.ivcFailureCount = createUpDownCounterWithDefault(meter, Metrics.IVC_VERIFIER_FAILURE_COUNT);
         this.aggDurationMetrics = {
-            avg: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_AVG, {
-                valueType: ValueType.DOUBLE,
-                description: 'AVG ivc verification',
-                unit: 'ms'
-            }),
-            max: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MAX, {
-                valueType: ValueType.DOUBLE,
-                description: 'MAX ivc verification',
-                unit: 'ms'
-            }),
-            min: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MIN, {
-                valueType: ValueType.DOUBLE,
-                description: 'MIN ivc verification',
-                unit: 'ms'
-            }),
-            p50: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P50, {
-                valueType: ValueType.DOUBLE,
-                description: 'P50 ivc verification',
-                unit: 'ms'
-            }),
-            p90: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P90, {
-                valueType: ValueType.DOUBLE,
-                description: 'P90 ivc verification',
-                unit: 'ms'
-            })
+            avg: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_AVG),
+            max: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MAX),
+            min: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MIN),
+            p50: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P50),
+            p90: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P90)
         };
         meter.addBatchObservableCallback(this.aggregate, Object.values(this.aggDurationMetrics));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/bb-prover",
-  "version": "3.0.3",
+  "version": "4.0.0-devnet.1-patch.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -69,32 +69,32 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "3.0.3",
-    "@aztec/constants": "3.0.3",
-    "@aztec/foundation": "3.0.3",
-    "@aztec/noir-noirc_abi": "3.0.3",
-    "@aztec/noir-protocol-circuits-types": "3.0.3",
-    "@aztec/noir-types": "3.0.3",
-    "@aztec/simulator": "3.0.3",
-    "@aztec/stdlib": "3.0.3",
-    "@aztec/telemetry-client": "3.0.3",
-    "@aztec/world-state": "3.0.3",
+    "@aztec/bb.js": "4.0.0-devnet.1-patch.0",
+    "@aztec/constants": "4.0.0-devnet.1-patch.0",
+    "@aztec/foundation": "4.0.0-devnet.1-patch.0",
+    "@aztec/noir-noirc_abi": "4.0.0-devnet.1-patch.0",
+    "@aztec/noir-protocol-circuits-types": "4.0.0-devnet.1-patch.0",
+    "@aztec/noir-types": "4.0.0-devnet.1-patch.0",
+    "@aztec/simulator": "4.0.0-devnet.1-patch.0",
+    "@aztec/stdlib": "4.0.0-devnet.1-patch.0",
+    "@aztec/telemetry-client": "4.0.0-devnet.1-patch.0",
+    "@aztec/world-state": "4.0.0-devnet.1-patch.0",
     "commander": "^12.1.0",
     "pako": "^2.1.0",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/ethereum": "3.0.3",
-    "@aztec/kv-store": "3.0.3",
-    "@aztec/noir-contracts.js": "3.0.3",
-    "@aztec/noir-test-contracts.js": "3.0.3",
-    "@aztec/protocol-contracts": "3.0.3",
+    "@aztec/ethereum": "4.0.0-devnet.1-patch.0",
+    "@aztec/kv-store": "4.0.0-devnet.1-patch.0",
+    "@aztec/noir-contracts.js": "4.0.0-devnet.1-patch.0",
+    "@aztec/noir-test-contracts.js": "4.0.0-devnet.1-patch.0",
+    "@aztec/protocol-contracts": "4.0.0-devnet.1-patch.0",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",
     "@types/source-map-support": "^0.5.10",
-    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
     "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",

package/src/avm_proving_tests/avm_proving_tester.ts

@@ -18,14 +18,7 @@ import fs from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'path';
 
-import {
-  type BBResult,
-  type BBSuccess,
-  BB_RESULT,
-  VK_FILENAME,
-  generateAvmProof,
-  verifyAvmProof,
-} from '../bb/execute.js';
+import { type BBResult, type BBSuccess, BB_RESULT, generateAvmProof, verifyAvmProof } from '../bb/execute.js';
 
 const BB_PATH = path.resolve('../../barretenberg/cpp/build/bin/bb-avm');
 
@@ -51,6 +44,10 @@ class InterceptingLogger implements Logger {
     throw new Error('Not implemented');
   }
 
+  getBindings() {
+    return this.logger.getBindings();
+  }
+
   private intercept(level: LogLevel, msg: string, ...args: any[]) {
     this.logs.push(...msg.split('\n'));
     // Forward to the wrapped logger
@@ -193,14 +190,7 @@ export class AvmProvingTester extends PublicTxSimulationTester {
       return proofRes;
     }
 
-    return await verifyAvmProof(
-      BB_PATH,
-      this.bbWorkingDirectory,
-      proofRes.proofPath!,
-      publicInputs,
-      path.join(proofRes.vkDirectoryPath!, VK_FILENAME),
-      this.logger,
-    );
+    return await verifyAvmProof(BB_PATH, this.bbWorkingDirectory, proofRes.proofPath!, publicInputs, this.logger);
   }
 
   public async proveVerify(avmCircuitInputs: AvmCircuitInputs, txLabel: string = 'unlabeledTx') {

package/src/bb/execute.ts

@@ -353,7 +353,7 @@ export async function generateAvmProof(
         durationMs: duration,
         proofPath: join(outputPath, PROOF_FILENAME),
         pkPath: undefined,
-        vkDirectoryPath: outputPath,
+        vkDirectoryPath: undefined, // AVM VK is fixed in the binary.
       };
     }
     // Not a great error message here but it is difficult to decipher what comes from bb
@@ -372,7 +372,7 @@ export async function generateAvmProof(
  * @param pathToBB - The full path to the bb binary
  * @param proofFullPath - The full path to the proof to be verified
  * @param verificationKeyPath - The full path to the circuit verification key
- * @param log - A logging function
+ * @param logger - A logger
  * @returns An object containing a result indication and duration taken
  */
 export async function verifyProof(
@@ -380,16 +380,25 @@ export async function verifyProof(
   proofFullPath: string,
   verificationKeyPath: string,
   ultraHonkFlavor: UltraHonkFlavor,
-  log: Logger,
+  logger: Logger,
 ): Promise<BBFailure | BBSuccess> {
-  return await verifyProofInternal(
-    pathToBB,
+  // Specify the public inputs path in the case of UH verification.
+  // Take proofFullPath and remove the suffix past the / to get the directory.
+  const proofDir = proofFullPath.substring(0, proofFullPath.lastIndexOf('/'));
+  const publicInputsFullPath = join(proofDir, '/public_inputs');
+  logger.debug(`public inputs path: ${publicInputsFullPath}`);
+
+  const args = [
+    '-p',
     proofFullPath,
+    '-k',
     verificationKeyPath,
-    `verify`,
-    log,
-    getArgs(ultraHonkFlavor),
-  );
+    '-i',
+    publicInputsFullPath,
+    '--disable_zk',
+    ...getArgs(ultraHonkFlavor),
+  ];
+  return await verifyProofInternal(pathToBB, `verify`, args, logger);
 }
 
 export async function verifyAvmProof(
@@ -397,7 +406,6 @@ export async function verifyAvmProof(
   workingDirectory: string,
   proofFullPath: string,
   publicInputs: AvmCircuitPublicInputs,
-  verificationKeyPath: string,
   logger: Logger,
 ): Promise<BBFailure | BBSuccess> {
   const inputsBuffer = publicInputs.serializeWithMessagePack();
@@ -414,10 +422,8 @@ export async function verifyAvmProof(
     return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
   }
 
-  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', logger, [
-    '--avm-public-inputs',
-    avmInputsPath,
-  ]);
+  const args = ['-p', proofFullPath, '--avm-public-inputs', avmInputsPath];
+  return await verifyProofInternal(pathToBB, 'avm_verify', args, logger);
 }
 
 /**
@@ -425,7 +431,7 @@ export async function verifyAvmProof(
  * 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
- * @param log - A logging function
+ * @param logger - A logger
  * @param concurrency - The number of threads to use for the verification
  * @returns An object containing a result indication and duration taken
  */
@@ -433,7 +439,7 @@ export async function verifyChonkProof(
   pathToBB: string,
   proofPath: string,
   keyPath: string,
-  log: LogFn,
+  logger: Logger,
   concurrency = 1,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
@@ -444,43 +450,25 @@ export async function verifyChonkProof(
     return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
   }
 
-  try {
-    const args = ['--scheme', 'chonk', '-p', proofPath, '-k', keyPath, '-v'];
-    const timer = new Timer();
-    const command = 'verify';
-
-    const result = await executeBB(pathToBB, command, args, log, concurrency);
-    const duration = timer.ms();
-    if (result.status == BB_RESULT.SUCCESS) {
-      return { status: BB_RESULT.SUCCESS, durationMs: duration };
-    }
-    // Not a great error message here but it is difficult to decipher what comes from bb
-    return {
-      status: BB_RESULT.FAILURE,
-      reason: `Failed to verify proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
-    };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
-  }
+  const args = ['--scheme', 'chonk', '-p', proofPath, '-k', keyPath, '-v'];
+  return await verifyProofInternal(pathToBB, 'verify', args, logger, concurrency);
 }
 
 /**
  * Used for verifying proofs with BB
  * @param pathToBB - The full path to the bb binary
- * @param proofFullPath - The full path to the proof to be verified
- * @param verificationKeyPath - The full path to the circuit verification key
  * @param command - The BB command to execute (verify/avm_verify)
- * @param log - A logging function
+ * @param args - The arguments to pass to the command
+ * @param logger - A logger
+ * @param concurrency - The number of threads to use for the verification
  * @returns An object containing a result indication and duration taken
  */
 async function verifyProofInternal(
   pathToBB: string,
-  proofFullPath: string,
-  verificationKeyPath: string,
   command: 'verify' | 'avm_verify',
+  args: string[],
   logger: Logger,
-  extraArgs: string[] = [],
+  concurrency?: number,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
     .access(pathToBB, fs.constants.R_OK)
@@ -495,28 +483,12 @@ async function verifyProofInternal(
   };
 
   try {
-    let args;
-
-    if (command == 'verify') {
-      // Specify the public inputs path in the case of UH verification.
-      // Take proofFullPath and remove the suffix past the / to get the directory.
-      const proofDir = proofFullPath.substring(0, proofFullPath.lastIndexOf('/'));
-      const publicInputsFullPath = join(proofDir, '/public_inputs');
-      logger.debug(`public inputs path: ${publicInputsFullPath}`);
-
-      args = ['-p', proofFullPath, '-k', verificationKeyPath, '-i', publicInputsFullPath, '--disable_zk', ...extraArgs];
-    } else {
-      args = ['-p', proofFullPath, '-k', verificationKeyPath, ...extraArgs];
-    }
-
     const loggingArg =
       logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
-    if (loggingArg !== '') {
-      args.push(loggingArg);
-    }
+    const finalArgs = loggingArg !== '' ? [...args, loggingArg] : args;
 
     const timer = new Timer();
-    const result = await executeBB(pathToBB, command, args, logFunction);
+    const result = await executeBB(pathToBB, command, finalArgs, logFunction, concurrency);
     const duration = timer.ms();
     if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, durationMs: duration };

package/src/instrumentation.ts

@@ -7,7 +7,6 @@ import {
   Metrics,
   type TelemetryClient,
   type Tracer,
-  ValueType,
 } from '@aztec/telemetry-client';
 
 /**
@@ -31,51 +30,21 @@ export class ProverInstrumentation {
     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.simulationDuration = meter.createHistogram(Metrics.CIRCUIT_SIMULATION_DURATION);
 
-    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.witGenDuration = meter.createHistogram(Metrics.CIRCUIT_WITNESS_GEN_DURATION);
 
-    this.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION, {
-      unit: 's',
-      description: 'Records how long it takes to prove a circuit',
-      valueType: ValueType.DOUBLE,
-    });
+    this.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION);
 
-    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.witGenInputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_INPUT_SIZE);
 
-    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.witGenOutputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_OUTPUT_SIZE);
 
-    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.proofSize = meter.createGauge(Metrics.CIRCUIT_PROVING_PROOF_SIZE);
 
-    this.circuitPublicInputCount = meter.createGauge(Metrics.CIRCUIT_PUBLIC_INPUTS_COUNT, {
-      description: 'Records the number of public inputs in a circuit',
-      valueType: ValueType.INT,
-    });
+    this.circuitPublicInputCount = meter.createGauge(Metrics.CIRCUIT_PUBLIC_INPUTS_COUNT);
 
-    this.circuitSize = meter.createGauge(Metrics.CIRCUIT_SIZE, {
-      description: 'Records the size of the circuit in gates',
-      valueType: ValueType.INT,
-    });
+    this.circuitSize = meter.createGauge(Metrics.CIRCUIT_SIZE);
   }
 
   /**

package/src/prover/client/bb_private_kernel_prover.ts

@@ -1,5 +1,5 @@
-import { AztecClientBackend, Barretenberg } from '@aztec/bb.js';
-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 {
@@ -45,12 +45,17 @@ import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@azt
 
 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,
@@ -271,9 +276,14 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
   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)),
-      await Barretenberg.initSingleton(),
+      barretenberg,
+      executionSteps.map(step => step.functionName),
     );
 
     const [proof] = await backend.prove(
@@ -290,7 +300,11 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
 
   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 backend = new AztecClientBackend([ungzip(_bytecode)], await Barretenberg.initSingleton());
+    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, [_circuitName]);
     const gateCount = await backend.gates();
     return gateCount[0];
   }

package/src/prover/client/bundle.ts

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

package/src/prover/client/lazy.ts

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

package/src/prover/server/bb_prover.ts

@@ -55,10 +55,8 @@ import { NativeACVMSimulator } from '@aztec/simulator/server';
 import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
 import { ProvingError } from '@aztec/stdlib/errors';
 import {
-  type ProofAndVerificationKey,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
-  makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
 import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
@@ -84,10 +82,9 @@ import {
   type RootRollupPublicInputs,
   type TxMergeRollupPrivateInputs,
   type TxRollupPublicInputs,
-  enhanceProofWithPiValidationFlag,
 } from '@aztec/stdlib/rollup';
 import type { CircuitProvingStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
-import type { VerificationKeyData } from '@aztec/stdlib/vks';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { promises as fs } from 'fs';
@@ -106,9 +103,8 @@ import {
   verifyProof,
 } from '../../bb/execute.js';
 import type { ACVMConfig, BBConfig } from '../../config.js';
-import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../../honk.js';
+import { getUltraHonkFlavorForCircuit } from '../../honk.js';
 import { ProverInstrumentation } from '../../instrumentation.js';
-import { extractAvmVkData } from '../../verification_key/verification_key_data.js';
 import { readProofsFromOutputDirectory } from '../proof_utils.js';
 
 const logger = createLogger('bb-prover');
@@ -192,14 +188,10 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }))
   public async getAvmProof(
     inputs: AvmCircuitInputs,
-    skipPublicInputsValidation: boolean = false,
-  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
-    const proofAndVk = await this.createAvmProof(inputs);
-    await this.verifyAvmProof(proofAndVk.proof.binaryProof, proofAndVk.verificationKey, inputs.publicInputs);
-
-    // TODO(#14234)[Unconditional PIs validation]: remove next lines and directly return proofAndVk
-    proofAndVk.proof.proof = enhanceProofWithPiValidationFlag(proofAndVk.proof.proof, skipPublicInputsValidation);
-    return proofAndVk;
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+    const proof = await this.createAvmProof(inputs);
+    await this.verifyAvmProof(proof.binaryProof, inputs.publicInputs);
+    return proof;
   }
 
   public async getPublicChonkVerifierProof(
@@ -471,6 +463,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       this.config.acvmWorkingDirectory,
       this.config.acvmBinaryPath,
       outputWitnessFile,
+      logger,
     );
 
     const artifact = getServerCircuitArtifact(circuitType);
@@ -535,11 +528,10 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
   private async createAvmProof(
     input: AvmCircuitInputs,
-  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
     const operation = async (bbWorkingDirectory: string) => {
       const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
 
-      const avmVK = await extractAvmVkData(provingResult.vkDirectoryPath!);
       const avmProof = await this.readAvmProofAsFields(provingResult.proofPath!);
 
       const circuitType = 'avm-circuit' as const;
@@ -562,7 +554,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         } satisfies CircuitProvingStats,
       );
 
-      return makeProofAndVerificationKey(avmProof, avmVK);
+      return avmProof;
     };
     return await this.runInDirectory(operation);
   }
@@ -636,28 +628,19 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async verifyProof(circuitType: ServerProtocolArtifact, proof: Proof) {
     const verificationKey = this.getVerificationKeyDataForCircuit(circuitType);
-    return await this.verifyWithKey(getUltraHonkFlavorForCircuit(circuitType), verificationKey, proof);
-  }
-
-  public async verifyAvmProof(
-    proof: Proof,
-    verificationKey: VerificationKeyData,
-    publicInputs: AvmCircuitPublicInputs,
-  ) {
-    return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) =>
-      verifyAvmProof(this.config.bbBinaryPath, this.config.bbWorkingDirectory, proofPath, publicInputs, vkPath, logger),
+    return await this.verifyInternal(proof, verificationKey, (proofPath, vkPath) =>
+      verifyProof(this.config.bbBinaryPath, proofPath, vkPath, getUltraHonkFlavorForCircuit(circuitType), 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),
+  public async verifyAvmProof(proof: Proof, publicInputs: AvmCircuitPublicInputs) {
+    return await this.verifyInternal(proof, /*verificationKey=*/ undefined, (proofPath, /*unused*/ _vkPath) =>
+      verifyAvmProof(this.config.bbBinaryPath, this.config.bbWorkingDirectory, proofPath, publicInputs, logger),
     );
   }
-
-  private async verifyWithKeyInternal(
+  private async verifyInternal(
     proof: Proof,
-    verificationKey: { keyAsBytes: Buffer },
+    verificationKey: { keyAsBytes: Buffer } | undefined,
     verificationFunction: (proofPath: string, vkPath: string) => Promise<BBFailure | BBSuccess>,
   ) {
     const operation = async (bbWorkingDirectory: string) => {
@@ -665,11 +648,13 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
       const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
       // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13189): Put this proof parsing logic in the proof class.
-      await fs.writeFile(publicInputsFileName, proof.buffer.slice(0, proof.numPublicInputs * 32));
-      await fs.writeFile(proofFileName, proof.buffer.slice(proof.numPublicInputs * 32));
-      await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+      await fs.writeFile(publicInputsFileName, proof.buffer.subarray(0, proof.numPublicInputs * 32));
+      await fs.writeFile(proofFileName, proof.buffer.subarray(proof.numPublicInputs * 32));
+      if (verificationKey !== undefined) {
+        await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+      }
 
-      const result = await verificationFunction(proofFileName, verificationKeyPath!);
+      const result = await verificationFunction(proofFileName, verificationKeyPath);
 
       if (result.status === BB_RESULT.FAILURE) {
         const errorMessage = `Failed to verify proof from key!`;