@aztec/bb-prover 0.71.0 → 0.73.0

package/dest/verifier/bb_verifier.js

@@ -1,51 +1,34 @@
 import { Tx } from '@aztec/circuit-types';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
-import { ServerCircuitArtifacts } from '@aztec/noir-protocol-circuits-types/server';
+import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { BB_RESULT, PROOF_FILENAME, VK_FILENAME, generateContractForCircuit, generateKeyForNoirCircuit, verifyClientIvcProof, verifyProof, } from '../bb/execute.js';
+import { BB_RESULT, PROOF_FILENAME, VK_FILENAME, verifyClientIvcProof, verifyProof } from '../bb/execute.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
 import { writeToOutputDirectory } from '../prover/client_ivc_proof_utils.js';
-import { isProtocolArtifactRecursive, mapProtocolArtifactNameToCircuitName } from '../stats.js';
-import { extractVkData } from '../verification_key/verification_key_data.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 export class BBCircuitVerifier {
-    constructor(config, verificationKeys = new Map(), logger) {
+    constructor(config, logger) {
         this.config = config;
-        this.verificationKeys = verificationKeys;
         this.logger = logger;
     }
-    static async new(config, initialCircuits = [], logger = createLogger('bb-prover:verifier')) {
+    static async new(config, logger = createLogger('bb-prover:verifier')) {
         await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
-        const keys = new Map();
-        for (const circuit of initialCircuits) {
-            const vkData = await this.generateVerificationKey(circuit, config.bbBinaryPath, config.bbWorkingDirectory, logger.debug);
-            keys.set(circuit, Promise.resolve(vkData));
-        }
-        return new BBCircuitVerifier(config, keys, logger);
-    }
-    static async generateVerificationKey(circuit, bbPath, workingDirectory, logFn) {
-        return await generateKeyForNoirCircuit(bbPath, workingDirectory, circuit, ServerCircuitArtifacts[circuit], isProtocolArtifactRecursive(circuit), getUltraHonkFlavorForCircuit(circuit), logFn).then(result => {
-            if (result.status === BB_RESULT.FAILURE) {
-                throw new Error(`Failed to created verification key for ${circuit}, ${result.reason}`);
-            }
-            return extractVkData(result.vkPath);
-        });
+        return new BBCircuitVerifier(config, logger);
     }
-    async getVerificationKeyData(circuit) {
-        let promise = this.verificationKeys.get(circuit);
-        if (!promise) {
-            promise = BBCircuitVerifier.generateVerificationKey(circuit, this.config.bbBinaryPath, this.config.bbWorkingDirectory, this.logger.debug);
+    getVerificationKeyData(circuitType) {
+        const vk = ServerCircuitVks[circuitType];
+        if (vk === undefined) {
+            throw new Error('Could not find VK for server artifact ' + circuitType);
         }
-        this.verificationKeys.set(circuit, promise);
-        const vk = await promise;
-        return vk.clone();
+        return vk;
     }
     async verifyProofForCircuit(circuit, proof) {
         const operation = async (bbWorkingDirectory) => {
             const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
             const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
-            const verificationKey = await this.getVerificationKeyData(circuit);
+            const verificationKey = this.getVerificationKeyData(circuit);
             this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
             await fs.writeFile(proofFileName, proof.buffer);
             await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
@@ -63,13 +46,6 @@ export class BBCircuitVerifier {
         };
         await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup);
     }
-    async generateSolidityContract(circuit, contractName) {
-        const result = await generateContractForCircuit(this.config.bbBinaryPath, this.config.bbWorkingDirectory, circuit, ServerCircuitArtifacts[circuit], contractName, this.logger.debug);
-        if (result.status === BB_RESULT.FAILURE) {
-            throw new Error(`Failed to create verifier contract for ${circuit}, ${result.reason}`);
-        }
-        return fs.readFile(result.contractPath, 'utf-8');
-    }
     async verifyProof(tx) {
         try {
             // TODO(#7370) The verification keys should be supplied separately and based on the expectedCircuit
@@ -107,4 +83,4 @@ export class BBCircuitVerifier {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmJfdmVyaWZpZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmVyaWZpZXIvYmJfdmVyaWZpZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFzQyxFQUFFLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUc5RSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDdEQsT0FBTyxFQUEyQixZQUFZLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUM5RSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQU9wRixPQUFPLEVBQUUsUUFBUSxJQUFJLEVBQUUsRUFBRSxNQUFNLElBQUksQ0FBQztBQUNwQyxPQUFPLEtBQUssSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUU3QixPQUFPLEVBQ0wsU0FBUyxFQUNULGNBQWMsRUFDZCxXQUFXLEVBQ1gsMEJBQTBCLEVBQzFCLHlCQUF5QixFQUN6QixvQkFBb0IsRUFDcEIsV0FBVyxHQUNaLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIsT0FBTyxFQUE4Qyw0QkFBNEIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUN0RyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUM3RSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDaEcsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBRTdFLE1BQU0sT0FBTyxpQkFBaUI7SUFDNUIsWUFDVSxNQUFnQixFQUNoQixtQkFBbUIsSUFBSSxHQUFHLEVBQWtELEVBQzVFLE1BQWM7UUFGZCxXQUFNLEdBQU4sTUFBTSxDQUFVO1FBQ2hCLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBNEQ7UUFDNUUsV0FBTSxHQUFOLE1BQU0sQ0FBUTtJQUNyQixDQUFDO0lBRUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQ3JCLE1BQWdCLEVBQ2hCLGtCQUE0QyxFQUFFLEVBQzlDLE1BQU0sR0FBRyxZQUFZLENBQUMsb0JBQW9CLENBQUM7UUFFM0MsTUFBTSxFQUFFLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxrQkFBa0IsRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQy9ELE1BQU0sSUFBSSxHQUFHLElBQUksR0FBRyxFQUFrRCxDQUFDO1FBQ3ZFLEtBQUssTUFBTSxPQUFPLElBQUksZUFBZSxFQUFFLENBQUM7WUFDdEMsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsdUJBQXVCLENBQy9DLE9BQU8sRUFDUCxNQUFNLENBQUMsWUFBWSxFQUNuQixNQUFNLENBQUMsa0JBQWtCLEVBQ3pCLE1BQU0sQ0FBQyxLQUFLLENBQ2IsQ0FBQztZQUNGLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUM3QyxDQUFDO1FBQ0QsT0FBTyxJQUFJLGlCQUFpQixDQUFDLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDckQsQ0FBQztJQUVPLE1BQU0sQ0FBQyxLQUFLLENBQUMsdUJBQXVCLENBQzFDLE9BQStCLEVBQy9CLE1BQWMsRUFDZCxnQkFBd0IsRUFDeEIsS0FBWTtRQUVaLE9BQU8sTUFBTSx5QkFBeUIsQ0FDcEMsTUFBTSxFQUNOLGdCQUFnQixFQUNoQixPQUFPLEVBQ1Asc0JBQXNCLENBQUMsT0FBTyxDQUFDLEVBQy9CLDJCQUEyQixDQUFDLE9BQU8sQ0FBQyxFQUNwQyw0QkFBNEIsQ0FBQyxPQUFPLENBQUMsRUFDckMsS0FBSyxDQUNOLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQ2QsSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLFNBQVMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztnQkFDeEMsTUFBTSxJQUFJLEtBQUssQ0FBQywwQ0FBMEMsT0FBTyxLQUFLLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO1lBQ3pGLENBQUM7WUFFRCxPQUFPLGFBQWEsQ0FBQyxNQUFNLENBQUMsTUFBTyxDQUFDLENBQUM7UUFDdkMsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU0sS0FBSyxDQUFDLHNCQUFzQixDQUFDLE9BQStCO1FBQ2pFLElBQUksT0FBTyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDakQsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ2IsT0FBTyxHQUFHLGlCQUFpQixDQUFDLHVCQUF1QixDQUNqRCxPQUFPLEVBQ1AsSUFBSSxDQUFDLE1BQU0sQ0FBQyxZQUFZLEVBQ3hCLElBQUksQ0FBQyxNQUFNLENBQUMsa0JBQWtCLEVBQzlCLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUNsQixDQUFDO1FBQ0osQ0FBQztRQUNELElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQzVDLE1BQU0sRUFBRSxHQUFHLE1BQU0sT0FBTyxDQUFDO1FBQ3pCLE9BQU8sRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3BCLENBQUM7SUFFTSxLQUFLLENBQUMscUJBQXFCLENBQUMsT0FBK0IsRUFBRSxLQUFZO1FBQzlFLE1BQU0sU0FBUyxHQUFHLEtBQUssRUFBRSxrQkFBMEIsRUFBRSxFQUFFO1lBQ3JELE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsa0JBQWtCLEVBQUUsY0FBYyxDQUFDLENBQUM7WUFDcEUsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLGtCQUFrQixFQUFFLFdBQVcsQ0FBQyxDQUFDO1lBQ3ZFLE1BQU0sZUFBZSxHQUFHLE1BQU0sSUFBSSxDQUFDLHNCQUFzQixDQUFDLE9BQU8sQ0FBQyxDQUFDO1lBRW5FLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsT0FBTyx3QkFBd0IsZUFBZSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1lBRW5HLE1BQU0sRUFBRSxDQUFDLFNBQVMsQ0FBQyxhQUFhLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBQ2hELE1BQU0sRUFBRSxDQUFDLFNBQVMsQ0FBQyxtQkFBbUIsRUFBRSxlQUFlLENBQUMsVUFBVSxDQUFDLENBQUM7WUFFcEUsTUFBTSxNQUFNLEdBQUcsTUFBTSxXQUFXLENBQzlCLElBQUksQ0FBQyxNQUFNLENBQUMsWUFBWSxFQUN4QixhQUFhLEVBQ2IsbUJBQW9CLEVBQ3BCLDRCQUE0QixDQUFDLE9BQU8sQ0FBQyxFQUNyQyxJQUFJLENBQUMsTUFBTSxDQUNaLENBQUM7WUFFRixJQUFJLE1BQU0sQ0FBQyxNQUFNLEtBQUssU0FBUyxDQUFDLE9BQU8sRUFBRSxDQUFDO2dCQUN4QyxNQUFNLFlBQVksR0FBRyxvQkFBb0IsT0FBTyxTQUFTLENBQUM7Z0JBQzFELE1BQU0sSUFBSSxLQUFLLENBQUMsWUFBWSxDQUFDLENBQUM7WUFDaEMsQ0FBQztZQUVELElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsT0FBTywwQkFBMEIsRUFBRTtnQkFDdEQsV0FBVyxFQUFFLG9DQUFvQyxDQUFDLE9BQU8sQ0FBQztnQkFDMUQsUUFBUSxFQUFFLE1BQU0sQ0FBQyxVQUFVO2dCQUMzQixTQUFTLEVBQUUsc0JBQXNCO2dCQUNqQyxTQUFTLEVBQUUsWUFBWTthQUNXLENBQUMsQ0FBQztRQUN4QyxDQUFDLENBQUM7UUFDRixNQUFNLGNBQWMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLGtCQUFrQixFQUFFLFNBQVMsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQzdGLENBQUM7SUFFTSxLQUFLLENBQUMsd0JBQXdCLENBQUMsT0FBOEMsRUFBRSxZQUFvQjtRQUN4RyxNQUFNLE1BQU0sR0FBRyxNQUFNLDBCQUEwQixDQUM3QyxJQUFJLENBQUMsTUFBTSxDQUFDLFlBQVksRUFDeEIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxrQkFBa0IsRUFDOUIsT0FBTyxFQUNQLHNCQUFzQixDQUFDLE9BQU8sQ0FBQyxFQUMvQixZQUFZLEVBQ1osSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQ2xCLENBQUM7UUFFRixJQUFJLE1BQU0sQ0FBQyxNQUFNLEtBQUssU0FBUyxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ3hDLE1BQU0sSUFBSSxLQUFLLENBQUMsMENBQTBDLE9BQU8sS0FBSyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztRQUN6RixDQUFDO1FBRUQsT0FBTyxFQUFFLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxZQUFhLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDcEQsQ0FBQztJQUVNLEtBQUssQ0FBQyxXQUFXLENBQUMsRUFBTTtRQUM3QixJQUFJLENBQUM7WUFDSCxtR0FBbUc7WUFDbkcscUdBQXFHO1lBQ3JHLG1HQUFtRztZQUNuRywrQ0FBK0M7WUFDL0MsTUFBTSxlQUFlLEdBQTJCLEVBQUUsQ0FBQyxJQUFJLENBQUMsU0FBUztnQkFDL0QsQ0FBQyxDQUFDLG1DQUFtQztnQkFDckMsQ0FBQyxDQUFDLDJCQUEyQixDQUFDO1lBQ2hDLE1BQU0sT0FBTyxHQUFHLFdBQVcsQ0FBQztZQUU1QiwrREFBK0Q7WUFDL0QsTUFBTSxTQUFTLEdBQUcsS0FBSyxFQUFFLGtCQUEwQixFQUFFLEVBQUU7Z0JBQ3JELE1BQU0sV0FBVyxHQUFHLENBQUMsT0FBZSxFQUFFLEVBQUU7b0JBQ3RDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsT0FBTyxhQUFhLE9BQU8sRUFBRSxDQUFDLENBQUM7Z0JBQ3RELENBQUMsQ0FBQztnQkFFRixNQUFNLHNCQUFzQixDQUFDLEVBQUUsQ0FBQyxjQUFjLEVBQUUsa0JBQWtCLENBQUMsQ0FBQztnQkFDcEUsTUFBTSxNQUFNLEdBQUcsTUFBTSxvQkFBb0IsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFlBQVksRUFBRSxrQkFBa0IsRUFBRSxXQUFXLENBQUMsQ0FBQztnQkFFckcsSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLFNBQVMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztvQkFDeEMsTUFBTSxZQUFZLEdBQUcsb0JBQW9CLE9BQU8sU0FBUyxDQUFDO29CQUMxRCxNQUFNLElBQUksS0FBSyxDQUFDLFlBQVksQ0FBQyxDQUFDO2dCQUNoQyxDQUFDO2dCQUVELElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsT0FBTywwQkFBMEIsRUFBRTtvQkFDdEQsV0FBVyxFQUFFLG9DQUFvQyxDQUFDLGVBQWUsQ0FBQztvQkFDbEUsUUFBUSxFQUFFLE1BQU0sQ0FBQyxVQUFVO29CQUMzQixTQUFTLEVBQUUsc0JBQXNCO29CQUNqQyxTQUFTLEVBQUUsWUFBWTtpQkFDVyxDQUFDLENBQUM7WUFDeEMsQ0FBQyxDQUFDO1lBQ0YsTUFBTSxjQUFjLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxrQkFBa0IsRUFBRSxTQUFTLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztZQUMzRixPQUFPLElBQUksQ0FBQztRQUNkLENBQUM7UUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2IsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsMkNBQTJDLEVBQUUsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLEtBQUssTUFBTSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUM5RixPQUFPLEtBQUssQ0FBQztRQUNmLENBQUM7SUFDSCxDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/bb-prover",
-  "version": "0.71.0",
+  "version": "0.73.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -67,14 +67,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.71.0",
-    "@aztec/circuit-types": "0.71.0",
-    "@aztec/circuits.js": "0.71.0",
-    "@aztec/foundation": "0.71.0",
-    "@aztec/noir-protocol-circuits-types": "0.71.0",
-    "@aztec/simulator": "0.71.0",
-    "@aztec/telemetry-client": "0.71.0",
-    "@aztec/world-state": "0.71.0",
+    "@aztec/bb.js": "0.73.0",
+    "@aztec/circuit-types": "0.73.0",
+    "@aztec/circuits.js": "0.73.0",
+    "@aztec/foundation": "0.73.0",
+    "@aztec/noir-protocol-circuits-types": "0.73.0",
+    "@aztec/simulator": "0.73.0",
+    "@aztec/telemetry-client": "0.73.0",
+    "@aztec/world-state": "0.73.0",
     "@msgpack/msgpack": "^3.0.0-beta2",
     "@noir-lang/noirc_abi": "portal:../../noir/packages/noirc_abi",
     "@noir-lang/types": "portal:../../noir/packages/types",
@@ -86,6 +86,8 @@
   "devDependencies": {
     "@aztec/ethereum": "workspace:^",
     "@aztec/kv-store": "workspace:^",
+    "@aztec/noir-contracts.js": "workspace:^",
+    "@aztec/protocol-contracts": "workspace:^",
     "@aztec/types": "workspace:^",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
@@ -96,7 +98,7 @@
     "jest-mock-extended": "^3.0.3",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4",
-    "viem": "^2.7.15"
+    "viem": "2.22.8"
   },
   "files": [
     "dest",

package/src/avm_proving_tests/avm_proving_tester.ts

@@ -0,0 +1,175 @@
+import { type MerkleTreeWriteOperations } from '@aztec/circuit-types';
+import { type AvmCircuitInputs, AztecAddress, VerificationKeyData } from '@aztec/circuits.js';
+import { openTmpStore } from '@aztec/kv-store/lmdb';
+import { PublicTxSimulationTester, type TestEnqueuedCall } from '@aztec/simulator/public/fixtures';
+import { MerkleTrees } from '@aztec/world-state';
+
+import fs from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'path';
+
+import { SimpleContractDataSource } from '../../../simulator/src/avm/fixtures/simple_contract_data_source.js';
+import {
+  type BBResult,
+  type BBSuccess,
+  BB_RESULT,
+  generateAvmProof,
+  generateAvmProofV2,
+  verifyAvmProof,
+  verifyAvmProofV2,
+} from '../bb/execute.js';
+import { extractAvmVkData } from '../verification_key/verification_key_data.js';
+
+const BB_PATH = path.resolve('../../barretenberg/cpp/build/bin/bb');
+
+export class AvmProvingTester extends PublicTxSimulationTester {
+  constructor(
+    private bbWorkingDirectory: string,
+    private checkCircuitOnly: boolean,
+    contractDataSource: SimpleContractDataSource,
+    merkleTrees: MerkleTreeWriteOperations,
+    skipContractDeployments: boolean,
+  ) {
+    super(contractDataSource, merkleTrees, skipContractDeployments);
+  }
+
+  static override async create(checkCircuitOnly: boolean = false, skipContractDeployments: boolean = false) {
+    const bbWorkingDirectory = await fs.mkdtemp(path.join(tmpdir(), 'bb-'));
+
+    const contractDataSource = new SimpleContractDataSource();
+    const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
+    return new AvmProvingTester(
+      bbWorkingDirectory,
+      checkCircuitOnly,
+      contractDataSource,
+      merkleTrees,
+      skipContractDeployments,
+    );
+  }
+
+  async prove(avmCircuitInputs: AvmCircuitInputs): Promise<BBResult> {
+    // Then we prove.
+    const proofRes = await generateAvmProof(
+      BB_PATH,
+      this.bbWorkingDirectory,
+      avmCircuitInputs,
+      this.logger,
+      this.checkCircuitOnly,
+    );
+    if (proofRes.status === BB_RESULT.FAILURE) {
+      this.logger.error(`Proof generation failed: ${proofRes.reason}`);
+    }
+    return proofRes;
+  }
+
+  async verify(proofRes: BBSuccess): Promise<BBResult> {
+    if (this.checkCircuitOnly) {
+      // Skip verification if we're only checking the circuit.
+      // Check-circuit doesn't generate a proof to verify.
+      return proofRes;
+    }
+    // Then we test VK extraction and serialization.
+    const succeededRes = proofRes as BBSuccess;
+    const vkData = await extractAvmVkData(succeededRes.vkPath!);
+    VerificationKeyData.fromBuffer(vkData.toBuffer());
+
+    // Then we verify.
+    const rawVkPath = path.join(succeededRes.vkPath!, 'vk');
+    return await verifyAvmProof(BB_PATH, succeededRes.proofPath!, rawVkPath, this.logger);
+  }
+
+  public async simProveVerify(
+    sender: AztecAddress,
+    setupCalls: TestEnqueuedCall[],
+    appCalls: TestEnqueuedCall[],
+    teardownCall: TestEnqueuedCall | undefined,
+    expectRevert: boolean | undefined,
+    feePayer?: AztecAddress,
+  ) {
+    const simRes = await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer);
+    expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
+    const avmCircuitInputs = simRes.avmProvingRequest.inputs;
+    const provingRes = await this.prove(avmCircuitInputs);
+    expect(provingRes.status).toEqual(BB_RESULT.SUCCESS);
+    const verificationRes = await this.verify(provingRes as BBSuccess);
+    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
+  }
+
+  public async simProveVerifyAppLogic(appCall: TestEnqueuedCall, expectRevert?: boolean) {
+    const simRes = await this.simulateTx(/*sender=*/ AztecAddress.fromNumber(42), /*setupCalls=*/ [], [appCall]);
+    expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
+
+    const avmCircuitInputs = simRes.avmProvingRequest.inputs;
+    const provingRes = await this.prove(avmCircuitInputs);
+    expect(provingRes.status).toEqual(BB_RESULT.SUCCESS);
+
+    const verificationRes = await this.verify(provingRes as BBSuccess);
+    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
+  }
+}
+
+export class AvmProvingTesterV2 extends PublicTxSimulationTester {
+  constructor(
+    private bbWorkingDirectory: string,
+    contractDataSource: SimpleContractDataSource,
+    merkleTrees: MerkleTreeWriteOperations,
+    skipContractDeployments: boolean,
+  ) {
+    super(contractDataSource, merkleTrees, skipContractDeployments);
+  }
+
+  static override async create(skipContractDeployments: boolean = false) {
+    const bbWorkingDirectory = await fs.mkdtemp(path.join(tmpdir(), 'bb-'));
+
+    const contractDataSource = new SimpleContractDataSource();
+    const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
+    return new AvmProvingTesterV2(bbWorkingDirectory, contractDataSource, merkleTrees, skipContractDeployments);
+  }
+
+  async proveV2(avmCircuitInputs: AvmCircuitInputs): Promise<BBResult> {
+    // Then we prove.
+    const proofRes = await generateAvmProofV2(BB_PATH, this.bbWorkingDirectory, avmCircuitInputs, this.logger);
+    if (proofRes.status === BB_RESULT.FAILURE) {
+      this.logger.error(`Proof generation failed: ${proofRes.reason}`);
+    }
+    expect(proofRes.status).toEqual(BB_RESULT.SUCCESS);
+    return proofRes as BBSuccess;
+  }
+
+  async verifyV2(proofRes: BBSuccess): Promise<BBResult> {
+    // Then we verify.
+    // Placeholder for now.
+    const publicInputs = {
+      dummy: [] as any[],
+    };
+
+    const rawVkPath = path.join(proofRes.vkPath!, 'vk');
+    return await verifyAvmProofV2(
+      BB_PATH,
+      this.bbWorkingDirectory,
+      proofRes.proofPath!,
+      publicInputs,
+      rawVkPath,
+      this.logger,
+    );
+  }
+
+  public async simProveVerifyV2(
+    sender: AztecAddress,
+    setupCalls: TestEnqueuedCall[],
+    appCalls: TestEnqueuedCall[],
+    teardownCall: TestEnqueuedCall | undefined,
+    expectRevert: boolean | undefined,
+    feePayer?: AztecAddress,
+  ) {
+    const simRes = await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer);
+    expect(simRes.revertCode.isOK()).toBe(expectRevert ? false : true);
+
+    const avmCircuitInputs = simRes.avmProvingRequest.inputs;
+    const provingRes = await this.proveV2(avmCircuitInputs);
+    expect(provingRes.status).toEqual(BB_RESULT.SUCCESS);
+
+    const verificationRes = await this.verifyV2(provingRes as BBSuccess);
+    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
+  }
+}

package/src/bb/cli.ts

@@ -5,11 +5,6 @@ import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { Command } from 'commander';
-import { promises as fs } from 'fs';
-
-import { generateContractForCircuit, generateKeyForNoirCircuit } from './execute.js';
-
-const { BB_WORKING_DIRECTORY, BB_BINARY_PATH } = process.env;
 
 export const ProtocolCircuitArtifacts: Record<ProtocolArtifact, NoirCompiledCircuit> = {
   ...ClientCircuitArtifacts,
@@ -33,76 +28,5 @@ export function getProgram(log: LogFn): Command {
       log(Object.keys(ProtocolCircuitArtifacts).reduce((prev: string, x: string) => prev.concat(`\n${x}`)));
     });
 
-  program
-    .command('write-vk')
-    .description('Generates the verification key for the specified circuit')
-    .requiredOption(
-      '-w, --working-directory <string>',
-      'A directory to use for storing input/output files',
-      BB_WORKING_DIRECTORY,
-    )
-    .requiredOption('-b, --bb-path <string>', 'The path to the BB binary', BB_BINARY_PATH)
-    .requiredOption('-c, --circuit <string>', 'The name of a protocol circuit')
-    .requiredOption('-f, --flavor <string>', 'The name of the verification key flavor', 'ultra_honk')
-    .option('-r, --recursive', 'Whether a SNARK friendly key should be generated', false)
-    .action(async options => {
-      const compiledCircuit = ProtocolCircuitArtifacts[options.circuit as ProtocolArtifact];
-      if (!compiledCircuit) {
-        log(`Failed to find circuit ${options.circuit}`);
-        return;
-      }
-      try {
-        await fs.access(options.workingDirectory, fs.constants.W_OK);
-      } catch (error) {
-        log(`Working directory does not exist`);
-        return;
-      }
-      await generateKeyForNoirCircuit(
-        options.bbPath,
-        options.workingDirectory,
-        options.circuit,
-        compiledCircuit,
-        options.recursive,
-        options.flavor,
-        // (options.circuit as ServerProtocolArtifact) === 'RootRollupArtifact' ? 'ultra_keccak_honk' : 'ultra_honk',
-        log,
-      );
-    });
-
-  program
-    .command('write-contract')
-    .description('Generates the verification contract for the specified circuit')
-    .requiredOption(
-      '-w, --working-directory <string>',
-      'A directory to use for storing input/output files',
-      BB_WORKING_DIRECTORY,
-    )
-    .requiredOption('-b, --bb-path <string>', 'The path to the BB binary', BB_BINARY_PATH)
-    .requiredOption('-c, --circuit <string>', 'The name of a protocol circuit')
-    .requiredOption('-n --contract-name <string>', 'The name of the contract to generate', 'contract.sol')
-    .action(async options => {
-      const compiledCircuit = ProtocolCircuitArtifacts[options.circuit as ProtocolArtifact];
-      if (!compiledCircuit) {
-        log(`Failed to find circuit ${options.circuit}`);
-        return;
-      }
-      try {
-        await fs.access(options.workingDirectory, fs.constants.W_OK);
-      } catch (error) {
-        log(`Working directory does not exist`);
-        return;
-      }
-
-      await generateContractForCircuit(
-        options.bbPath,
-        options.workingDirectory,
-        options.circuit,
-        compiledCircuit,
-        options.contractName,
-        log,
-        /*force= */ true,
-      );
-    });
-
   return program;
 }

package/src/bb/execute.ts

@@ -2,13 +2,13 @@ import { type AvmCircuitInputs, serializeWithMessagePack } from '@aztec/circuits
 import { sha256 } from '@aztec/foundation/crypto';
 import { type LogFn, type Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
 import { basename, dirname, join } from 'path';
 
 import { type UltraHonkFlavor } from '../honk.js';
+import { CLIENT_IVC_PROOF_FILE_NAME, CLIENT_IVC_VK_FILE_NAME } from '../prover/client_ivc_proof_utils.js';
 
 export const VK_FILENAME = 'vk';
 export const VK_FIELDS_FILENAME = 'vk_fields.json';
@@ -97,103 +97,6 @@ export function executeBB(
   }).catch(_ => ({ status: BB_RESULT.FAILURE, exitCode: -1, signal: undefined }));
 }
 
-const bytecodeFilename = 'bytecode';
-
-/**
- * Used for generating either a proving or verification key, will exit early if the key already exists
- * It assumes the provided working directory is one where the caller wishes to maintain a permanent set of keys
- * It is not considered a temporary directory
- * @param pathToBB - The full path to the bb binary
- * @param workingDirectory - The directory into which the key should be created
- * @param circuitName - An identifier for the circuit
- * @param compiledCircuit - The compiled circuit
- * @param key - The type of key, either 'pk' or 'vk'
- * @param log - A logging function
- * @param force - Force the key to be regenerated even if it already exists
- * @returns An instance of BBResult
- */
-export async function generateKeyForNoirCircuit(
-  pathToBB: string,
-  workingDirectory: string,
-  circuitName: string,
-  compiledCircuit: NoirCompiledCircuit,
-  recursive: boolean,
-  flavor: UltraHonkFlavor,
-  log: LogFn,
-  force = false,
-): Promise<BBSuccess | BBFailure> {
-  const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
-
-  // The key generation is written to e.g. /workingDirectory/pk/BaseParityArtifact/pk
-  // The bytecode hash file is also written here as /workingDirectory/pk/BaseParityArtifact/bytecode-hash
-  // The bytecode is written to e.g. /workingDirectory/pk/BaseParityArtifact/bytecode
-  // The bytecode is removed after the key is generated, leaving just the hash file
-  const circuitOutputDirectory = `${workingDirectory}/vk/${circuitName}`;
-  const outputPath = `${circuitOutputDirectory}`;
-  const bytecodeHash = sha256(bytecode);
-
-  // ensure the directory exists
-  await fs.mkdir(circuitOutputDirectory, { recursive: true });
-
-  const res = await fsCache<BBSuccess | BBFailure>(circuitOutputDirectory, bytecodeHash, log, force, async () => {
-    const binaryPresent = await fs
-      .access(pathToBB, fs.constants.R_OK)
-      .then(_ => true)
-      .catch(_ => false);
-    if (!binaryPresent) {
-      return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
-    }
-
-    // We are now going to generate the key
-    try {
-      const bytecodePath = `${circuitOutputDirectory}/${bytecodeFilename}`;
-      // Write the bytecode to the working directory
-      await fs.writeFile(bytecodePath, bytecode);
-
-      // args are the output path and the input bytecode path
-      const args = ['-o', `${outputPath}/${VK_FILENAME}`, '-b', bytecodePath, recursive ? '--recursive' : ''];
-      const timer = new Timer();
-      let result = await executeBB(pathToBB, `write_vk_${flavor}`, args, log);
-
-      // If we succeeded and the type of key if verification, have bb write the 'fields' version too
-      if (result.status == BB_RESULT.SUCCESS) {
-        const asFieldsArgs = ['-k', `${outputPath}/${VK_FILENAME}`, '-o', `${outputPath}/${VK_FIELDS_FILENAME}`, '-v'];
-        result = await executeBB(pathToBB, `vk_as_fields_${flavor}`, asFieldsArgs, log);
-      }
-      const duration = timer.ms();
-
-      if (result.status == BB_RESULT.SUCCESS) {
-        return {
-          status: BB_RESULT.SUCCESS,
-          durationMs: duration,
-          pkPath: undefined,
-          vkPath: outputPath,
-          proofPath: undefined,
-        };
-      }
-      // Not a great error message here but it is difficult to decipher what comes from bb
-      return {
-        status: BB_RESULT.FAILURE,
-        reason: `Failed to generate key. Exit code: ${result.exitCode}. Signal ${result.signal}.`,
-        retry: !!result.signal,
-      };
-    } catch (error) {
-      return { status: BB_RESULT.FAILURE, reason: `${error}` };
-    }
-  });
-
-  if (!res) {
-    return {
-      status: BB_RESULT.ALREADY_PRESENT,
-      durationMs: 0,
-      pkPath: undefined,
-      vkPath: outputPath,
-    };
-  }
-
-  return res;
-}
-
 // TODO(#7369) comment this etc (really just take inspiration from this and rewrite it all O:))
 export async function executeBbClientIvcProof(
   pathToBB: string,
@@ -443,8 +346,8 @@ export async function generateTubeProof(
   }
 
   // // Paths for the inputs
-  const vkPath = join(workingDirectory, 'client_ivc_vk.bin');
-  const proofPath = join(workingDirectory, 'client_ivc_proof.bin');
+  const vkPath = join(workingDirectory, CLIENT_IVC_VK_FILE_NAME);
+  const proofPath = join(workingDirectory, CLIENT_IVC_PROOF_FILE_NAME);
 
   // The proof is written to e.g. /workingDirectory/proof
   const outputPath = workingDirectory;
@@ -460,7 +363,7 @@ export async function generateTubeProof(
   }
 
   try {
-    if (!filePresent(vkPath) || !filePresent(proofPath)) {
+    if (!(await filePresent(vkPath)) || !(await filePresent(proofPath))) {
       return { status: BB_RESULT.FAILURE, reason: `Client IVC input files not present in  ${workingDirectory}` };
     }
     const args = ['-o', outputPath, '-v'];
@@ -534,7 +437,7 @@ export async function generateAvmProofV2(
     // Write the inputs to the working directory.
     const avmInputsPath = join(workingDirectory, 'avm_inputs.bin');
     await fs.writeFile(avmInputsPath, inputsBuffer);
-    if (!filePresent(avmInputsPath)) {
+    if (!(await filePresent(avmInputsPath))) {
       return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
     }
 
@@ -616,13 +519,13 @@ export async function generateAvmProof(
   try {
     // Write the inputs to the working directory.
 
-    await fs.writeFile(publicInputsPath, input.output.toBuffer());
-    if (!filePresent(publicInputsPath)) {
+    await fs.writeFile(publicInputsPath, input.publicInputs.toBuffer());
+    if (!(await filePresent(publicInputsPath))) {
       return { status: BB_RESULT.FAILURE, reason: `Could not write publicInputs at ${publicInputsPath}` };
     }
 
     await fs.writeFile(avmHintsPath, input.avmHints.toBuffer());
-    if (!filePresent(avmHintsPath)) {
+    if (!(await filePresent(avmHintsPath))) {
       return { status: BB_RESULT.FAILURE, reason: `Could not write avmHints at ${avmHintsPath}` };
     }
 
@@ -717,7 +620,7 @@ export async function verifyAvmProofV2(
       .catch(_ => false);
   const avmInputsPath = join(workingDirectory, 'avm_public_inputs.bin');
   await fs.writeFile(avmInputsPath, inputsBuffer);
-  if (!filePresent(avmInputsPath)) {
+  if (!(await filePresent(avmInputsPath))) {
     return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
   }
 
@@ -960,43 +863,6 @@ export async function generateContractForVerificationKey(
   return res;
 }
 
-export async function generateContractForCircuit(
-  pathToBB: string,
-  workingDirectory: string,
-  circuitName: string,
-  compiledCircuit: NoirCompiledCircuit,
-  contractName: string,
-  log: LogFn,
-  force = false,
-) {
-  // Verifier contracts are never recursion friendly, because non-recursive proofs are generated using the keccak256 hash function.
-  // We need to use the same hash function during verification so proofs generated using keccak256 are cheap to verify on ethereum
-  // (where the verifier contract would be deployed) whereas if we want to verify the proof within a snark (for recursion) we want
-  // to use a snark-friendly hash function.
-  const recursive = false;
-
-  const vkResult = await generateKeyForNoirCircuit(
-    pathToBB,
-    workingDirectory,
-    circuitName,
-    compiledCircuit,
-    recursive,
-    'ultra_keccak_honk',
-    log,
-    force,
-  );
-  if (vkResult.status === BB_RESULT.FAILURE) {
-    return vkResult;
-  }
-
-  return generateContractForVerificationKey(
-    pathToBB,
-    join(vkResult.vkPath!, VK_FILENAME),
-    join(workingDirectory, 'contract', circuitName, contractName),
-    log,
-  );
-}
-
 /**
  * Compute bb gate count for a given circuit
  * @param pathToBB - The full path to the bb binary

package/src/prover/bb_private_kernel_prover.ts

@@ -166,7 +166,15 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     const witnessMap = convertInputs(inputs, compiledCircuit.abi);
 
     const timer = new Timer();
-    const outputWitness = await this.simulationProvider.executeProtocolCircuit(witnessMap, compiledCircuit);
+    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}`, {