@aztec/bb-prover 0.40.1 → 0.42.0

package/src/bb/execute.ts

@@ -1,3 +1,4 @@
+import { type AvmCircuitInputs } from '@aztec/circuits.js';
 import { sha256 } from '@aztec/foundation/crypto';
 import { type LogFn } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -5,6 +6,7 @@ import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import * as proc from 'child_process';
 import * as fs from 'fs/promises';
+import { basename, dirname, join } from 'path';
 
 export const VK_FILENAME = 'vk';
 export const VK_FIELDS_FILENAME = 'vk_fields.json';
@@ -20,9 +22,14 @@ export enum BB_RESULT {
 export type BBSuccess = {
   status: BB_RESULT.SUCCESS | BB_RESULT.ALREADY_PRESENT;
   duration: number;
+  /** Full path of the public key. */
   pkPath?: string;
+  /** Base directory for the VKs (raw, fields). */
   vkPath?: string;
+  /** Full path of the proof. */
   proofPath?: string;
+  /** Full path of the contract. */
+  contractPath?: string;
 };
 
 export type BBFailure = {
@@ -32,6 +39,14 @@ export type BBFailure = {
 
 export type BBResult = BBSuccess | BBFailure;
 
+export type VerificationFunction = typeof verifyProof | typeof verifyAvmProof;
+
+type BBExecResult = {
+  status: BB_RESULT;
+  exitCode: number;
+  signal: string | undefined;
+};
+
 /**
  * Invokes the Barretenberg binary with the provided command and args
  * @param pathToBB - The path to the BB binary
@@ -47,10 +62,15 @@ export function executeBB(
   args: string[],
   logger: LogFn,
   resultParser = (code: number) => code === 0,
-) {
-  return new Promise<BB_RESULT.SUCCESS | BB_RESULT.FAILURE>((resolve, reject) => {
+): Promise<BBExecResult> {
+  return new Promise<BBExecResult>(resolve => {
     // spawn the bb process
-    const bb = proc.spawn(pathToBB, [command, ...args]);
+    const { HARDWARE_CONCURRENCY: _, ...envWithoutConcurrency } = process.env;
+    const env = process.env.HARDWARE_CONCURRENCY ? process.env : envWithoutConcurrency;
+    logger(`Executing BB with: ${command} ${args.join(' ')}`);
+    const bb = proc.spawn(pathToBB, [command, ...args], {
+      env,
+    });
     bb.stdout.on('data', data => {
       const message = data.toString('utf-8').replace(/\n$/, '');
       logger(message);
@@ -59,17 +79,16 @@ export function executeBB(
       const message = data.toString('utf-8').replace(/\n$/, '');
       logger(message);
     });
-    bb.on('close', (code: number) => {
-      if (resultParser(code)) {
-        resolve(BB_RESULT.SUCCESS);
+    bb.on('close', (exitCode: number, signal?: string) => {
+      if (resultParser(exitCode)) {
+        resolve({ status: BB_RESULT.SUCCESS, exitCode, signal });
       } else {
-        reject();
+        resolve({ status: BB_RESULT.FAILURE, exitCode, signal });
       }
     });
-  }).catch(_ => BB_RESULT.FAILURE);
+  }).catch(_ => ({ status: BB_RESULT.FAILURE, exitCode: -1, signal: undefined }));
 }
 
-const bytecodeHashFilename = 'bytecode_hash';
 const bytecodeFilename = 'bytecode';
 
 /**
@@ -101,82 +120,67 @@ export async function generateKeyForNoirCircuit(
   // 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}/${key}/${circuitName}`;
-  const bytecodeHashPath = `${circuitOutputDirectory}/${bytecodeHashFilename}`;
-  const bytecodePath = `${circuitOutputDirectory}/${bytecodeFilename}`;
-  const bytecodeHash = sha256(bytecode);
-
   const outputPath = `${circuitOutputDirectory}`;
+  const bytecodeHash = sha256(bytecode);
 
   // ensure the directory exists
   await fs.mkdir(circuitOutputDirectory, { recursive: true });
 
-  // Generate the key if we have been told to, or there is no bytecode hash
-  let mustRegenerate =
-    force ||
-    (await fs
-      .access(bytecodeHashPath, fs.constants.R_OK)
-      .then(_ => false)
-      .catch(_ => true));
-
-  if (!mustRegenerate) {
-    // Check to see if the bytecode hash has changed from the stored value
-    const data: Buffer = await fs.readFile(bytecodeHashPath).catch(_ => Buffer.alloc(0));
-    mustRegenerate = data.length == 0 || !data.equals(bytecodeHash);
-  }
+  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);
 
-  if (!mustRegenerate) {
-    // No need to generate, early out
+      // args are the output path and the input bytecode path
+      const args = ['-o', `${outputPath}/${VK_FILENAME}`, '-b', bytecodePath];
+      const timer = new Timer();
+      let result = await executeBB(pathToBB, `write_${key}`, 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 && key === 'vk') {
+        const asFieldsArgs = ['-k', `${outputPath}/${VK_FILENAME}`, '-o', `${outputPath}/${VK_FIELDS_FILENAME}`, '-v'];
+        result = await executeBB(pathToBB, `vk_as_fields`, asFieldsArgs, log);
+      }
+      const duration = timer.ms();
+
+      if (result.status == BB_RESULT.SUCCESS) {
+        return {
+          status: BB_RESULT.SUCCESS,
+          duration,
+          pkPath: key === 'pk' ? outputPath : undefined,
+          vkPath: key === 'vk' ? outputPath : undefined,
+          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}.`,
+      };
+    } catch (error) {
+      return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+  });
+
+  if (!res) {
     return {
       status: BB_RESULT.ALREADY_PRESENT,
       duration: 0,
       pkPath: key === 'pk' ? outputPath : undefined,
       vkPath: key === 'vk' ? outputPath : undefined,
-      proofPath: undefined,
     };
   }
 
-  // Check we have access to bb
-  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 {
-    // 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, '-b', bytecodePath];
-    const timer = new Timer();
-    let result = await executeBB(pathToBB, `write_${key}`, args, log);
-    // If we succeeded and the type of key if verification, have bb write the 'fields' version too
-    if (result == BB_RESULT.SUCCESS && key === 'vk') {
-      const asFieldsArgs = ['-k', `${outputPath}/${VK_FILENAME}`, '-o', `${outputPath}/${VK_FIELDS_FILENAME}`, '-v'];
-      result = await executeBB(pathToBB, `vk_as_fields`, asFieldsArgs, log);
-    }
-    const duration = timer.ms();
-    // Cleanup the bytecode file
-    await fs.rm(bytecodePath, { force: true });
-    if (result == BB_RESULT.SUCCESS) {
-      // Store the bytecode hash so we don't need to regenerate at a later time
-      await fs.writeFile(bytecodeHashPath, bytecodeHash);
-      return {
-        status: BB_RESULT.SUCCESS,
-        duration,
-        pkPath: key === 'pk' ? outputPath : undefined,
-        vkPath: key === 'vk' ? outputPath : undefined,
-        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` };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
-  }
+  return res;
 }
 
 /**
@@ -229,9 +233,8 @@ export async function generateProof(
     };
     const result = await executeBB(pathToBB, 'prove_output_all', args, logFunction);
     const duration = timer.ms();
-    // cleanup the bytecode
-    await fs.rm(bytecodePath, { force: true });
-    if (result == BB_RESULT.SUCCESS) {
+
+    if (result.status == BB_RESULT.SUCCESS) {
       return {
         status: BB_RESULT.SUCCESS,
         duration,
@@ -241,7 +244,119 @@ export async function generateProof(
       };
     }
     // 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 proof` };
+    return {
+      status: BB_RESULT.FAILURE,
+      reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+    };
+  } catch (error) {
+    return { status: BB_RESULT.FAILURE, reason: `${error}` };
+  }
+}
+
+/**
+ * Used for generating AVM proofs.
+ * 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 bytecode - The AVM bytecode for the public function to be proven (expected to be decompressed)
+ * @param log - A logging function
+ * @returns An object containing a result indication, the location of the proof and the duration taken
+ */
+export async function generateAvmProof(
+  pathToBB: string,
+  workingDirectory: string,
+  input: AvmCircuitInputs,
+  log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  // Check that the working directory exists
+  try {
+    await fs.access(workingDirectory);
+  } catch (error) {
+    return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
+  }
+
+  // Paths for the inputs
+  const bytecodePath = join(workingDirectory, 'avm_bytecode.bin');
+  const calldataPath = join(workingDirectory, 'avm_calldata.bin');
+  const publicInputsPath = join(workingDirectory, 'avm_public_inputs.bin');
+  const avmHintsPath = join(workingDirectory, 'avm_hints.bin');
+
+  // The proof is written to e.g. /workingDirectory/proof
+  const outputPath = workingDirectory;
+
+  const filePresent = async (file: string) =>
+    await fs
+      .access(file, fs.constants.R_OK)
+      .then(_ => true)
+      .catch(_ => false);
+
+  const binaryPresent = await filePresent(pathToBB);
+  if (!binaryPresent) {
+    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
+  }
+
+  try {
+    // Write the inputs to the working directory.
+    await fs.writeFile(bytecodePath, input.bytecode);
+    if (!filePresent(bytecodePath)) {
+      return { status: BB_RESULT.FAILURE, reason: `Could not write bytecode at ${bytecodePath}` };
+    }
+    await fs.writeFile(
+      calldataPath,
+      input.calldata.map(fr => fr.toBuffer()),
+    );
+    if (!filePresent(calldataPath)) {
+      return { status: BB_RESULT.FAILURE, reason: `Could not write calldata at ${calldataPath}` };
+    }
+
+    // public inputs are used directly as a vector of fields in C++,
+    // so we serialize them as such here instead of just using toBuffer
+    await fs.writeFile(
+      publicInputsPath,
+      input.publicInputs.toFields().map(fr => fr.toBuffer()),
+    );
+    if (!filePresent(publicInputsPath)) {
+      return { status: BB_RESULT.FAILURE, reason: `Could not write publicInputs at ${publicInputsPath}` };
+    }
+
+    await fs.writeFile(avmHintsPath, input.avmHints.toBuffer());
+    if (!filePresent(avmHintsPath)) {
+      return { status: BB_RESULT.FAILURE, reason: `Could not write avmHints at ${avmHintsPath}` };
+    }
+
+    const args = [
+      '--avm-bytecode',
+      bytecodePath,
+      '--avm-calldata',
+      calldataPath,
+      '--avm-public-inputs',
+      publicInputsPath,
+      '--avm-hints',
+      avmHintsPath,
+      '-o',
+      outputPath,
+    ];
+    const timer = new Timer();
+    const logFunction = (message: string) => {
+      log(`AvmCircuit (prove) BB out - ${message}`);
+    };
+    const result = await executeBB(pathToBB, 'avm_prove', args, logFunction);
+    const duration = timer.ms();
+
+    if (result.status == BB_RESULT.SUCCESS) {
+      return {
+        status: BB_RESULT.SUCCESS,
+        duration,
+        proofPath: join(outputPath, PROOF_FILENAME),
+        pkPath: undefined,
+        vkPath: outputPath,
+      };
+    }
+    // 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 proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+    };
   } catch (error) {
     return { status: BB_RESULT.FAILURE, reason: `${error}` };
   }
@@ -260,6 +375,42 @@ export async function verifyProof(
   proofFullPath: string,
   verificationKeyPath: string,
   log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'verify', log);
+}
+
+/**
+ * Used for verifying proofs of the AVM
+ * @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
+ * @returns An object containing a result indication and duration taken
+ */
+export async function verifyAvmProof(
+  pathToBB: string,
+  proofFullPath: string,
+  verificationKeyPath: string,
+  log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', log);
+}
+
+/**
+ * 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
+ * @returns An object containing a result indication and duration taken
+ */
+async function verifyProofInternal(
+  pathToBB: string,
+  proofFullPath: string,
+  verificationKeyPath: string,
+  command: 'verify' | 'avm_verify',
+  log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
     .access(pathToBB, fs.constants.R_OK)
@@ -272,13 +423,16 @@ export async function verifyProof(
   try {
     const args = ['-p', proofFullPath, '-k', verificationKeyPath];
     const timer = new Timer();
-    const result = await executeBB(pathToBB, 'verify', args, log);
+    const result = await executeBB(pathToBB, command, args, log);
     const duration = timer.ms();
-    if (result == BB_RESULT.SUCCESS) {
+    if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, 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` };
+    return {
+      status: BB_RESULT.FAILURE,
+      reason: `Failed to verify proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+    };
   } catch (error) {
     return { status: BB_RESULT.FAILURE, reason: `${error}` };
   }
@@ -311,11 +465,14 @@ export async function writeVkAsFields(
     const timer = new Timer();
     const result = await executeBB(pathToBB, 'vk_as_fields', args, log);
     const duration = timer.ms();
-    if (result == BB_RESULT.SUCCESS) {
+    if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, duration, vkPath: verificationKeyPath };
     }
     // Not a great error message here but it is difficult to decipher what comes from bb
-    return { status: BB_RESULT.FAILURE, reason: `Failed to create vk as fields` };
+    return {
+      status: BB_RESULT.FAILURE,
+      reason: `Failed to create vk as fields. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+    };
   } catch (error) {
     return { status: BB_RESULT.FAILURE, reason: `${error}` };
   }
@@ -326,6 +483,7 @@ export async function writeVkAsFields(
  * @param pathToBB - The full path to the bb binary
  * @param proofPath - The directory containing the binary proof
  * @param proofFileName - The filename of the proof
+ * @param vkFileName - The filename of the verification key
  * @param log - A logging function
  * @returns An object containing a result indication and duration taken
  */
@@ -333,6 +491,7 @@ export async function writeProofAsFields(
   pathToBB: string,
   proofPath: string,
   proofFileName: string,
+  vkFilePath: string,
   log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
@@ -344,16 +503,145 @@ export async function writeProofAsFields(
   }
 
   try {
-    const args = ['-p', `${proofPath}/${proofFileName}`, '-v'];
+    const args = ['-p', `${proofPath}/${proofFileName}`, '-k', vkFilePath, '-v'];
     const timer = new Timer();
     const result = await executeBB(pathToBB, 'proof_as_fields', args, log);
     const duration = timer.ms();
-    if (result == BB_RESULT.SUCCESS) {
+    if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, duration, proofPath: proofPath };
     }
     // Not a great error message here but it is difficult to decipher what comes from bb
-    return { status: BB_RESULT.FAILURE, reason: `Failed to create proof as fields` };
+    return {
+      status: BB_RESULT.FAILURE,
+      reason: `Failed to create proof as fields. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+    };
   } catch (error) {
     return { status: BB_RESULT.FAILURE, reason: `${error}` };
   }
 }
+
+export async function generateContractForVerificationKey(
+  pathToBB: string,
+  vkFilePath: string,
+  contractPath: string,
+  log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  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}` };
+  }
+
+  const outputDir = dirname(contractPath);
+  const contractName = basename(contractPath);
+  // cache contract generation based on vk file and contract name
+  const cacheKey = sha256(Buffer.concat([Buffer.from(contractName), await fs.readFile(vkFilePath)]));
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const res = await fsCache<BBSuccess | BBFailure>(outputDir, cacheKey, log, false, async () => {
+    try {
+      const args = ['-k', vkFilePath, '-o', contractPath, '-v'];
+      const timer = new Timer();
+      const result = await executeBB(pathToBB, 'contract', args, log);
+      const duration = timer.ms();
+      if (result.status == BB_RESULT.SUCCESS) {
+        return { status: BB_RESULT.SUCCESS, duration, contractPath };
+      }
+      // Not a great error message here but it is difficult to decipher what comes from bb
+      return {
+        status: BB_RESULT.FAILURE,
+        reason: `Failed to write verifier contract. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+      };
+    } catch (error) {
+      return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+  });
+
+  if (!res) {
+    return {
+      status: BB_RESULT.ALREADY_PRESENT,
+      duration: 0,
+      contractPath,
+    };
+  }
+
+  return res;
+}
+
+export async function generateContractForCircuit(
+  pathToBB: string,
+  workingDirectory: string,
+  circuitName: string,
+  compiledCircuit: NoirCompiledCircuit,
+  contractName: string,
+  log: LogFn,
+  force = false,
+) {
+  const vkResult = await generateKeyForNoirCircuit(
+    pathToBB,
+    workingDirectory,
+    circuitName,
+    compiledCircuit,
+    'vk',
+    log,
+    force,
+  );
+  if (vkResult.status === BB_RESULT.FAILURE) {
+    return vkResult;
+  }
+
+  return generateContractForVerificationKey(
+    pathToBB,
+    join(vkResult.vkPath!, VK_FILENAME),
+    join(workingDirectory, 'contract', circuitName, contractName),
+    log,
+  );
+}
+
+const CACHE_FILENAME = '.cache';
+async function fsCache<T>(
+  dir: string,
+  expectedCacheKey: Buffer,
+  logger: LogFn,
+  force: boolean,
+  action: () => Promise<T>,
+): Promise<T | undefined> {
+  const cacheFilePath = join(dir, CACHE_FILENAME);
+
+  let run: boolean;
+  if (force) {
+    run = true;
+  } else {
+    try {
+      run = !expectedCacheKey.equals(await fs.readFile(cacheFilePath));
+    } catch (err: any) {
+      if (err && 'code' in err && err.code === 'ENOENT') {
+        // cache file doesn't exist, swallow error and run
+        run = true;
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  let res: T | undefined;
+  if (run) {
+    logger(`Cache miss or forced run. Running operation in ${dir}...`);
+    res = await action();
+  } else {
+    logger(`Cache hit. Skipping operation in ${dir}...`);
+  }
+
+  try {
+    await fs.writeFile(cacheFilePath, expectedCacheKey);
+  } catch (err) {
+    logger(`Couldn't write cache data to ${cacheFilePath}. Skipping cache...`);
+    // ignore
+  }
+
+  return res;
+}

package/src/config.ts

@@ -0,0 +1,9 @@
+export interface BBConfig {
+  bbBinaryPath: string;
+  bbWorkingDirectory: string;
+}
+
+export interface ACVMConfig {
+  acvmBinaryPath: string;
+  acvmWorkingDirectory: string;
+}

package/src/index.ts

@@ -1,2 +1,4 @@
 export * from './prover/index.js';
 export * from './test/index.js';
+export * from './verifier/index.js';
+export * from './config.js';

package/src/mappings/mappings.ts

@@ -2,12 +2,18 @@ import { PublicKernelType } from '@aztec/circuit-types';
 import { type PublicKernelCircuitPrivateInputs, type PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
 import {
   type ServerProtocolArtifact,
-  convertPublicInnerRollupInputsToWitnessMap,
-  convertPublicInnerRollupOutputFromWitnessMap,
-  convertPublicSetupRollupInputsToWitnessMap,
-  convertPublicSetupRollupOutputFromWitnessMap,
-  convertPublicTeardownRollupInputsToWitnessMap,
-  convertPublicTeardownRollupOutputFromWitnessMap,
+  convertPublicInnerInputsToWitnessMap,
+  convertPublicInnerOutputFromWitnessMap,
+  convertPublicSetupInputsToWitnessMap,
+  convertPublicSetupOutputFromWitnessMap,
+  convertPublicTeardownInputsToWitnessMap,
+  convertPublicTeardownOutputFromWitnessMap,
+  convertSimulatedPublicInnerInputsToWitnessMap,
+  convertSimulatedPublicInnerOutputFromWitnessMap,
+  convertSimulatedPublicSetupInputsToWitnessMap,
+  convertSimulatedPublicSetupOutputFromWitnessMap,
+  convertSimulatedPublicTeardownInputsToWitnessMap,
+  convertSimulatedPublicTeardownOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 
 import { type WitnessMap } from '@noir-lang/types';
@@ -20,22 +26,42 @@ export type PublicKernelProvingOps = {
 
 export type KernelTypeToArtifact = Record<PublicKernelType, PublicKernelProvingOps | undefined>;
 
+export const SimulatedPublicKernelArtifactMapping: KernelTypeToArtifact = {
+  [PublicKernelType.NON_PUBLIC]: undefined,
+  [PublicKernelType.APP_LOGIC]: {
+    artifact: 'PublicKernelAppLogicArtifact',
+    convertInputs: convertSimulatedPublicInnerInputsToWitnessMap,
+    convertOutputs: convertSimulatedPublicInnerOutputFromWitnessMap,
+  },
+  [PublicKernelType.SETUP]: {
+    artifact: 'PublicKernelSetupArtifact',
+    convertInputs: convertSimulatedPublicSetupInputsToWitnessMap,
+    convertOutputs: convertSimulatedPublicSetupOutputFromWitnessMap,
+  },
+  [PublicKernelType.TEARDOWN]: {
+    artifact: 'PublicKernelTeardownArtifact',
+    convertInputs: convertSimulatedPublicTeardownInputsToWitnessMap,
+    convertOutputs: convertSimulatedPublicTeardownOutputFromWitnessMap,
+  },
+  [PublicKernelType.TAIL]: undefined,
+};
+
 export const PublicKernelArtifactMapping: KernelTypeToArtifact = {
   [PublicKernelType.NON_PUBLIC]: undefined,
   [PublicKernelType.APP_LOGIC]: {
     artifact: 'PublicKernelAppLogicArtifact',
-    convertInputs: convertPublicInnerRollupInputsToWitnessMap,
-    convertOutputs: convertPublicInnerRollupOutputFromWitnessMap,
+    convertInputs: convertPublicInnerInputsToWitnessMap,
+    convertOutputs: convertPublicInnerOutputFromWitnessMap,
   },
   [PublicKernelType.SETUP]: {
     artifact: 'PublicKernelSetupArtifact',
-    convertInputs: convertPublicSetupRollupInputsToWitnessMap,
-    convertOutputs: convertPublicSetupRollupOutputFromWitnessMap,
+    convertInputs: convertPublicSetupInputsToWitnessMap,
+    convertOutputs: convertPublicSetupOutputFromWitnessMap,
   },
   [PublicKernelType.TEARDOWN]: {
     artifact: 'PublicKernelTeardownArtifact',
-    convertInputs: convertPublicTeardownRollupInputsToWitnessMap,
-    convertOutputs: convertPublicTeardownRollupOutputFromWitnessMap,
+    convertInputs: convertPublicTeardownInputsToWitnessMap,
+    convertOutputs: convertPublicTeardownOutputFromWitnessMap,
   },
   [PublicKernelType.TAIL]: undefined,
 };