@aztec/pxe 0.37.0 → 0.38.0

package/dest/kernel_prover/bb_prover/bb_native_proof_creator.js

@@ -0,0 +1,437 @@
+import { Fr, Proof, makeEmptyProof, } from '@aztec/circuits.js';
+import { siloNoteHash } from '@aztec/circuits.js/hash';
+import { randomBytes, sha256 } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ClientCircuitArtifacts, convertPrivateKernelInitInputsToWitnessMap, convertPrivateKernelInitOutputsFromWitnessMap, convertPrivateKernelInnerInputsToWitnessMap, convertPrivateKernelInnerOutputsFromWitnessMap, convertPrivateKernelTailForPublicOutputsFromWitnessMap, convertPrivateKernelTailOutputsFromWitnessMap, executeTail, executeTailForPublic, } from '@aztec/noir-protocol-circuits-types';
+import { WASMSimulator } from '@aztec/simulator';
+import { serializeWitness } from '@noir-lang/noirc_abi';
+import * as proc from 'child_process';
+import * as fs from 'fs/promises';
+/**
+ * Temporary implementation of ProofCreator using the native bb binary.
+ * Will be replaced by the WASM equivalent once ready
+ */
+const VK_FILENAME = 'vk';
+const VK_FIELDS_FILENAME = 'vk_fields.json';
+const PROOF_FILENAME = 'proof';
+//const PROOF_FIELDS_FILENAME = 'proof_fields.json';
+//const AGGREGATION_OBJECT_SIZE = 16;
+const CIRCUIT_SIZE_INDEX = 3;
+const CIRCUIT_PUBLIC_INPUTS_INDEX = 4;
+const CIRCUIT_RECURSIVE_INDEX = 5;
+var BB_RESULT;
+(function (BB_RESULT) {
+    BB_RESULT[BB_RESULT["SUCCESS"] = 0] = "SUCCESS";
+    BB_RESULT[BB_RESULT["FAILURE"] = 1] = "FAILURE";
+    BB_RESULT[BB_RESULT["ALREADY_PRESENT"] = 2] = "ALREADY_PRESENT";
+})(BB_RESULT || (BB_RESULT = {}));
+/**
+ * Invokes the Barretenberg binary with the provided command and args
+ * @param pathToBB - The path to the BB binary
+ * @param command - The command to execute
+ * @param args - The arguments to pass
+ * @param logger - A log function
+ * @param resultParser - An optional handler for detecting success or failure
+ * @returns The completed partial witness outputted from the circuit
+ */
+function executeBB(pathToBB, command, args, logger, resultParser = (code) => code === 0) {
+    return new Promise((resolve, reject) => {
+        // spawn the bb process
+        const bb = proc.spawn(pathToBB, [command, ...args]);
+        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', (code) => {
+            if (resultParser(code)) {
+                resolve(BB_RESULT.SUCCESS);
+            }
+            else {
+                reject();
+            }
+        });
+    }).catch(_ => BB_RESULT.FAILURE);
+}
+/**
+ * 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)
+        .catch(_ => false);
+    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'];
+        const timer = new Timer();
+        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
+        await fs.rm(bytecodePath, { force: true });
+        if (result == BB_RESULT.SUCCESS) {
+            return {
+                status: BB_RESULT.SUCCESS,
+                duration,
+                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 proof` };
+    }
+    catch (error) {
+        return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+}
+/**
+ * Used for verifying proofs of noir circuits
+ * @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
+ */
+async function verifyProof(pathToBB, proofFullPath, verificationKeyPath, 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}` };
+    }
+    try {
+        const args = ['-p', proofFullPath, '-k', verificationKeyPath];
+        const timer = new Timer();
+        const result = await executeBB(pathToBB, 'verify', args, log);
+        const duration = timer.ms();
+        if (result == 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` };
+    }
+    catch (error) {
+        return { status: BB_RESULT.FAILURE, reason: `${error}` };
+    }
+}
+const bytecodeHashFilename = 'bytecode_hash';
+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, workingDirectory, circuitName, compiledCircuit, key, log, force = false) {
+    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}/${key}/${circuitName}`;
+    const bytecodeHashPath = `${circuitOutputDirectory}/${bytecodeHashFilename}`;
+    const bytecodePath = `${circuitOutputDirectory}/${bytecodeFilename}`;
+    const bytecodeHash = sha256(bytecode);
+    const outputPath = `${circuitOutputDirectory}`;
+    // 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
+        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}` };
+    }
+}
+const KernelArtifactMapping = {
+    PrivateKernelInitArtifact: {
+        convertOutputs: convertPrivateKernelInitOutputsFromWitnessMap,
+    },
+    PrivateKernelInnerArtifact: {
+        convertOutputs: convertPrivateKernelInnerOutputsFromWitnessMap,
+    },
+    PrivateKernelTailArtifact: {
+        convertOutputs: convertPrivateKernelTailOutputsFromWitnessMap,
+    },
+    PrivateKernelTailToPublicArtifact: {
+        convertOutputs: convertPrivateKernelTailForPublicOutputsFromWitnessMap,
+    },
+};
+/**
+ * This proof creator implementation uses the native bb binary.
+ * This is a temporary implementation until we make the WASM version work.
+ */
+export class BBNativeProofCreator {
+    constructor(bbBinaryPath, bbWorkingDirectory, log = createDebugLogger('aztec:bb-native-prover')) {
+        this.bbBinaryPath = bbBinaryPath;
+        this.bbWorkingDirectory = bbWorkingDirectory;
+        this.log = log;
+        this.simulator = new WASMSimulator();
+        this.verificationKeys = new Map();
+    }
+    getSiloedCommitments(publicInputs) {
+        const contractAddress = publicInputs.callContext.storageContractAddress;
+        return Promise.resolve(publicInputs.newNoteHashes.map(commitment => siloNoteHash(contractAddress, commitment.value)));
+    }
+    async createProofInit(inputs) {
+        const witnessMap = convertPrivateKernelInitInputsToWitnessMap(inputs);
+        return await this.createSafeProof(witnessMap, 'PrivateKernelInitArtifact');
+    }
+    async createProofInner(inputs) {
+        const witnessMap = convertPrivateKernelInnerInputsToWitnessMap(inputs);
+        return await this.createSafeProof(witnessMap, 'PrivateKernelInnerArtifact');
+    }
+    async createProofTail(inputs) {
+        // if (!inputs.isForPublic()) {
+        //   const witnessMap = convertPrivateKernelTailInputsToWitnessMap(inputs);
+        //   return await this.createSafeProof(witnessMap, 'PrivateKernelTailArtifact');
+        // }
+        if (!inputs.isForPublic()) {
+            const result = await executeTail(inputs);
+            return {
+                publicInputs: result,
+                proof: makeEmptyProof(),
+            };
+        }
+        // const witnessMap = convertPrivateKernelTailToPublicInputsToWitnessMap(inputs);
+        // return await this.createSafeProof(witnessMap, 'PrivateKernelTailToPublicArtifact');
+        const result = await executeTailForPublic(inputs);
+        return {
+            publicInputs: result,
+            proof: makeEmptyProof(),
+        };
+    }
+    async createAppCircuitProof(partialWitness, bytecode) {
+        const directory = `${this.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
+        await fs.mkdir(directory, { recursive: true });
+        this.log.debug(`Created directory: ${directory}`);
+        try {
+            this.log.debug(`Proving app circuit`);
+            const proof = await this.createProof(directory, partialWitness, bytecode, 'App');
+            return new Proof(proof);
+        }
+        finally {
+            await fs.rm(directory, { recursive: true, force: true });
+            this.log.debug(`Deleted directory: ${directory}`);
+        }
+    }
+    /**
+     * Verifies a proof, will generate the verification key if one is not cached internally
+     * @param circuitType - The type of circuit whose proof is to be verified
+     * @param proof - The proof to be verified
+     */
+    async verifyProof(circuitType, proof) {
+        // Create random directory to be used for temp files
+        const bbWorkingDirectory = `${this.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
+        await fs.mkdir(bbWorkingDirectory, { recursive: true });
+        const proofFileName = `${bbWorkingDirectory}/proof`;
+        const verificationKeyPath = `${bbWorkingDirectory}/vk`;
+        const verificationKey = await this.getVerificationKeyDataForCircuit(circuitType);
+        this.log.debug(`Verifying with key: ${verificationKey.hash.toString()}`);
+        await fs.writeFile(proofFileName, proof.buffer);
+        await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+        const logFunction = (message) => {
+            this.log.debug(`${circuitType} BB out - ${message}`);
+        };
+        const result = await verifyProof(this.bbBinaryPath, proofFileName, verificationKeyPath, logFunction);
+        await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
+        if (result.status === BB_RESULT.FAILURE) {
+            const errorMessage = `Failed to verify ${circuitType} proof!`;
+            throw new Error(errorMessage);
+        }
+        this.log.info(`Successfully verified ${circuitType} proof in ${result.duration} ms`);
+    }
+    /**
+     * Returns the verification key data for a circuit, will generate and cache it if not cached internally
+     * @param circuitType - The type of circuit for which the verification key is required
+     * @returns The verification key data
+     */
+    async getVerificationKeyDataForCircuit(circuitType) {
+        let promise = this.verificationKeys.get(circuitType);
+        if (!promise) {
+            promise = generateKeyForNoirCircuit(this.bbBinaryPath, this.bbWorkingDirectory, circuitType, ClientCircuitArtifacts[circuitType], 'vk', this.log.debug).then(result => {
+                if (result.status === BB_RESULT.FAILURE) {
+                    throw new Error(`Failed to generate verification key for ${circuitType}, ${result.reason}`);
+                }
+                return this.convertVk(result.vkPath);
+            });
+            this.verificationKeys.set(circuitType, promise);
+        }
+        return await promise;
+    }
+    /**
+     * Reads the verification key data stored at the specified location and parses into a VerificationKeyData
+     * @param filePath - The directory containing the verification key data files
+     * @returns The verification key data
+     */
+    async convertVk(filePath) {
+        const [rawFields, rawBinary] = await Promise.all([
+            fs.readFile(`${filePath}/${VK_FIELDS_FILENAME}`, { encoding: 'utf-8' }),
+            fs.readFile(`${filePath}/${VK_FILENAME}`),
+        ]);
+        const fieldsJson = JSON.parse(rawFields);
+        const fields = fieldsJson.map(Fr.fromString);
+        // The first item is the hash, this is not part of the actual VK
+        const vkHash = fields[0];
+        const actualVk = fields.slice(1);
+        const vk = {
+            hash: vkHash,
+            keyAsFields: actualVk,
+            keyAsBytes: rawBinary,
+            numPublicInputs: Number(actualVk[CIRCUIT_PUBLIC_INPUTS_INDEX]),
+            circuitSize: Number(actualVk[CIRCUIT_SIZE_INDEX]),
+            isRecursive: actualVk[CIRCUIT_RECURSIVE_INDEX] == Fr.ONE,
+        };
+        return vk;
+    }
+    /**
+     * Ensures our verification key cache includes the key data located at the specified directory
+     * @param filePath - The directory containing the verification key data files
+     * @param circuitType - The type of circuit to which the verification key corresponds
+     */
+    async updateVerificationKeyAfterProof(filePath, circuitType) {
+        let promise = this.verificationKeys.get(circuitType);
+        if (!promise) {
+            promise = this.convertVk(filePath);
+            this.log.debug(`Updated verification key for circuit: ${circuitType}`);
+            this.verificationKeys.set(circuitType, promise);
+        }
+        await promise;
+    }
+    async createSafeProof(inputs, circuitType) {
+        const directory = `${this.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
+        await fs.mkdir(directory, { recursive: true });
+        this.log.debug(`Created directory: ${directory}`);
+        try {
+            return await this.generateWitnessAndCreateProof(inputs, circuitType, directory);
+        }
+        finally {
+            await fs.rm(directory, { recursive: true, force: true });
+            this.log.debug(`Deleted directory: ${directory}`);
+        }
+    }
+    async generateWitnessAndCreateProof(inputs, circuitType, directory) {
+        this.log.debug(`Generating witness for ${circuitType}`);
+        const compiledCircuit = ClientCircuitArtifacts[circuitType];
+        const outputWitness = await this.simulator.simulateCircuit(inputs, compiledCircuit);
+        this.log.debug(`Generated witness for ${circuitType}`);
+        const publicInputs = KernelArtifactMapping[circuitType].convertOutputs(outputWitness);
+        const proofBuffer = await this.createProof(directory, outputWitness, Buffer.from(compiledCircuit.bytecode, 'base64'), circuitType);
+        const proofOutput = {
+            publicInputs,
+            proof: new Proof(proofBuffer),
+        };
+        return proofOutput;
+    }
+    async createProof(directory, partialWitness, bytecode, circuitType) {
+        const compressedBincodedWitness = serializeWitness(partialWitness);
+        const inputsWitnessFile = `${directory}/witness.gz`;
+        await fs.writeFile(inputsWitnessFile, compressedBincodedWitness);
+        this.log.debug(`Written ${inputsWitnessFile}`);
+        const provingResult = await generateProof(this.bbBinaryPath, directory, circuitType, bytecode, inputsWitnessFile, this.log.debug);
+        if (provingResult.status === BB_RESULT.FAILURE) {
+            this.log.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
+            throw new Error(provingResult.reason);
+        }
+        if (circuitType !== 'App') {
+            await this.updateVerificationKeyAfterProof(directory, circuitType);
+        }
+        const proofFile = `${directory}/${PROOF_FILENAME}`;
+        return await fs.readFile(proofFile);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bb_native_proof_creator.js","sourceRoot":"","sources":["../../../src/kernel_prover/bb_prover/bb_native_proof_creator.ts"],"names":[],"mappings":"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"}

package/dest/kernel_prover/{proof_creator.d.ts → interface/proof_creator.d.ts}

@@ -1,33 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
 import { type PrivateCircuitPublicInputs, type PrivateKernelCircuitPublicInputs, type PrivateKernelInitCircuitPrivateInputs, type PrivateKernelInnerCircuitPrivateInputs, type PrivateKernelTailCircuitPrivateInputs, type PrivateKernelTailCircuitPublicInputs, type Proof } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
+import { type ACVMField } from '@aztec/simulator';
 /**
  * Represents the output of the proof creation process for init and inner private kernel circuit.
  * Contains the public inputs required for the init and inner private kernel circuit and the generated proof.
  */
-export interface ProofOutput {
+export type ProofOutput<PublicInputsType> = {
     /**
      * The public inputs required for the proof generation process.
      */
-    publicInputs: PrivateKernelCircuitPublicInputs;
+    publicInputs: PublicInputsType;
     /**
      * The zk-SNARK proof for the kernel execution.
      */
     proof: Proof;
-}
-/**
- * Represents the output of the proof creation process for final ordering private kernel circuit.
- * Contains the public inputs required for the final ordering private kernel circuit and the generated proof.
- */
-export interface ProofOutputFinal {
-    /**
-     * The public inputs required for the proof generation process.
-     */
-    publicInputs: PrivateKernelTailCircuitPublicInputs;
-    /**
-     * The zk-SNARK proof for the kernel execution.
-     */
-    proof: Proof;
-}
+};
 /**
  * ProofCreator provides functionality to create and validate proofs, and retrieve
  * siloed commitments necessary for maintaining transaction privacy and security on the network.
@@ -46,35 +34,28 @@ export interface ProofCreator {
      * @param privateKernelInputsInit - The private data structure for the initial iteration.
      * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
      */
-    createProofInit(privateKernelInputsInit: PrivateKernelInitCircuitPrivateInputs): Promise<ProofOutput>;
+    createProofInit(privateKernelInputsInit: PrivateKernelInitCircuitPrivateInputs): Promise<ProofOutput<PrivateKernelCircuitPublicInputs>>;
     /**
      * Creates a proof output for a given previous kernel data and private call data for an inner iteration.
      *
      * @param privateKernelInputsInner - The private input data structure for the inner iteration.
      * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
      */
-    createProofInner(privateKernelInputsInner: PrivateKernelInnerCircuitPrivateInputs): Promise<ProofOutput>;
+    createProofInner(privateKernelInputsInner: PrivateKernelInnerCircuitPrivateInputs): Promise<ProofOutput<PrivateKernelCircuitPublicInputs>>;
     /**
      * Creates a proof output based on the last inner kernel iteration kernel data for the final ordering iteration.
      *
      * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
      * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
      */
-    createProofTail(privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs): Promise<ProofOutputFinal>;
-}
-/**
- * The KernelProofCreator class is responsible for generating siloed commitments and zero-knowledge proofs
- * for private kernel circuit. It leverages Barretenberg to perform cryptographic operations and proof creation.
- * The class provides methods to compute commitments based on the given public inputs and to generate proofs based on
- * signed transaction requests, previous kernel data, private call data, and a flag indicating whether it's the first
- * iteration or not.
- */
-export declare class KernelProofCreator implements ProofCreator {
-    private log;
-    constructor(log?: import("@aztec/foundation/log").Logger);
-    getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs): Promise<Fr[]>;
-    createProofInit(privateInputs: PrivateKernelInitCircuitPrivateInputs): Promise<ProofOutput>;
-    createProofInner(privateInputs: PrivateKernelInnerCircuitPrivateInputs): Promise<ProofOutput>;
-    createProofTail(privateInputs: PrivateKernelTailCircuitPrivateInputs): Promise<ProofOutputFinal>;
+    createProofTail(privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs): Promise<ProofOutput<PrivateKernelTailCircuitPublicInputs>>;
+    /**
+     * Creates a proof for an app circuit.
+     *
+     * @param partialWitness - The witness produced via circuit simulation
+     * @param bytecode - The circuit bytecode in gzipped bincode format
+     * @returns A Promise resolving to a Proof object
+     */
+    createAppCircuitProof(partialWitness: Map<number, ACVMField>, bytecode: Buffer): Promise<Proof>;
 }
 //# sourceMappingURL=proof_creator.d.ts.map

package/dest/kernel_prover/interface/proof_creator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof_creator.d.ts","sourceRoot":"","sources":["../../../src/kernel_prover/interface/proof_creator.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,qCAAqC,EAC1C,KAAK,sCAAsC,EAC3C,KAAK,qCAAqC,EAC1C,KAAK,oCAAoC,EACzC,KAAK,KAAK,EACX,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,gBAAgB,IAAI;IAC1C;;OAEG;IACH,YAAY,EAAE,gBAAgB,CAAC;IAC/B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,oBAAoB,CAAC,YAAY,EAAE,0BAA0B,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;IAE9E;;;;;OAKG;IACH,eAAe,CACb,uBAAuB,EAAE,qCAAqC,GAC7D,OAAO,CAAC,WAAW,CAAC,gCAAgC,CAAC,CAAC,CAAC;IAE1D;;;;;OAKG;IACH,gBAAgB,CACd,wBAAwB,EAAE,sCAAsC,GAC/D,OAAO,CAAC,WAAW,CAAC,gCAAgC,CAAC,CAAC,CAAC;IAE1D;;;;;OAKG;IACH,eAAe,CACb,uBAAuB,EAAE,qCAAqC,GAC7D,OAAO,CAAC,WAAW,CAAC,oCAAoC,CAAC,CAAC,CAAC;IAE9D;;;;;;OAMG;IACH,qBAAqB,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CACjG"}

package/dest/kernel_prover/interface/proof_creator.js

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

package/dest/kernel_prover/kernel_prover.d.ts

@@ -1,6 +1,6 @@
-import { type TxRequest } from '@aztec/circuits.js';
+import { type PrivateKernelTailCircuitPublicInputs, type TxRequest } from '@aztec/circuits.js';
 import { type ExecutionResult } from '@aztec/simulator';
-import { type ProofCreator, type ProofOutputFinal } from './proof_creator.js';
+import { type ProofCreator, type ProofOutput } from './interface/proof_creator.js';
 import { type ProvingDataOracle } from './proving_data_oracle.js';
 /**
  * The KernelProver class is responsible for generating kernel proofs.
@@ -12,7 +12,7 @@ export declare class KernelProver {
     private oracle;
     private proofCreator;
     private log;
-    constructor(oracle: ProvingDataOracle, proofCreator?: ProofCreator);
+    constructor(oracle: ProvingDataOracle, proofCreator: ProofCreator);
     /**
      * Generate a proof for a given transaction request and execution result.
      * The function iterates through the nested executions in the execution result, creates private call data,
@@ -23,7 +23,7 @@ export declare class KernelProver {
      * @param executionResult - The execution result object containing nested executions and preimages.
      * @returns A Promise that resolves to a KernelProverOutput object containing proof, public inputs, and output notes.
      */
-    prove(txRequest: TxRequest, executionResult: ExecutionResult): Promise<ProofOutputFinal>;
+    prove(txRequest: TxRequest, executionResult: ExecutionResult): Promise<ProofOutput<PrivateKernelTailCircuitPublicInputs>>;
     private createPrivateCallData;
 }
 //# sourceMappingURL=kernel_prover.d.ts.map

package/dest/kernel_prover/kernel_prover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kernel_prover.d.ts","sourceRoot":"","sources":["../../src/kernel_prover/kernel_prover.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,KAAK,SAAS,EAIf,MAAM,oBAAoB,CAAC;AAM5B,OAAO,EAAE,KAAK,eAAe,EAAoC,MAAM,kBAAkB,CAAC;AAO1F,OAAO,EAAsB,KAAK,YAAY,EAAoB,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACpH,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;GAKG;AACH,qBAAa,YAAY;IAEX,OAAO,CAAC,MAAM;IAAqB,OAAO,CAAC,YAAY;IADnE,OAAO,CAAC,GAAG,CAA4C;gBACnC,MAAM,EAAE,iBAAiB,EAAU,YAAY,GAAE,YAAuC;IAE5G;;;;;;;;;OASG;IACG,KAAK,CAAC,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;YA2GhF,qBAAqB;CAoDpC"}
+{"version":3,"file":"kernel_prover.d.ts","sourceRoot":"","sources":["../../src/kernel_prover/kernel_prover.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,KAAK,oCAAoC,EAEzC,KAAK,SAAS,EAIf,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EAAE,KAAK,eAAe,EAAiE,MAAM,kBAAkB,CAAC;AAEvH,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAMnF,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;GAKG;AACH,qBAAa,YAAY;IAGX,OAAO,CAAC,MAAM;IAAqB,OAAO,CAAC,YAAY;IAFnE,OAAO,CAAC,GAAG,CAA4C;gBAEnC,MAAM,EAAE,iBAAiB,EAAU,YAAY,EAAE,YAAY;IAEjF;;;;;;;;;OASG;IACG,KAAK,CACT,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,WAAW,CAAC,oCAAoC,CAAC,CAAC;YAmF/C,qBAAqB;CA4CpC"}