@aztec/bb-prover 0.80.0 → 0.82.0

package/dest/verifier/bb_verifier.d.ts

@@ -5,6 +5,8 @@ import type { Proof } from '@aztec/stdlib/proofs';
 import { Tx } from '@aztec/stdlib/tx';
 import type { VerificationKeyData } from '@aztec/stdlib/vks';
 import type { BBConfig } from '../config.js';
+export declare const PRIVATE_TAIL_CIVC_VK: string;
+export declare const PUBLIC_TAIL_CIVC_VK: string;
 export declare class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
     private config;
     private logger;

package/dest/verifier/bb_verifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bb_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/bb_verifier.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAA0B,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAChH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAM7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAK7C,qBAAa,iBAAkB,YAAW,6BAA6B;IACjD,OAAO,CAAC,MAAM;IAAY,OAAO,CAAC,MAAM;IAA5D,OAAO;WAEa,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAqC;IAK9E,sBAAsB,CAAC,WAAW,EAAE,sBAAsB,GAAG,mBAAmB;IAQ1E,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK;IAkCnE,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CA4CnD"}
+{"version":3,"file":"bb_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/bb_verifier.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAA0B,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAChH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAO7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAQ7C,eAAO,MAAM,oBAAoB,QAA0D,CAAC;AAC5F,eAAO,MAAM,mBAAmB,QAAyD,CAAC;AAE1F,qBAAa,iBAAkB,YAAW,6BAA6B;IACjD,OAAO,CAAC,MAAM;IAAY,OAAO,CAAC,MAAM;IAA5D,OAAO;WAEa,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAqC;IAK9E,sBAAsB,CAAC,WAAW,EAAE,sBAAsB,GAAG,mBAAmB;IAQ1E,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK;IAkCnE,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CA4CnD"}

package/dest/verifier/bb_verifier.js

@@ -4,10 +4,15 @@ import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks
 import { Tx } from '@aztec/stdlib/tx';
 import { promises as fs } from 'fs';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
 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 { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Built by yarn generate
+export const PRIVATE_TAIL_CIVC_VK = path.join(__dirname, '../../artifacts/private-civc-vk');
+export const PUBLIC_TAIL_CIVC_VK = path.join(__dirname, '../../artifacts/public-civc-vk');
 export class BBCircuitVerifier {
     config;
     logger;
@@ -64,7 +69,7 @@ export class BBCircuitVerifier {
                     this.logger.debug(`${circuit} BB out - ${message}`);
                 };
                 await writeToOutputDirectory(tx.clientIvcProof, bbWorkingDirectory);
-                const result = await verifyClientIvcProof(this.config.bbBinaryPath, bbWorkingDirectory.concat('/proof'), bbWorkingDirectory.concat('/vk'), logFunction);
+                const result = await verifyClientIvcProof(this.config.bbBinaryPath, bbWorkingDirectory.concat('/proof'), tx.data.forPublic ? PUBLIC_TAIL_CIVC_VK : PRIVATE_TAIL_CIVC_VK, logFunction);
                 if (result.status === BB_RESULT.FAILURE) {
                     const errorMessage = `Failed to verify ${circuit} proof!`;
                     throw new Error(errorMessage);
@@ -79,7 +84,7 @@ export class BBCircuitVerifier {
             await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
             return true;
         } catch (err) {
-            this.logger.warn(`Failed to verify ClientIVC proof for tx ${Tx.getHash(tx)}: ${String(err)}`);
+            this.logger.warn(`Failed to verify ClientIVC proof for tx ${await Tx.getHash(tx)}: ${String(err)}`);
             return false;
         }
     }

package/dest/wasm/bb_wasm_private_kernel_prover.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import type { ArtifactProvider } from '@aztec/noir-protocol-circuits-types/types';
-import type { WitnessMap } from '@aztec/noir-types';
 import type { SimulationProvider } from '@aztec/simulator/client';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import { BBPrivateKernelProver } from '../prover/bb_private_kernel_prover.js';
 export declare abstract class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
@@ -11,7 +11,7 @@ export declare abstract class BBWASMPrivateKernelProver extends BBPrivateKernelP
     private threads;
     protected log: import("@aztec/foundation/log").Logger;
     constructor(artifactProvider: ArtifactProvider, simulationProvider: SimulationProvider, threads?: number, log?: import("@aztec/foundation/log").Logger);
-    createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof>;
+    createClientIvcProof(executionSteps: PrivateExecutionStep[]): Promise<ClientIvcProof>;
     computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number>;
 }
 //# sourceMappingURL=bb_wasm_private_kernel_prover.d.ts.map

package/dest/wasm/bb_wasm_private_kernel_prover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bb_wasm_private_kernel_prover.d.ts","sourceRoot":"","sources":["../../src/wasm/bb_wasm_private_kernel_prover.ts"],"names":[],"mappings":";;AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAItD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAE9E,8BAAsB,yBAA0B,SAAQ,qBAAqB;cAEtD,gBAAgB,EAAE,gBAAgB;cAClC,kBAAkB,EAAE,kBAAkB;IACzD,OAAO,CAAC,OAAO;cACI,GAAG;gBAHH,gBAAgB,EAAE,gBAAgB,EAClC,kBAAkB,EAAE,kBAAkB,EACjD,OAAO,GAAE,MAAU,EACR,GAAG,yCAAiC;IAKnC,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAmB1F,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAY3G"}
+{"version":3,"file":"bb_wasm_private_kernel_prover.d.ts","sourceRoot":"","sources":["../../src/wasm/bb_wasm_private_kernel_prover.ts"],"names":[],"mappings":";;AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAItD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAE9E,8BAAsB,yBAA0B,SAAQ,qBAAqB;cAEtD,gBAAgB,EAAE,gBAAgB;cAClC,kBAAkB,EAAE,kBAAkB;IACzD,OAAO,CAAC,OAAO;cACI,GAAG;gBAHH,gBAAgB,EAAE,gBAAgB,EAClC,kBAAkB,EAAE,kBAAkB,EACjD,OAAO,GAAE,MAAU,EACR,GAAG,yCAAiC;IAKnC,oBAAoB,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAoBrF,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAY3G"}

package/dest/wasm/bb_wasm_private_kernel_prover.js

@@ -13,23 +13,24 @@ export class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
     constructor(artifactProvider, simulationProvider, threads = 1, log = createLogger('bb-prover:wasm')){
         super(artifactProvider, simulationProvider, log), this.artifactProvider = artifactProvider, this.simulationProvider = simulationProvider, this.threads = threads, this.log = log;
     }
-    async createClientIvcProof(acirs, witnessStack) {
+    async createClientIvcProof(executionSteps) {
         const timer = new Timer();
         this.log.info(`Generating ClientIVC proof...`);
-        const backend = new AztecClientBackend(acirs.map((acir)=>ungzip(acir)), {
+        const backend = new AztecClientBackend(executionSteps.map((step)=>ungzip(step.bytecode)), {
             threads: this.threads,
             logger: this.log.verbose,
             wasmPath: process.env.BB_WASM_PATH
         });
-        const [proof, vk] = await backend.prove(witnessStack.map((witnessMap)=>ungzip(serializeWitness(witnessMap))));
+        // TODO(https://github.com/AztecProtocol/barretenberg/issues/1297): the vk is not provided to the network anymore.
+        // Move this sanity check inside the wasm code and remove the vk from the return value.
+        const [proof, _vk] = await backend.prove(executionSteps.map((step)=>ungzip(serializeWitness(step.witness))));
         await backend.destroy();
         this.log.info(`Generated ClientIVC proof`, {
             eventName: 'client-ivc-proof-generation',
             duration: timer.ms(),
-            proofSize: proof.length,
-            vkSize: vk.length
+            proofSize: proof.length
         });
-        return new ClientIvcProof(Buffer.from(proof), Buffer.from(vk));
+        return new ClientIvcProof(Buffer.from(proof));
     }
     async computeGateCountForCircuit(_bytecode, _circuitName) {
         const backend = new AztecClientBackend([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/bb-prover",
-  "version": "0.80.0",
+  "version": "0.82.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -30,6 +30,7 @@
     "clean": "rm -rf ./dest .tsbuildinfo",
     "formatting": "run -T prettier --check ./src && run -T eslint ./src",
     "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "generate": "scripts/generate_civc_vks.sh",
     "bb": "node --no-warnings ./dest/bb/index.js",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -67,16 +68,16 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.80.0",
-    "@aztec/constants": "0.80.0",
-    "@aztec/foundation": "0.80.0",
-    "@aztec/noir-noirc_abi": "0.80.0",
-    "@aztec/noir-protocol-circuits-types": "0.80.0",
-    "@aztec/noir-types": "0.80.0",
-    "@aztec/simulator": "0.80.0",
-    "@aztec/stdlib": "0.80.0",
-    "@aztec/telemetry-client": "0.80.0",
-    "@aztec/world-state": "0.80.0",
+    "@aztec/bb.js": "0.82.0",
+    "@aztec/constants": "0.82.0",
+    "@aztec/foundation": "0.82.0",
+    "@aztec/noir-noirc_abi": "0.82.0",
+    "@aztec/noir-protocol-circuits-types": "0.82.0",
+    "@aztec/noir-types": "0.82.0",
+    "@aztec/simulator": "0.82.0",
+    "@aztec/stdlib": "0.82.0",
+    "@aztec/telemetry-client": "0.82.0",
+    "@aztec/world-state": "0.82.0",
     "@msgpack/msgpack": "^3.0.0-beta2",
     "commander": "^12.1.0",
     "pako": "^2.1.0",
@@ -84,10 +85,10 @@
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/ethereum": "0.80.0",
-    "@aztec/kv-store": "0.80.0",
-    "@aztec/noir-contracts.js": "0.80.0",
-    "@aztec/protocol-contracts": "0.80.0",
+    "@aztec/ethereum": "0.82.0",
+    "@aztec/kv-store": "0.82.0",
+    "@aztec/noir-contracts.js": "0.82.0",
+    "@aztec/protocol-contracts": "0.82.0",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/memdown": "^3.0.0",

package/src/avm_proving_tests/avm_proving_tester.ts

@@ -1,5 +1,5 @@
 import { PublicTxSimulationTester, type TestEnqueuedCall } from '@aztec/simulator/public/fixtures';
-import { SimpleContractDataSource, WorldStateDB } from '@aztec/simulator/server';
+import { SimpleContractDataSource } from '@aztec/simulator/server';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
@@ -28,11 +28,10 @@ export class AvmProvingTester extends PublicTxSimulationTester {
   constructor(
     private bbWorkingDirectory: string,
     private checkCircuitOnly: boolean,
-    worldStateDB: WorldStateDB,
+    merkleTree: MerkleTreeWriteOperations,
     contractDataSource: SimpleContractDataSource,
-    merkleTrees: MerkleTreeWriteOperations,
   ) {
-    super(worldStateDB, contractDataSource, merkleTrees);
+    super(merkleTree, contractDataSource);
   }
 
   static override async create(checkCircuitOnly: boolean = false) {
@@ -40,8 +39,7 @@ export class AvmProvingTester extends PublicTxSimulationTester {
 
     const contractDataSource = new SimpleContractDataSource();
     const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-    return new AvmProvingTester(bbWorkingDirectory, checkCircuitOnly, worldStateDB, contractDataSource, merkleTrees);
+    return new AvmProvingTester(bbWorkingDirectory, checkCircuitOnly, merkleTrees, contractDataSource);
   }
 
   async prove(avmCircuitInputs: AvmCircuitInputs): Promise<BBResult> {
@@ -108,11 +106,10 @@ export class AvmProvingTester extends PublicTxSimulationTester {
 export class AvmProvingTesterV2 extends PublicTxSimulationTester {
   constructor(
     private bbWorkingDirectory: string,
-    worldStateDB: WorldStateDB,
     contractDataSource: SimpleContractDataSource,
     merkleTrees: MerkleTreeWriteOperations,
   ) {
-    super(worldStateDB, contractDataSource, merkleTrees);
+    super(merkleTrees, contractDataSource);
   }
 
   static override async create() {
@@ -120,8 +117,7 @@ export class AvmProvingTesterV2 extends PublicTxSimulationTester {
 
     const contractDataSource = new SimpleContractDataSource();
     const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-    return new AvmProvingTesterV2(bbWorkingDirectory, worldStateDB, contractDataSource, merkleTrees);
+    return new AvmProvingTesterV2(bbWorkingDirectory, contractDataSource, merkleTrees);
   }
 
   async proveV2(avmCircuitInputs: AvmCircuitInputs): Promise<BBResult> {

package/src/bb/execute.ts

@@ -8,7 +8,7 @@ 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';
+import { CLIENT_IVC_PROOF_FILE_NAME } from '../prover/client_ivc_proof_utils.js';
 
 export const VK_FILENAME = 'vk';
 export const VK_FIELDS_FILENAME = 'vk_fields.json';
@@ -62,6 +62,7 @@ type BBExecResult = {
  * @param command - The command to execute
  * @param args - The arguments to pass
  * @param logger - A log function
+ * @param timeout - An optional timeout before killing the BB process
  * @param resultParser - An optional handler for detecting success or failure
  * @returns The completed partial witness outputted from the circuit
  */
@@ -70,6 +71,7 @@ export function executeBB(
   command: string,
   args: string[],
   logger: LogFn,
+  timeout?: number,
   resultParser = (code: number) => code === 0,
 ): Promise<BBExecResult> {
   return new Promise<BBExecResult>(resolve => {
@@ -80,6 +82,18 @@ export function executeBB(
     const bb = proc.spawn(pathToBB, [command, ...args], {
       env,
     });
+
+    let timeoutId: NodeJS.Timeout | undefined;
+    if (timeout !== undefined) {
+      timeoutId = setTimeout(() => {
+        logger(`BB execution timed out after ${timeout}ms, killing process`);
+        if (bb.pid) {
+          bb.kill('SIGKILL');
+        }
+        resolve({ status: BB_RESULT.FAILURE, exitCode: -1, signal: 'TIMEOUT' });
+      }, timeout);
+    }
+
     bb.stdout.on('data', data => {
       const message = data.toString('utf-8').replace(/\n$/, '');
       logger(message);
@@ -89,6 +103,9 @@ export function executeBB(
       logger(message);
     });
     bb.on('close', (exitCode: number, signal?: string) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
       if (resultParser(exitCode)) {
         resolve({ status: BB_RESULT.SUCCESS, exitCode, signal });
       } else {
@@ -98,7 +115,6 @@ export function executeBB(
   }).catch(_ => ({ status: BB_RESULT.FAILURE, exitCode: -1, signal: undefined }));
 }
 
-// TODO(#7369) comment this etc (really just take inspiration from this and rewrite it all O:))
 export async function executeBbClientIvcProof(
   pathToBB: string,
   workingDirectory: string,
@@ -275,17 +291,13 @@ export async function generateProof(
 /**
  * Used for generating proofs of the tube circuit
  * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
- * @param pathToBB - The full path to the bb binary
- * @param workingDirectory - A working directory for use by bb
- * @param circuitName - An identifier for the circuit
- * @param bytecode - The compiled circuit bytecode
- * @param inputWitnessFile - The circuit input witness
- * @param log - A logging function
+ *
  * @returns An object containing a result indication, the location of the proof and the duration taken
  */
 export async function generateTubeProof(
   pathToBB: string,
   workingDirectory: string,
+  vkPath: string,
   log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
@@ -295,8 +307,7 @@ export async function generateTubeProof(
     return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
-  // // Paths for the inputs
-  const vkPath = join(workingDirectory, CLIENT_IVC_VK_FILE_NAME);
+  // Paths for the inputs
   const proofPath = join(workingDirectory, CLIENT_IVC_PROOF_FILE_NAME);
 
   // The proof is written to e.g. /workingDirectory/proof
@@ -313,10 +324,10 @@ export async function generateTubeProof(
   }
 
   try {
-    if (!(await filePresent(vkPath)) || !(await filePresent(proofPath))) {
+    if (!(await filePresent(proofPath))) {
       return { status: BB_RESULT.FAILURE, reason: `Client IVC input files not present in  ${workingDirectory}` };
     }
-    const args = ['-o', outputPath, '-v'];
+    const args = ['-o', outputPath, '-k', vkPath, '-v'];
 
     const timer = new Timer();
     const logFunction = (message: string) => {
@@ -610,7 +621,8 @@ export async function verifyClientIvcProof(
     const args = ['--scheme', 'client_ivc', '-p', proofPath, '-k', keyPath];
     const timer = new Timer();
     const command = 'verify';
-    const result = await executeBB(pathToBB, command, args, log);
+    const timeout = 1000; // 1s verification timeout for invalid proofs
+    const result = await executeBB(pathToBB, command, args, log, timeout);
     const duration = timer.ms();
     if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, durationMs: duration };

package/src/prover/bb_native_private_kernel_prover.ts

@@ -2,8 +2,8 @@ import { runInDirectory } from '@aztec/foundation/fs';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { serializeWitness } from '@aztec/noir-noirc_abi';
 import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
-import type { WitnessMap } from '@aztec/noir-types';
 import type { SimulationProvider } from '@aztec/simulator/server';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
 import type { ClientIvcProof } from '@aztec/stdlib/proofs';
 
 import { encode } from '@msgpack/msgpack';
@@ -40,18 +40,26 @@ export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
     );
   }
 
+  // TODO(#7371): This is duplicated.
+  // Longer term we won't use this hacked together msgpack format
+  // Leaving duplicated as this eventually bb will provide a serialization
+  // helper for passing to a generic msgpack RPC endpoint.
+  private async _createClientIvcProofFiles(directory: string, executionSteps: PrivateExecutionStep[]) {
+    const acirPath = path.join(directory, 'acir.msgpack');
+    const witnessPath = path.join(directory, 'witnesses.msgpack');
+    await fs.writeFile(acirPath, encode(executionSteps.map(map => map.bytecode)));
+    await fs.writeFile(witnessPath, encode(executionSteps.map(map => serializeWitness(map.witness))));
+    return {
+      acirPath,
+      witnessPath,
+    };
+  }
+
   private async _createClientIvcProof(
     directory: string,
-    acirs: Buffer[],
-    witnessStack: WitnessMap[],
+    executionSteps: PrivateExecutionStep[],
   ): 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))),
-    );
+    await this._createClientIvcProofFiles(directory, executionSteps);
     const provingResult = await executeBbClientIvcProof(
       this.bbBinaryPath,
       directory,
@@ -75,10 +83,10 @@ export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
     return proof;
   }
 
-  public override async createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+  public override async createClientIvcProof(executionSteps: PrivateExecutionStep[]): Promise<ClientIvcProof> {
     this.log.info(`Generating Client IVC proof`);
     const operation = async (directory: string) => {
-      return await this._createClientIvcProof(directory, acirs, witnessStack);
+      return await this._createClientIvcProof(directory, executionSteps);
     };
     return await this.runInDirectory(operation);
   }

package/src/prover/bb_private_kernel_prover.ts

@@ -11,6 +11,7 @@ import {
   convertPrivateKernelTailInputsToWitnessMapWithAbi,
   convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
   convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+  foreignCallHandler,
   getPrivateKernelResetArtifactName,
   updateResetCircuitSampleInputs,
 } from '@aztec/noir-protocol-circuits-types/client';
@@ -19,6 +20,7 @@ import type { Abi, WitnessMap } from '@aztec/noir-types';
 import type { SimulationProvider } from '@aztec/simulator/client';
 import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 import type {
+  PrivateExecutionStep,
   PrivateKernelCircuitPublicInputs,
   PrivateKernelInitCircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
@@ -27,7 +29,7 @@ import type {
   PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 import type { ClientIvcProof } from '@aztec/stdlib/proofs';
 import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 
@@ -158,15 +160,14 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     convertInputs: (inputs: I, abi: Abi) => WitnessMap,
     convertOutputs: (outputs: WitnessMap, abi: Abi) => O,
   ): Promise<PrivateKernelSimulateOutput<O>> {
-    const compiledCircuit: NoirCompiledCircuit = await this.artifactProvider.getSimulatedClientCircuitArtifactByName(
-      circuitType,
-    );
+    const compiledCircuit: NoirCompiledCircuitWithName =
+      await this.artifactProvider.getSimulatedClientCircuitArtifactByName(circuitType);
 
     const witnessMap = convertInputs(inputs, compiledCircuit.abi);
 
     const timer = new Timer();
     const outputWitness = await this.simulationProvider
-      .executeProtocolCircuit(witnessMap, compiledCircuit)
+      .executeProtocolCircuit(witnessMap, compiledCircuit, foreignCallHandler)
       .catch((err: Error) => {
         this.log.debug(`Failed to simulate ${circuitType}`, {
           circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
@@ -197,13 +198,17 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     convertOutputs: (outputs: WitnessMap, abi: Abi) => O,
   ): Promise<PrivateKernelSimulateOutput<O>> {
     this.log.debug(`Generating witness for ${circuitType}`);
-    const compiledCircuit: NoirCompiledCircuit = await this.artifactProvider.getClientCircuitArtifactByName(
+    const compiledCircuit: NoirCompiledCircuitWithName = await this.artifactProvider.getClientCircuitArtifactByName(
       circuitType,
     );
 
     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,
+      foreignCallHandler,
+    );
     const output = convertOutputs(outputWitness, compiledCircuit.abi);
 
     this.log.debug(`Generated witness for ${circuitType}`, {
@@ -238,7 +243,7 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     return kernelProofOutput;
   }
 
-  public createClientIvcProof(_acirs: Buffer[], _witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+  public createClientIvcProof(_executionSteps: PrivateExecutionStep[]): Promise<ClientIvcProof> {
     throw new Error('Not implemented');
   }
 

package/src/prover/bb_prover.ts

@@ -14,7 +14,6 @@ import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { Timer } from '@aztec/foundation/timer';
 import {
-  ServerCircuitArtifacts,
   type ServerProtocolArtifact,
   convertBaseParityInputsToWitnessMap,
   convertBaseParityOutputsFromWitnessMap,
@@ -36,6 +35,7 @@ import {
   convertRootRollupOutputsFromWitnessMap,
   convertSingleTxBlockRootRollupInputsToWitnessMap,
   convertSingleTxBlockRootRollupOutputsFromWitnessMap,
+  getServerCircuitArtifact,
 } from '@aztec/noir-protocol-circuits-types/server';
 import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
 import type { WitnessMap } from '@aztec/noir-types';
@@ -92,6 +92,7 @@ import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../honk.js';
 import { ProverInstrumentation } from '../instrumentation.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractAvmVkData, extractVkData } from '../verification_key/verification_key_data.js';
+import { PRIVATE_TAIL_CIVC_VK, PUBLIC_TAIL_CIVC_VK } from '../verifier/bb_verifier.js';
 import { writeToOutputDirectory } from './client_ivc_proof_utils.js';
 
 const logger = createLogger('bb-prover');
@@ -410,13 +411,14 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       outputWitnessFile,
     );
 
-    const artifact = ServerCircuitArtifacts[circuitType];
+    const artifact = getServerCircuitArtifact(circuitType);
 
     logger.debug(`Generating witness data for ${circuitType}`);
 
     const inputWitness = convertInput(input);
     const timer = new Timer();
-    const outputWitness = await simulator.executeProtocolCircuit(inputWitness, artifact);
+    const foreignCallHandler = undefined; // We don't handle foreign calls in the native ACVM simulator
+    const outputWitness = await simulator.executeProtocolCircuit(inputWitness, artifact, foreignCallHandler);
     const output = convertOutput(outputWitness);
 
     const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
@@ -520,12 +522,18 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     hasher.update(input.toBuffer());
 
     await writeToOutputDirectory(input.clientIVCData, bbWorkingDirectory);
-    const provingResult = await generateTubeProof(this.config.bbBinaryPath, bbWorkingDirectory, logger.verbose);
+    const provingResult = await generateTubeProof(
+      this.config.bbBinaryPath,
+      bbWorkingDirectory,
+      input.usePublicTailVk ? PUBLIC_TAIL_CIVC_VK : PRIVATE_TAIL_CIVC_VK,
+      logger.verbose,
+    );
 
     if (provingResult.status === BB_RESULT.FAILURE) {
       logger.error(`Failed to generate proof for tube circuit: ${provingResult.reason}`);
       throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
     }
+
     return provingResult;
   }
 
@@ -740,10 +748,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     assert(json.length - numPublicInputs == proofLength, 'Proof length mismatch');
 
-    const fieldsWithoutPublicInputs = json
-      .slice(0, 3)
-      .map(Fr.fromHexString)
-      .concat(json.slice(3 + numPublicInputs).map(Fr.fromHexString));
+    const fieldsWithoutPublicInputs = json.slice(numPublicInputs).map(Fr.fromHexString);
     logger.debug(
       `Circuit path: ${filePath}, complete proof length: ${json.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`,
     );

package/src/prover/client_ivc_proof_utils.ts

@@ -3,40 +3,26 @@ import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import { promises as fs } from 'fs';
 import { join } from 'path';
 
-export const CLIENT_IVC_VK_FILE_NAME = 'vk';
 export const CLIENT_IVC_PROOF_FILE_NAME = 'proof';
 
 /**
- * TODO(#7371): eventually remove client_ivc_prove_output_all_msgpack and properly handle these accumulators and VKs
- * Create a ClientIvcProof from the result of client_ivc_prove_output_all or client_ivc_prove_output_all_msgpack
- * @param directory the directory of results
+ * Create a ClientIvcProof proof file.
+ *
+ * @param directory the directory to read the proof from.
  * @returns the encapsulated client ivc proof
  */
 export async function readFromOutputDirectory(directory: string) {
-  const [clientIvcVkBuffer, clientIvcProofBuffer] = await Promise.all(
-    [CLIENT_IVC_VK_FILE_NAME, CLIENT_IVC_PROOF_FILE_NAME].map(fileName => fs.readFile(join(directory, fileName))),
-  );
-  return new ClientIvcProof(clientIvcProofBuffer, clientIvcVkBuffer);
+  const clientIvcProofBuffer = await fs.readFile(join(directory, CLIENT_IVC_PROOF_FILE_NAME));
+  return new ClientIvcProof(clientIvcProofBuffer);
 }
 
 /**
- * TODO(#7371): eventually remove client_ivc_prove_output_all_msgpack and properly handle these accumulators and VKs
- * Serialize a ClientIvcProof to the files expected by prove_tube
+ * Serialize a ClientIvcProof to a proof file.
  *
- * Example usage:
- *  await runInDirectory(bbWorkingDirectory, async (dir: string) => {
- *    await privateTx.clientIvcProof!.writeToOutputDirectory(bbWorkingDirectory);
- *    const result = await generateTubeProof(bbPath, dir, logger.info)
- *    expect(result.status).toBe(BB_RESULT.SUCCESS)
- *  });
- * @param proof the ClientIvcProof from readFromOutputDirectory
- * @param directory the directory of results
+ * @param proof the ClientIvcProof from object
+ * @param directory the directory to write in
  */
 export async function writeToOutputDirectory(clientIvcProof: ClientIvcProof, directory: string) {
-  const { clientIvcProofBuffer, clientIvcVkBuffer } = clientIvcProof;
-  const fileData = [
-    [CLIENT_IVC_PROOF_FILE_NAME, clientIvcProofBuffer],
-    [CLIENT_IVC_VK_FILE_NAME, clientIvcVkBuffer],
-  ] as const;
-  await Promise.all(fileData.map(([fileName, buffer]) => fs.writeFile(join(directory, fileName), buffer)));
+  const { clientIvcProofBuffer } = clientIvcProof;
+  await fs.writeFile(join(directory, CLIENT_IVC_PROOF_FILE_NAME), clientIvcProofBuffer);
 }

package/src/test/test_circuit_prover.ts

@@ -11,7 +11,6 @@ import { sleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
 import {
   type ServerProtocolArtifact,
-  SimulatedServerCircuitArtifacts,
   convertBaseParityInputsToWitnessMap,
   convertBaseParityOutputsFromWitnessMap,
   convertBlockMergeRollupInputsToWitnessMap,
@@ -32,6 +31,8 @@ import {
   convertSimulatedPublicBaseRollupOutputsFromWitnessMap,
   convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap,
   convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap,
+  foreignCallHandler,
+  getSimulatedServerCircuitArtifact,
 } from '@aztec/noir-protocol-circuits-types/server';
 import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
 import type { WitnessMap } from '@aztec/noir-types';
@@ -347,16 +348,26 @@ export class TestCircuitProver implements ServerCircuitProver {
     const witnessMap = convertInput(input);
     const circuitName = mapProtocolArtifactNameToCircuitName(artifactName);
 
-    let simulationProvider = this.simulationProvider ?? this.wasmSimulator;
-    if (['BlockRootRollupArtifact', 'SingleTxBlockRootRollupArtifact'].includes(artifactName)) {
-      // TODO(#10323): temporarily force block root to use wasm while we simulate
-      // the blob operations with an oracle. Appears to be no way to provide nativeACVM with a foreign call hander.
-      simulationProvider = this.wasmSimulator;
+    let witness: WitnessMap;
+    if (
+      ['BlockRootRollupArtifact', 'SingleTxBlockRootRollupArtifact'].includes(artifactName) ||
+      this.simulationProvider == undefined
+    ) {
+      // TODO(#10323): Native ACVM simulator does not support foreign call handler so we use the wasm simulator
+      // when simulating block root rollup and single tx block root rollup circuits or when the native ACVM simulator
+      // is not provided.
+      witness = await this.wasmSimulator.executeProtocolCircuit(
+        witnessMap,
+        getSimulatedServerCircuitArtifact(artifactName),
+        foreignCallHandler,
+      );
+    } else {
+      witness = await this.simulationProvider.executeProtocolCircuit(
+        witnessMap,
+        getSimulatedServerCircuitArtifact(artifactName),
+        undefined, // Native ACM simulator does not support foreign call handler
+      );
     }
-    const witness = await simulationProvider.executeProtocolCircuit(
-      witnessMap,
-      SimulatedServerCircuitArtifacts[artifactName],
-    );
 
     const result = convertOutput(witness);