@aztec/bb-prover 0.41.0 → 0.43.0

package/dest/bb/execute.js

@@ -2,6 +2,7 @@ import { sha256 } from '@aztec/foundation/crypto';
 import { Timer } from '@aztec/foundation/timer';
 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';
 export const PROOF_FILENAME = 'proof';
@@ -24,8 +25,19 @@ export var BB_RESULT;
 export function executeBB(pathToBB, command, args, logger, resultParser = (code) => code === 0) {
     return new Promise(resolve => {
         // spawn the bb process
+        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], {
-            stdio: 'pipe',
+            env,
+        });
+        bb.stdout.on('data', data => {
+            const message = data.toString('utf-8').replace(/\n$/, '');
+            logger(message);
+        });
+        bb.stderr.on('data', data => {
+            const message = data.toString('utf-8').replace(/\n$/, '');
+            logger(message);
         });
         bb.on('close', (exitCode, signal) => {
             if (resultParser(exitCode)) {
@@ -37,7 +49,6 @@ export function executeBB(pathToBB, command, args, logger, resultParser = (code)
         });
     }).catch(_ => ({ status: BB_RESULT.FAILURE, exitCode: -1, signal: undefined }));
 }
-const bytecodeHashFilename = 'bytecode_hash';
 const bytecodeFilename = 'bytecode';
 /**
  * Used for generating either a proving or verification key, will exit early if the key already exists
@@ -59,34 +70,85 @@ export async function generateKeyForNoirCircuit(pathToBB, workingDirectory, circ
     // 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 = await fs.readFile(bytecodeHashPath).catch(_ => Buffer.alloc(0));
-        mustRegenerate = data.length == 0 || !data.equals(bytecodeHash);
-    }
-    if (!mustRegenerate) {
-        // No need to generate, early out
+    const res = await fsCache(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];
+            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
+    return res;
+}
+/**
+ * Used for generating proofs of noir circuits.
+ * 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 generateProof(pathToBB, workingDirectory, circuitName, bytecode, inputWitnessFile, log) {
+    // 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` };
+    }
+    // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
+    const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
+    // The proof is written to e.g. /workingDirectory/proof
+    const outputPath = `${workingDirectory}`;
     const binaryPresent = await fs
         .access(pathToBB, fs.constants.R_OK)
         .then(_ => true)
@@ -94,37 +156,29 @@ export async function generateKeyForNoirCircuit(pathToBB, workingDirectory, circ
     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 args = ['-o', outputPath, '-b', bytecodePath, '-w', inputWitnessFile, '-v'];
         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 logFunction = (message) => {
+            log(`${circuitName} BB out - ${message}`);
+        };
+        const result = await executeBB(pathToBB, 'prove_output_all', args, logFunction);
         const duration = timer.ms();
-        // Cleanup the bytecode file
-        await fs.rm(bytecodePath, { force: true });
         if (result.status == 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,
+                proofPath: `${outputPath}`,
+                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 key. Exit code: ${result.exitCode}. Signal ${result.signal}.`,
+            reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
         };
     }
     catch (error) {
@@ -132,17 +186,15 @@ export async function generateKeyForNoirCircuit(pathToBB, workingDirectory, circ
     }
 }
 /**
- * Used for generating proofs of noir circuits.
+ * 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 circuitName - An identifier for the circuit
- * @param bytecode - The compiled circuit bytecode
- * @param inputWitnessFile - The circuit input witness
+ * @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 generateProof(pathToBB, workingDirectory, circuitName, bytecode, inputWitnessFile, log) {
+export async function generateAvmProof(pathToBB, workingDirectory, input, log) {
     // Check that the working directory exists
     try {
         await fs.access(workingDirectory);
@@ -150,36 +202,66 @@ export async function generateProof(pathToBB, workingDirectory, circuitName, byt
     catch (error) {
         return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
     }
-    // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
-    const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
+    // 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 binaryPresent = await fs
-        .access(pathToBB, fs.constants.R_OK)
+    const outputPath = workingDirectory;
+    const filePresent = async (file) => 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 bytecode to the working directory
-        await fs.writeFile(bytecodePath, bytecode);
-        const args = ['-o', outputPath, '-b', bytecodePath, '-w', inputWitnessFile, '-v'];
+        // 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) => {
-            log(`${circuitName} BB out - ${message}`);
+            log(`AvmCircuit (prove) BB out - ${message}`);
         };
-        const result = await executeBB(pathToBB, 'prove_output_all', args, logFunction);
+        const result = await executeBB(pathToBB, 'avm_prove', args, logFunction);
         const duration = timer.ms();
-        // cleanup the bytecode
-        await fs.rm(bytecodePath, { force: true });
         if (result.status == BB_RESULT.SUCCESS) {
             return {
                 status: BB_RESULT.SUCCESS,
                 duration,
-                proofPath: `${outputPath}`,
+                proofPath: join(outputPath, PROOF_FILENAME),
                 pkPath: undefined,
-                vkPath: `${outputPath}`,
+                vkPath: outputPath,
             };
         }
         // Not a great error message here but it is difficult to decipher what comes from bb
@@ -201,6 +283,29 @@ export async function generateProof(pathToBB, workingDirectory, circuitName, byt
  * @returns An object containing a result indication and duration taken
  */
 export async function verifyProof(pathToBB, proofFullPath, verificationKeyPath, log) {
+    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, proofFullPath, verificationKeyPath, log) {
+    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, proofFullPath, verificationKeyPath, command, log) {
     const binaryPresent = await fs
         .access(pathToBB, fs.constants.R_OK)
         .then(_ => true)
@@ -211,7 +316,7 @@ export async function verifyProof(pathToBB, proofFullPath, verificationKeyPath,
     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.status == BB_RESULT.SUCCESS) {
             return { status: BB_RESULT.SUCCESS, duration };
@@ -265,10 +370,11 @@ export async function writeVkAsFields(pathToBB, verificationKeyPath, verificatio
  * @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
  */
-export async function writeProofAsFields(pathToBB, proofPath, proofFileName, log) {
+export async function writeProofAsFields(pathToBB, proofPath, proofFileName, vkFilePath, log) {
     const binaryPresent = await fs
         .access(pathToBB, fs.constants.R_OK)
         .then(_ => true)
@@ -277,7 +383,7 @@ export async function writeProofAsFields(pathToBB, proofPath, proofFileName, log
         return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
     }
     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();
@@ -294,4 +400,90 @@ export async function writeProofAsFields(pathToBB, proofPath, proofFileName, log
         return { status: BB_RESULT.FAILURE, reason: `${error}` };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"execute.js","sourceRoot":"","sources":["../../src/bb/execute.ts"],"names":[],"mappings":"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"}
+export async function generateContractForVerificationKey(pathToBB, vkFilePath, contractPath, log) {
+    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(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, workingDirectory, circuitName, compiledCircuit, contractName, log, 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(dir, expectedCacheKey, logger, force, action) {
+    const cacheFilePath = join(dir, CACHE_FILENAME);
+    let run;
+    if (force) {
+        run = true;
+    }
+    else {
+        try {
+            run = !expectedCacheKey.equals(await fs.readFile(cacheFilePath));
+        }
+        catch (err) {
+            if (err && 'code' in err && err.code === 'ENOENT') {
+                // cache file doesn't exist, swallow error and run
+                run = true;
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    let res;
+    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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"execute.js","sourceRoot":"","sources":["../../src/bb/execute.ts"],"names":[],"mappings":"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"}

package/dest/config.d.ts

@@ -0,0 +1,9 @@
+export interface BBConfig {
+    bbBinaryPath: string;
+    bbWorkingDirectory: string;
+}
+export interface ACVMConfig {
+    acvmBinaryPath: string;
+    acvmWorkingDirectory: string;
+}
+//# sourceMappingURL=config.d.ts.map

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;CAC9B"}

package/dest/config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/index.d.ts

@@ -1,3 +1,5 @@
 export * from './prover/index.js';
 export * from './test/index.js';
+export * from './verifier/index.js';
+export * from './config.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC"}

package/dest/index.js

@@ -1,3 +1,5 @@
 export * from './prover/index.js';
 export * from './test/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGlCQUFpQixDQUFDIn0=
+export * from './verifier/index.js';
+export * from './config.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxhQUFhLENBQUMifQ==

package/dest/mappings/mappings.d.ts

@@ -8,5 +8,6 @@ export type PublicKernelProvingOps = {
     convertOutputs: (outputs: WitnessMap) => PublicKernelCircuitPublicInputs;
 };
 export type KernelTypeToArtifact = Record<PublicKernelType, PublicKernelProvingOps | undefined>;
+export declare const SimulatedPublicKernelArtifactMapping: KernelTypeToArtifact;
 export declare const PublicKernelArtifactMapping: KernelTypeToArtifact;
 //# sourceMappingURL=mappings.d.ts.map

package/dest/mappings/mappings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mappings.d.ts","sourceRoot":"","sources":["../../src/mappings/mappings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,KAAK,gCAAgC,EAAE,KAAK,+BAA+B,EAAE,MAAM,oBAAoB,CAAC;AACjH,OAAO,EACL,KAAK,sBAAsB,EAO5B,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,sBAAsB,CAAC;IACjC,aAAa,EAAE,CAAC,MAAM,EAAE,gCAAgC,KAAK,UAAU,CAAC;IACxE,cAAc,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,+BAA+B,CAAC;CAC1E,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,gBAAgB,EAAE,sBAAsB,GAAG,SAAS,CAAC,CAAC;AAEhG,eAAO,MAAM,2BAA2B,EAAE,oBAkBzC,CAAC"}
+{"version":3,"file":"mappings.d.ts","sourceRoot":"","sources":["../../src/mappings/mappings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,KAAK,gCAAgC,EAAE,KAAK,+BAA+B,EAAE,MAAM,oBAAoB,CAAC;AACjH,OAAO,EACL,KAAK,sBAAsB,EAa5B,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,sBAAsB,CAAC;IACjC,aAAa,EAAE,CAAC,MAAM,EAAE,gCAAgC,KAAK,UAAU,CAAC;IACxE,cAAc,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,+BAA+B,CAAC;CAC1E,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,gBAAgB,EAAE,sBAAsB,GAAG,SAAS,CAAC,CAAC;AAEhG,eAAO,MAAM,oCAAoC,EAAE,oBAkBlD,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,oBAkBzC,CAAC"}

package/dest/mappings/mappings.js

@@ -1,22 +1,41 @@
 import { PublicKernelType } from '@aztec/circuit-types';
-import { convertPublicInnerRollupInputsToWitnessMap, convertPublicInnerRollupOutputFromWitnessMap, convertPublicSetupRollupInputsToWitnessMap, convertPublicSetupRollupOutputFromWitnessMap, convertPublicTeardownRollupInputsToWitnessMap, convertPublicTeardownRollupOutputFromWitnessMap, } from '@aztec/noir-protocol-circuits-types';
+import { convertPublicInnerInputsToWitnessMap, convertPublicInnerOutputFromWitnessMap, convertPublicSetupInputsToWitnessMap, convertPublicSetupOutputFromWitnessMap, convertPublicTeardownInputsToWitnessMap, convertPublicTeardownOutputFromWitnessMap, convertSimulatedPublicInnerInputsToWitnessMap, convertSimulatedPublicInnerOutputFromWitnessMap, convertSimulatedPublicSetupInputsToWitnessMap, convertSimulatedPublicSetupOutputFromWitnessMap, convertSimulatedPublicTeardownInputsToWitnessMap, convertSimulatedPublicTeardownOutputFromWitnessMap, } from '@aztec/noir-protocol-circuits-types';
+export const SimulatedPublicKernelArtifactMapping = {
+    [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 = {
     [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,
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcGluZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWFwcGluZ3MvbWFwcGluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFeEQsT0FBTyxFQUVMLDBDQUEwQyxFQUMxQyw0Q0FBNEMsRUFDNUMsMENBQTBDLEVBQzFDLDRDQUE0QyxFQUM1Qyw2Q0FBNkMsRUFDN0MsK0NBQStDLEdBQ2hELE1BQU0scUNBQXFDLENBQUM7QUFZN0MsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQXlCO0lBQy9ELENBQUMsZ0JBQWdCLENBQUMsVUFBVSxDQUFDLEVBQUUsU0FBUztJQUN4QyxDQUFDLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxFQUFFO1FBQzVCLFFBQVEsRUFBRSw4QkFBOEI7UUFDeEMsYUFBYSxFQUFFLDBDQUEwQztRQUN6RCxjQUFjLEVBQUUsNENBQTRDO0tBQzdEO0lBQ0QsQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUN4QixRQUFRLEVBQUUsMkJBQTJCO1FBQ3JDLGFBQWEsRUFBRSwwQ0FBMEM7UUFDekQsY0FBYyxFQUFFLDRDQUE0QztLQUM3RDtJQUNELENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLEVBQUU7UUFDM0IsUUFBUSxFQUFFLDhCQUE4QjtRQUN4QyxhQUFhLEVBQUUsNkNBQTZDO1FBQzVELGNBQWMsRUFBRSwrQ0FBK0M7S0FDaEU7SUFDRCxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxFQUFFLFNBQVM7Q0FDbkMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcGluZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWFwcGluZ3MvbWFwcGluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFeEQsT0FBTyxFQUVMLG9DQUFvQyxFQUNwQyxzQ0FBc0MsRUFDdEMsb0NBQW9DLEVBQ3BDLHNDQUFzQyxFQUN0Qyx1Q0FBdUMsRUFDdkMseUNBQXlDLEVBQ3pDLDZDQUE2QyxFQUM3QywrQ0FBK0MsRUFDL0MsNkNBQTZDLEVBQzdDLCtDQUErQyxFQUMvQyxnREFBZ0QsRUFDaEQsa0RBQWtELEdBQ25ELE1BQU0scUNBQXFDLENBQUM7QUFZN0MsTUFBTSxDQUFDLE1BQU0sb0NBQW9DLEdBQXlCO0lBQ3hFLENBQUMsZ0JBQWdCLENBQUMsVUFBVSxDQUFDLEVBQUUsU0FBUztJQUN4QyxDQUFDLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxFQUFFO1FBQzVCLFFBQVEsRUFBRSw4QkFBOEI7UUFDeEMsYUFBYSxFQUFFLDZDQUE2QztRQUM1RCxjQUFjLEVBQUUsK0NBQStDO0tBQ2hFO0lBQ0QsQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUN4QixRQUFRLEVBQUUsMkJBQTJCO1FBQ3JDLGFBQWEsRUFBRSw2Q0FBNkM7UUFDNUQsY0FBYyxFQUFFLCtDQUErQztLQUNoRTtJQUNELENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLEVBQUU7UUFDM0IsUUFBUSxFQUFFLDhCQUE4QjtRQUN4QyxhQUFhLEVBQUUsZ0RBQWdEO1FBQy9ELGNBQWMsRUFBRSxrREFBa0Q7S0FDbkU7SUFDRCxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxFQUFFLFNBQVM7Q0FDbkMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLDJCQUEyQixHQUF5QjtJQUMvRCxDQUFDLGdCQUFnQixDQUFDLFVBQVUsQ0FBQyxFQUFFLFNBQVM7SUFDeEMsQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFTLENBQUMsRUFBRTtRQUM1QixRQUFRLEVBQUUsOEJBQThCO1FBQ3hDLGFBQWEsRUFBRSxvQ0FBb0M7UUFDbkQsY0FBYyxFQUFFLHNDQUFzQztLQUN2RDtJQUNELENBQUMsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLEVBQUU7UUFDeEIsUUFBUSxFQUFFLDJCQUEyQjtRQUNyQyxhQUFhLEVBQUUsb0NBQW9DO1FBQ25ELGNBQWMsRUFBRSxzQ0FBc0M7S0FDdkQ7SUFDRCxDQUFDLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxFQUFFO1FBQzNCLFFBQVEsRUFBRSw4QkFBOEI7UUFDeEMsYUFBYSxFQUFFLHVDQUF1QztRQUN0RCxjQUFjLEVBQUUseUNBQXlDO0tBQzFEO0lBQ0QsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxTQUFTO0NBQ25DLENBQUMifQ==