@aztec/bb-prover 0.0.0-test.0 → 0.0.1-commit.21caa21

package/dest/prover/bb_prover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bb_prover.d.ts","sourceRoot":"","sources":["../../src/prover/bb_prover.ts"],"names":[],"mappings":"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"}

package/dest/prover/bb_prover.js

@@ -1,423 +0,0 @@
-/* eslint-disable require-await */ function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { AGGREGATION_OBJECT_LENGTH, AVM_PROOF_LENGTH_IN_FIELDS, IPA_CLAIM_LENGTH, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { runInDirectory } from '@aztec/foundation/fs';
-import { createLogger } from '@aztec/foundation/log';
-import { BufferReader } from '@aztec/foundation/serialize';
-import { Timer } from '@aztec/foundation/timer';
-import { ServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap, convertBlockRootRollupInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPrivateBaseRollupInputsToWitnessMap, convertPrivateBaseRollupOutputsFromWitnessMap, convertPublicBaseRollupInputsToWitnessMap, convertPublicBaseRollupOutputsFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertSingleTxBlockRootRollupInputsToWitnessMap, convertSingleTxBlockRootRollupOutputsFromWitnessMap } from '@aztec/noir-protocol-circuits-types/server';
-import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
-import { NativeACVMSimulator } from '@aztec/simulator/server';
-import { ProvingError } from '@aztec/stdlib/errors';
-import { makeProofAndVerificationKey, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { Proof, RecursiveProof, makeRecursiveProofFromBinary } from '@aztec/stdlib/proofs';
-import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { assert } from 'console';
-import crypto from 'crypto';
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { BB_RESULT, PROOF_FIELDS_FILENAME, PROOF_FILENAME, VK_FILENAME, generateAvmProof, generateProof, generateTubeProof, verifyAvmProof, verifyProof } from '../bb/execute.js';
-import { 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 { writeToOutputDirectory } from './client_ivc_proof_utils.js';
-const logger = createLogger('bb-prover');
-// All `ServerCircuitArtifact` are recursive.
-const SERVER_CIRCUIT_RECURSIVE = true;
-/**
- * Prover implementation that uses barretenberg native proving
- */ export class BBNativeRollupProver {
-    config;
-    instrumentation;
-    constructor(config, telemetry){
-        this.config = config;
-        this.instrumentation = new ProverInstrumentation(telemetry, 'BBNativeRollupProver');
-    }
-    get tracer() {
-        return this.instrumentation.tracer;
-    }
-    static async new(config, telemetry = getTelemetryClient()) {
-        await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
-        await fs.mkdir(config.acvmWorkingDirectory, {
-            recursive: true
-        });
-        await fs.access(config.bbBinaryPath, fs.constants.R_OK);
-        await fs.mkdir(config.bbWorkingDirectory, {
-            recursive: true
-        });
-        logger.info(`Using native BB at ${config.bbBinaryPath} and working directory ${config.bbWorkingDirectory}`);
-        logger.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
-        return new BBNativeRollupProver(config, telemetry);
-    }
-    /**
-   * Simulates the base parity circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs of the parity circuit.
-   */ async getBaseParityProof(inputs) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'BaseParityArtifact', RECURSIVE_PROOF_LENGTH, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('BaseParityArtifact');
-        await this.verifyProof('BaseParityArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the root parity circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs of the parity circuit.
-   */ async getRootParityProof(inputs) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'RootParityArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('RootParityArtifact');
-        await this.verifyProof('RootParityArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Creates an AVM proof and verifies it.
-   * @param inputs - The inputs to the AVM circuit.
-   * @returns The proof.
-   */ async getAvmProof(inputs) {
-        const proofAndVk = await this.createAvmProof(inputs);
-        await this.verifyAvmProof(proofAndVk.proof.binaryProof, proofAndVk.verificationKey);
-        return proofAndVk;
-    }
-    /**
-   * Simulates the base rollup circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getPrivateBaseRollupProof(inputs) {
-        const artifactName = 'PrivateBaseRollupArtifact';
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPrivateBaseRollupInputsToWitnessMap, convertPrivateBaseRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
-        await this.verifyProof(artifactName, proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Requests that the public kernel tail circuit be executed and the proof generated
-   * @param kernelRequest - The object encapsulating the request for a proof
-   * @returns The requested circuit's public inputs and proof
-   */ async getPublicBaseRollupProof(inputs) {
-        const artifactName = 'PublicBaseRollupArtifact';
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPublicBaseRollupInputsToWitnessMap, convertPublicBaseRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
-        await this.verifyProof(artifactName, proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the merge rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getMergeRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'MergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
-        await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the block root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootRollupInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
-        await this.verifyProof('BlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    async getSingleTxBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'SingleTxBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSingleTxBlockRootRollupInputsToWitnessMap, convertSingleTxBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
-        await this.verifyProof('SingleTxBlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the empty block root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getEmptyBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'EmptyBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
-        await this.verifyProof('EmptyBlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the block merge rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getBlockMergeRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BlockMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('BlockMergeRollupArtifact');
-        await this.verifyProof('BlockMergeRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createProof(input, 'RootRollupArtifact', convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap);
-        const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
-        const verificationKey = this.getVerificationKeyDataForCircuit('RootRollupArtifact');
-        await this.verifyProof('RootRollupArtifact', proof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, verificationKey);
-    }
-    async generateProofWithBB(input, circuitType, convertInput, convertOutput, workingDirectory) {
-        // Have the ACVM write the partial witness here
-        const outputWitnessFile = path.join(workingDirectory, 'partial-witness.gz');
-        // Generate the partial witness using the ACVM
-        // A further temp directory will be created beneath ours and then cleaned up after the partial witness has been copied to our specified location
-        const simulator = new NativeACVMSimulator(this.config.acvmWorkingDirectory, this.config.acvmBinaryPath, outputWitnessFile);
-        const artifact = ServerCircuitArtifacts[circuitType];
-        logger.debug(`Generating witness data for ${circuitType}`);
-        const inputWitness = convertInput(input);
-        const timer = new Timer();
-        const outputWitness = await simulator.executeProtocolCircuit(inputWitness, artifact);
-        const output = convertOutput(outputWitness);
-        const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
-        this.instrumentation.recordDuration('witGenDuration', circuitName, timer);
-        this.instrumentation.recordSize('witGenInputSize', circuitName, input.toBuffer().length);
-        this.instrumentation.recordSize('witGenOutputSize', circuitName, output.toBuffer().length);
-        logger.info(`Generated witness`, {
-            circuitName,
-            duration: timer.ms(),
-            inputSize: input.toBuffer().length,
-            outputSize: output.toBuffer().length,
-            eventName: 'circuit-witness-generation'
-        });
-        // Now prove the circuit from the generated witness
-        logger.debug(`Proving ${circuitType}...`);
-        const provingResult = await generateProof(this.config.bbBinaryPath, workingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), SERVER_CIRCUIT_RECURSIVE, outputWitnessFile, getUltraHonkFlavorForCircuit(circuitType), logger.debug);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
-            throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
-        }
-        return {
-            circuitOutput: output,
-            provingResult
-        };
-    }
-    async createProof(input, circuitType, convertInput, convertOutput) {
-        const operation = async (bbWorkingDirectory)=>{
-            const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
-            // Read the binary proof
-            const rawProof = await fs.readFile(`${provingResult.proofPath}/${PROOF_FILENAME}`);
-            const vkData = this.getVerificationKeyDataForCircuit(circuitType);
-            const proof = new Proof(rawProof, vkData.numPublicInputs);
-            const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
-            this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
-            this.instrumentation.recordSize('proofSize', circuitName, proof.buffer.length);
-            this.instrumentation.recordSize('circuitPublicInputCount', circuitName, vkData.numPublicInputs);
-            this.instrumentation.recordSize('circuitSize', circuitName, vkData.circuitSize);
-            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.durationMs)} ms`, {
-                circuitName,
-                // does not include reading the proof from disk
-                duration: provingResult.durationMs,
-                proofSize: proof.buffer.length,
-                eventName: 'circuit-proving',
-                // circuitOutput is the partial witness that became the input to the proof
-                inputSize: output.toBuffer().length,
-                circuitSize: vkData.circuitSize,
-                numPublicInputs: vkData.numPublicInputs
-            });
-            return {
-                circuitOutput: output,
-                proof
-            };
-        };
-        return await this.runInDirectory(operation);
-    }
-    async generateAvmProofWithBB(input, workingDirectory) {
-        logger.info(`Proving avm-circuit for ${input.functionName}...`);
-        const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate AVM proof for ${input.functionName}: ${provingResult.reason}`);
-            throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
-        }
-        return provingResult;
-    }
-    async generateTubeProofWithBB(bbWorkingDirectory, input) {
-        logger.debug(`Proving tube...`);
-        const hasher = crypto.createHash('sha256');
-        hasher.update(input.toBuffer());
-        await writeToOutputDirectory(input.clientIVCData, bbWorkingDirectory);
-        const provingResult = await generateTubeProof(this.config.bbBinaryPath, bbWorkingDirectory, 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;
-    }
-    async createAvmProof(input) {
-        const operation = async (bbWorkingDirectory)=>{
-            const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
-            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6773): this VK data format is wrong.
-            // In particular, the number of public inputs, etc will be wrong.
-            const verificationKey = await extractAvmVkData(provingResult.vkPath);
-            const avmProof = await this.readAvmProofAsFields(provingResult.proofPath, verificationKey);
-            const circuitType = 'avm-circuit';
-            const appCircuitName = 'unknown';
-            this.instrumentation.recordAvmDuration('provingDuration', appCircuitName, provingResult.durationMs);
-            this.instrumentation.recordAvmSize('proofSize', appCircuitName, avmProof.binaryProof.buffer.length);
-            this.instrumentation.recordAvmSize('circuitPublicInputCount', appCircuitName, verificationKey.numPublicInputs);
-            this.instrumentation.recordAvmSize('circuitSize', appCircuitName, verificationKey.circuitSize);
-            logger.info(`Generated proof for ${circuitType}(${input.functionName}) in ${Math.ceil(provingResult.durationMs)} ms`, {
-                circuitName: circuitType,
-                appCircuitName: input.functionName,
-                // does not include reading the proof from disk
-                duration: provingResult.durationMs,
-                proofSize: avmProof.binaryProof.buffer.length,
-                eventName: 'circuit-proving',
-                inputSize: input.serializeWithMessagePack().length,
-                circuitSize: verificationKey.circuitSize,
-                numPublicInputs: verificationKey.numPublicInputs
-            });
-            return makeProofAndVerificationKey(avmProof, verificationKey);
-        };
-        return await this.runInDirectory(operation);
-    }
-    async getTubeProof(input) {
-        const operation = async (bbWorkingDirectory)=>{
-            logger.debug(`createTubeProof: ${bbWorkingDirectory}`);
-            const provingResult = await this.generateTubeProofWithBB(bbWorkingDirectory, input);
-            // Read the proof as fields
-            // TODO(AD): this is the only remaining use of extractVkData.
-            const tubeVK = await extractVkData(provingResult.vkPath);
-            const tubeProof = await this.readProofAsFields(provingResult.proofPath, tubeVK, TUBE_PROOF_LENGTH);
-            this.instrumentation.recordDuration('provingDuration', 'tubeCircuit', provingResult.durationMs);
-            this.instrumentation.recordSize('proofSize', 'tubeCircuit', tubeProof.binaryProof.buffer.length);
-            this.instrumentation.recordSize('circuitPublicInputCount', 'tubeCircuit', tubeVK.numPublicInputs);
-            this.instrumentation.recordSize('circuitSize', 'tubeCircuit', tubeVK.circuitSize);
-            // Sanity check the tube proof (can be removed later)
-            await this.verifyWithKey('ultra_rollup_honk', tubeVK, tubeProof.binaryProof);
-            logger.info(`Generated proof for tubeCircuit in ${Math.ceil(provingResult.durationMs)} ms, size: ${tubeProof.proof.length} fields`);
-            return makeProofAndVerificationKey(tubeProof, tubeVK);
-        };
-        return await this.runInDirectory(operation);
-    }
-    /**
-   * Executes a circuit and returns its outputs and corresponding proof with embedded aggregation object
-   * @param witnessMap - The input witness
-   * @param circuitType - The type of circuit to be executed
-   * @param proofLength - The length of the proof to be generated. This is a dummy parameter to aid in type checking
-   * @param convertInput - Function for mapping the input object to a witness map.
-   * @param convertOutput - Function for parsing the output witness to it's corresponding object
-   * @returns The circuits output object and it's proof
-   */ async createRecursiveProof(input, circuitType, proofLength, convertInput, convertOutput) {
-        // this probably is gonna need to call client ivc
-        const operation = async (bbWorkingDirectory)=>{
-            const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
-            const vkData = this.getVerificationKeyDataForCircuit(circuitType);
-            // Read the proof as fields
-            const proof = await this.readProofAsFields(provingResult.proofPath, vkData, proofLength);
-            const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
-            this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
-            this.instrumentation.recordSize('proofSize', circuitName, proof.binaryProof.buffer.length);
-            this.instrumentation.recordSize('circuitPublicInputCount', circuitName, vkData.numPublicInputs);
-            this.instrumentation.recordSize('circuitSize', circuitName, vkData.circuitSize);
-            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.durationMs)} ms, size: ${proof.proof.length} fields`, {
-                circuitName,
-                circuitSize: vkData.circuitSize,
-                duration: provingResult.durationMs,
-                inputSize: output.toBuffer().length,
-                proofSize: proof.binaryProof.buffer.length,
-                eventName: 'circuit-proving',
-                numPublicInputs: vkData.numPublicInputs
-            });
-            return {
-                circuitOutput: output,
-                proof
-            };
-        };
-        return await this.runInDirectory(operation);
-    }
-    /**
-   * 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) {
-        const verificationKey = this.getVerificationKeyDataForCircuit(circuitType);
-        return await this.verifyWithKey(getUltraHonkFlavorForCircuit(circuitType), verificationKey, proof);
-    }
-    async verifyAvmProof(proof, verificationKey) {
-        return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath)=>verifyAvmProof(this.config.bbBinaryPath, proofPath, vkPath, logger));
-    }
-    async verifyWithKey(flavor, verificationKey, proof) {
-        return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath)=>verifyProof(this.config.bbBinaryPath, proofPath, vkPath, flavor, logger));
-    }
-    async verifyWithKeyInternal(proof, verificationKey, verificationFunction) {
-        const operation = async (bbWorkingDirectory)=>{
-            const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
-            const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
-            await fs.writeFile(proofFileName, proof.buffer);
-            await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
-            const result = await verificationFunction(proofFileName, verificationKeyPath);
-            if (result.status === BB_RESULT.FAILURE) {
-                const errorMessage = `Failed to verify proof from key!`;
-                throw new ProvingError(errorMessage, result, result.retry);
-            }
-            logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
-        };
-        await this.runInDirectory(operation);
-    }
-    /**
-   * Returns the verification key data for a circuit.
-   * @param circuitType - The type of circuit for which the verification key is required
-   * @returns The verification key data
-   */ getVerificationKeyDataForCircuit(circuitType) {
-        const vk = ServerCircuitVks[circuitType];
-        if (vk === undefined) {
-            throw new Error('Could not find VK for server artifact ' + circuitType);
-        }
-        return vk;
-    }
-    async readProofAsFields(filePath, vkData, proofLength) {
-        const proofFilename = path.join(filePath, PROOF_FILENAME);
-        const proofFieldsFilename = path.join(filePath, PROOF_FIELDS_FILENAME);
-        const [binaryProof, proofString] = await Promise.all([
-            fs.readFile(proofFilename),
-            fs.readFile(proofFieldsFilename, {
-                encoding: 'utf-8'
-            })
-        ]);
-        const json = JSON.parse(proofString);
-        let numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-        if (proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH) {
-            numPublicInputs -= IPA_CLAIM_LENGTH;
-        }
-        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));
-        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}`);
-        return new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProof, numPublicInputs), true, proofLength);
-    }
-    async readAvmProofAsFields(proofFilename, vkData) {
-        const rawProof = await fs.readFile(proofFilename);
-        const reader = BufferReader.asReader(rawProof);
-        const fields = reader.readArray(rawProof.length / Fr.SIZE_IN_BYTES, Fr);
-        const fieldsWithoutPublicCols = fields.slice(-1 * AVM_PROOF_LENGTH_IN_FIELDS);
-        const proof = new Proof(rawProof, vkData.numPublicInputs);
-        return new RecursiveProof(fieldsWithoutPublicCols, proof, true, AVM_PROOF_LENGTH_IN_FIELDS);
-    }
-    runInDirectory(fn) {
-        return runInDirectory(this.config.bbWorkingDirectory, (dir)=>fn(dir).catch((err)=>{
-                logger.error(`Error running operation at ${dir}: ${err}`);
-                throw err;
-            }), this.config.bbSkipCleanup, logger);
-    }
-}
-_ts_decorate([
-    trackSpan('BBNativeRollupProver.getBaseParityProof', {
-        [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity'
-    })
-], BBNativeRollupProver.prototype, "getBaseParityProof", null);
-_ts_decorate([
-    trackSpan('BBNativeRollupProver.getRootParityProof', {
-        [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity'
-    })
-], BBNativeRollupProver.prototype, "getRootParityProof", null);
-_ts_decorate([
-    trackSpan('BBNativeRollupProver.getAvmProof', (inputs)=>({
-            [Attributes.APP_CIRCUIT_NAME]: inputs.functionName
-        }))
-], BBNativeRollupProver.prototype, "getAvmProof", null);

package/dest/prover/client_ivc_proof_utils.d.ts

@@ -1,25 +0,0 @@
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
-export declare const CLIENT_IVC_VK_FILE_NAME = "vk";
-export declare 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
- * @returns the encapsulated client ivc proof
- */
-export declare function readFromOutputDirectory(directory: string): Promise<ClientIvcProof>;
-/**
- * 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
- *
- * 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
- */
-export declare function writeToOutputDirectory(clientIvcProof: ClientIvcProof, directory: string): Promise<void>;
-//# sourceMappingURL=client_ivc_proof_utils.d.ts.map

package/dest/prover/client_ivc_proof_utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client_ivc_proof_utils.d.ts","sourceRoot":"","sources":["../../src/prover/client_ivc_proof_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAKtD,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAC5C,eAAO,MAAM,0BAA0B,UAAU,CAAC;AAElD;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAAC,SAAS,EAAE,MAAM,2BAK9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAAC,cAAc,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,iBAO7F"}

package/dest/prover/client_ivc_proof_utils.js

@@ -1,43 +0,0 @@
-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
- * @returns the encapsulated client ivc proof
- */ export async function readFromOutputDirectory(directory) {
-    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);
-}
-/**
- * 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
- *
- * 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
- */ export async function writeToOutputDirectory(clientIvcProof, directory) {
-    const { clientIvcProofBuffer, clientIvcVkBuffer } = clientIvcProof;
-    const fileData = [
-        [
-            CLIENT_IVC_PROOF_FILE_NAME,
-            clientIvcProofBuffer
-        ],
-        [
-            CLIENT_IVC_VK_FILE_NAME,
-            clientIvcVkBuffer
-        ]
-    ];
-    await Promise.all(fileData.map(([fileName, buffer])=>fs.writeFile(join(directory, fileName), buffer)));
-}

package/dest/stats.d.ts

@@ -1,5 +0,0 @@
-import type { ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
-import type { CircuitName } from '@aztec/stdlib/stats';
-export declare function mapProtocolArtifactNameToCircuitName(artifact: ProtocolArtifact): CircuitName;
-export declare function isProtocolArtifactRecursive(artifact: ProtocolArtifact): boolean;
-//# sourceMappingURL=stats.d.ts.map

package/dest/stats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../src/stats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,gBAAgB,GAAG,WAAW,CAqC5F;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAqB/E"}

package/dest/stats.js

@@ -1,62 +0,0 @@
-export function mapProtocolArtifactNameToCircuitName(artifact) {
-    switch(artifact){
-        case 'BaseParityArtifact':
-            return 'base-parity';
-        case 'RootParityArtifact':
-            return 'root-parity';
-        case 'PrivateBaseRollupArtifact':
-            return 'private-base-rollup';
-        case 'PublicBaseRollupArtifact':
-            return 'public-base-rollup';
-        case 'MergeRollupArtifact':
-            return 'merge-rollup';
-        case 'BlockRootRollupArtifact':
-            return 'block-root-rollup';
-        case 'SingleTxBlockRootRollupArtifact':
-            return 'single-tx-block-root-rollup';
-        case 'EmptyBlockRootRollupArtifact':
-            return 'empty-block-root-rollup';
-        case 'BlockMergeRollupArtifact':
-            return 'block-merge-rollup';
-        case 'RootRollupArtifact':
-            return 'root-rollup';
-        case 'PrivateKernelInitArtifact':
-            return 'private-kernel-init';
-        case 'PrivateKernelInnerArtifact':
-            return 'private-kernel-inner';
-        case 'PrivateKernelTailArtifact':
-            return 'private-kernel-tail';
-        case 'PrivateKernelTailToPublicArtifact':
-            return 'private-kernel-tail-to-public';
-        default:
-            {
-                if (artifact.startsWith('PrivateKernelReset')) {
-                    return 'private-kernel-reset';
-                }
-                throw new Error(`Unknown circuit type: ${artifact}`);
-            }
-    }
-}
-export function isProtocolArtifactRecursive(artifact) {
-    switch(artifact){
-        case 'BaseParityArtifact':
-        case 'RootParityArtifact':
-        case 'PrivateBaseRollupArtifact':
-        case 'PublicBaseRollupArtifact':
-        case 'MergeRollupArtifact':
-        case 'BlockRootRollupArtifact':
-        case 'SingleTxBlockRootRollupArtifact':
-        case 'EmptyBlockRootRollupArtifact':
-        case 'BlockMergeRollupArtifact':
-        case 'RootRollupArtifact':
-            return true;
-        default:
-            {
-                if (artifact.startsWith('PrivateKernel')) {
-                    // The kernel prover, where these are used, eventually calls `createClientIvcProof`, which is recursive.
-                    return true;
-                }
-                throw new Error(`Unknown circuit type: ${artifact}`);
-            }
-    }
-}

package/dest/wasm/bb_wasm_private_kernel_prover.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { ArtifactProvider } from '@aztec/noir-protocol-circuits-types/types';
-import type { SimulationProvider } from '@aztec/simulator/client';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
-import type { WitnessMap } from '@noir-lang/types';
-import { BBPrivateKernelProver } from '../prover/bb_private_kernel_prover.js';
-export declare abstract class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
-    protected artifactProvider: ArtifactProvider;
-    protected simulationProvider: SimulationProvider;
-    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>;
-    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 +0,0 @@
-{"version":3,"file":"bb_wasm_private_kernel_prover.d.ts","sourceRoot":"","sources":["../../src/wasm/bb_wasm_private_kernel_prover.ts"],"names":[],"mappings":";;AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,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"}

package/dest/wasm/bb_wasm_private_kernel_prover.js

@@ -1,46 +0,0 @@
-import { AztecClientBackend } from '@aztec/bb.js';
-import { createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
-import { serializeWitness } from '@noir-lang/noirc_abi';
-import { ungzip } from 'pako';
-import { BBPrivateKernelProver } from '../prover/bb_private_kernel_prover.js';
-export class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
-    artifactProvider;
-    simulationProvider;
-    threads;
-    log;
-    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) {
-        const timer = new Timer();
-        this.log.info(`Generating ClientIVC proof...`);
-        const backend = new AztecClientBackend(acirs.map((acir)=>ungzip(acir)), {
-            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))));
-        await backend.destroy();
-        this.log.info(`Generated ClientIVC proof`, {
-            eventName: 'client-ivc-proof-generation',
-            duration: timer.ms(),
-            proofSize: proof.length,
-            vkSize: vk.length
-        });
-        return new ClientIvcProof(Buffer.from(proof), Buffer.from(vk));
-    }
-    async computeGateCountForCircuit(_bytecode, _circuitName) {
-        const backend = new AztecClientBackend([
-            ungzip(_bytecode)
-        ], {
-            threads: this.threads,
-            logger: this.log.verbose,
-            wasmPath: process.env.BB_WASM_PATH
-        });
-        const gateCount = await backend.gates();
-        await backend.destroy();
-        return gateCount[0];
-    }
-}