@aztec/bb-prover 0.39.0

package/dest/prover/bb_prover.js

@@ -0,0 +1,321 @@
+/* eslint-disable require-await */
+import { PublicKernelType, makePublicInputsAndProof, } from '@aztec/circuit-types';
+import { Fr, Proof, RecursiveProof, RollupTypes, RootParityInput, VerificationKeyAsFields, } from '@aztec/circuits.js';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBaseRollupInputsToWitnessMap, convertBaseRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPublicTailInputsToWitnessMap, convertPublicTailOutputFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, } from '@aztec/noir-protocol-circuits-types';
+import { NativeACVMSimulator } from '@aztec/simulator';
+import * as fs from 'fs/promises';
+import { BB_RESULT, PROOF_FIELDS_FILENAME, PROOF_FILENAME, VK_FIELDS_FILENAME, VK_FILENAME, generateKeyForNoirCircuit, generateProof, verifyProof, } from '../bb/execute.js';
+import { PublicKernelArtifactMapping } from '../mappings/mappings.js';
+import { circuitTypeToCircuitName, emitCircuitProvingStats, emitCircuitWitnessGenerationStats } from '../stats.js';
+import { AGGREGATION_OBJECT_SIZE, CIRCUIT_PUBLIC_INPUTS_INDEX, CIRCUIT_RECURSIVE_INDEX, CIRCUIT_SIZE_INDEX, } from './verification_key_data.js';
+const logger = createDebugLogger('aztec:bb-prover');
+const CIRCUITS_WITHOUT_AGGREGATION = new Set(['BaseParityArtifact']);
+/**
+ * Prover implementation that uses barretenberg native proving
+ */
+export class BBNativeRollupProver {
+    constructor(config) {
+        this.config = config;
+        this.verificationKeys = new Map();
+    }
+    static async new(config) {
+        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);
+    }
+    /**
+     * 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 witnessMap = convertBaseParityInputsToWitnessMap(inputs);
+        const [circuitOutput, proof] = await this.createRecursiveProof(witnessMap, 'BaseParityArtifact', convertBaseParityOutputsFromWitnessMap);
+        const verificationKey = await this.getVerificationKeyDataForCircuit('BaseParityArtifact');
+        const vk = new VerificationKeyAsFields(verificationKey.keyAsFields, verificationKey.hash);
+        return new RootParityInput(proof, vk, circuitOutput);
+    }
+    /**
+     * 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 witnessMap = convertRootParityInputsToWitnessMap(inputs);
+        const [circuitOutput, proof] = await this.createRecursiveProof(witnessMap, 'RootParityArtifact', convertRootParityOutputsFromWitnessMap);
+        const verificationKey = await this.getVerificationKeyDataForCircuit('RootParityArtifact');
+        const vk = new VerificationKeyAsFields(verificationKey.keyAsFields, verificationKey.hash);
+        return new RootParityInput(proof, vk, circuitOutput);
+    }
+    /**
+     * Requests that a public kernel 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 getPublicKernelProof(kernelRequest) {
+        const kernelOps = PublicKernelArtifactMapping[kernelRequest.type];
+        if (kernelOps === undefined) {
+            throw new Error(`Unable to prove kernel type ${PublicKernelType[kernelRequest.type]}`);
+        }
+        const witnessMap = kernelOps.convertInputs(kernelRequest.inputs);
+        const [outputWitness, proof] = await this.createProof(witnessMap, kernelOps.artifact);
+        const result = kernelOps.convertOutputs(outputWitness);
+        return makePublicInputsAndProof(result, proof);
+    }
+    /**
+     * 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 getPublicTailProof(kernelRequest) {
+        const witnessMap = convertPublicTailInputsToWitnessMap(kernelRequest.inputs);
+        const [outputWitness, proof] = await this.createProof(witnessMap, 'PublicKernelTailArtifact');
+        const result = convertPublicTailOutputFromWitnessMap(outputWitness);
+        return makePublicInputsAndProof(result, proof);
+    }
+    /**
+     * Simulates the base rollup circuit from its inputs.
+     * @param input - Inputs to the circuit.
+     * @returns The public inputs as outputs of the simulation.
+     */
+    async getBaseRollupProof(input) {
+        const witnessMap = convertBaseRollupInputsToWitnessMap(input);
+        const [outputWitness, proof] = await this.createProof(witnessMap, 'BaseRollupArtifact');
+        const result = convertBaseRollupOutputsFromWitnessMap(outputWitness);
+        return makePublicInputsAndProof(result, proof);
+    }
+    /**
+     * 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) {
+        // verify both inputs
+        await Promise.all(input.previousRollupData.map(prev => this.verifyPreviousRollupProof(prev)));
+        const witnessMap = convertMergeRollupInputsToWitnessMap(input);
+        const [outputWitness, proof] = await this.createProof(witnessMap, 'MergeRollupArtifact');
+        const result = convertMergeRollupOutputsFromWitnessMap(outputWitness);
+        return makePublicInputsAndProof(result, proof);
+    }
+    /**
+     * 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) {
+        // verify the inputs
+        await Promise.all(input.previousRollupData.map(prev => this.verifyPreviousRollupProof(prev)));
+        const witnessMap = convertRootRollupInputsToWitnessMap(input);
+        const [outputWitness, proof] = await this.createProof(witnessMap, 'RootRollupArtifact');
+        await this.verifyProof('RootRollupArtifact', proof);
+        const result = convertRootRollupOutputsFromWitnessMap(outputWitness);
+        return makePublicInputsAndProof(result, proof);
+    }
+    // TODO(@PhilWindle): Delete when no longer required
+    async createProof(witnessMap, circuitType) {
+        // Create random directory to be used for temp files
+        const bbWorkingDirectory = `${this.config.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
+        await fs.mkdir(bbWorkingDirectory, { recursive: true });
+        await fs.access(bbWorkingDirectory);
+        // Have the ACVM write the partial witness here
+        const outputWitnessFile = `${bbWorkingDirectory}/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 timer = new Timer();
+        const outputWitness = await simulator.simulateCircuit(witnessMap, artifact);
+        emitCircuitWitnessGenerationStats(circuitTypeToCircuitName(circuitType), timer.ms(), witnessMap.size * Fr.SIZE_IN_BYTES, outputWitness.size * Fr.SIZE_IN_BYTES, logger);
+        // Now prove the circuit from the generated witness
+        logger.debug(`Proving ${circuitType}...`);
+        const provingResult = await generateProof(this.config.bbBinaryPath, bbWorkingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), outputWitnessFile, logger.debug);
+        if (provingResult.status === BB_RESULT.FAILURE) {
+            logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
+            throw new Error(provingResult.reason);
+        }
+        // Ensure our vk cache is up to date
+        await this.updateVerificationKeyAfterProof(provingResult.vkPath, circuitType);
+        // Read the proof and then cleanup up our temporary directory
+        const proof = await fs.readFile(`${provingResult.proofPath}/${PROOF_FILENAME}`);
+        // does not include reading the proof from disk above because duration comes from the bb wrapper
+        emitCircuitProvingStats(circuitTypeToCircuitName(circuitType), provingResult.duration, witnessMap.size * Fr.SIZE_IN_BYTES, outputWitness.size * Fr.SIZE_IN_BYTES, proof.length, logger);
+        await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
+        logger.info(`Generated proof for ${circuitType} in ${provingResult.duration} ms, size: ${proof.length} fields`);
+        return [outputWitness, new Proof(proof)];
+    }
+    /**
+     * Executes a circuit and returns it's outputs and corresponding proof with embedded aggregation object
+     * @param witnessMap - The input witness
+     * @param circuitType - The type of circuit to be executed
+     * @param convertOutput - Function for parsing the output witness to it's corresponding object
+     * @returns The circuits output object and it's proof
+     */
+    async createRecursiveProof(witnessMap, circuitType, convertOutput) {
+        // Create random directory to be used for temp files
+        const bbWorkingDirectory = `${this.config.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
+        await fs.mkdir(bbWorkingDirectory, { recursive: true });
+        await fs.access(bbWorkingDirectory);
+        try {
+            // Have the ACVM write the partial witness here
+            const outputWitnessFile = `${bbWorkingDirectory}/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 timer = new Timer();
+            const outputWitness = await simulator.simulateCircuit(witnessMap, artifact);
+            emitCircuitWitnessGenerationStats(circuitTypeToCircuitName(circuitType), timer.ms(), witnessMap.size * Fr.SIZE_IN_BYTES, outputWitness.size * Fr.SIZE_IN_BYTES, logger);
+            const outputType = convertOutput(outputWitness);
+            // Now prove the circuit from the generated witness
+            logger.debug(`Proving ${circuitType}...`);
+            const provingResult = await generateProof(this.config.bbBinaryPath, bbWorkingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), outputWitnessFile, logger.debug);
+            if (provingResult.status === BB_RESULT.FAILURE) {
+                logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
+                throw new Error(provingResult.reason);
+            }
+            // Ensure our vk cache is up to date
+            await this.updateVerificationKeyAfterProof(provingResult.vkPath, circuitType);
+            // Read the proof and then cleanup up our temporary directory
+            const proof = await this.readProofAsFields(provingResult.proofPath, circuitType);
+            logger.info(`Generated proof for ${circuitType} in ${provingResult.duration} ms, size: ${proof.proof.length} fields`);
+            emitCircuitProvingStats(circuitTypeToCircuitName(circuitType), provingResult.duration, witnessMap.size * Fr.SIZE_IN_BYTES, outputWitness.size * Fr.SIZE_IN_BYTES, proof.binaryProof.buffer.length, logger);
+            return [outputType, proof];
+        }
+        finally {
+            await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
+        }
+    }
+    /**
+     * 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.config.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);
+        logger.debug(`Verifying with key: ${verificationKey.hash.toString()}`);
+        await fs.writeFile(proofFileName, proof.buffer);
+        await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+        const logFunction = (message) => {
+            logger.debug(`${circuitType} BB out - ${message}`);
+        };
+        const result = await verifyProof(this.config.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);
+        }
+        logger.info(`Successfully verified ${circuitType} proof in ${result.duration} ms`);
+    }
+    /**
+     * Returns the verification key for a circuit, will generate it if not cached internally
+     * @param circuitType - The type of circuit for which the verification key is required
+     * @returns The verification key
+     */
+    async getVerificationKeyForCircuit(circuitType) {
+        const vkData = await this.getVerificationKeyDataForCircuit(circuitType);
+        return new VerificationKeyAsFields(vkData.keyAsFields, vkData.hash);
+    }
+    async verifyPreviousRollupProof(previousRollupData) {
+        const proof = previousRollupData.proof;
+        const circuitType = previousRollupData.baseOrMergeRollupPublicInputs.rollupType === RollupTypes.Base
+            ? 'BaseRollupArtifact'
+            : 'MergeRollupArtifact';
+        await this.verifyProof(circuitType, proof);
+    }
+    /**
+     * 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.config.bbBinaryPath, this.config.bbWorkingDirectory, circuitType, ServerCircuitArtifacts[circuitType], 'vk', logger.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.verificationKeys.set(circuitType, promise);
+        }
+        await promise;
+    }
+    /**
+     * Parses and returns the proof data stored at the specified directory
+     * @param filePath - The directory containing the proof data
+     * @param circuitType - The type of circuit proven
+     * @returns The proof
+     */
+    async readProofAsFields(filePath, circuitType) {
+        const [binaryProof, proofString] = await Promise.all([
+            fs.readFile(`${filePath}/${PROOF_FILENAME}`),
+            fs.readFile(`${filePath}/${PROOF_FIELDS_FILENAME}`, { encoding: 'utf-8' }),
+        ]);
+        const json = JSON.parse(proofString);
+        const fields = json.map(Fr.fromString);
+        const vkData = await this.verificationKeys.get(circuitType);
+        if (!vkData) {
+            throw new Error(`Invalid verification key for ${circuitType}`);
+        }
+        const numPublicInputs = CIRCUITS_WITHOUT_AGGREGATION.has(circuitType)
+            ? vkData.numPublicInputs
+            : vkData.numPublicInputs - AGGREGATION_OBJECT_SIZE;
+        const fieldsWithoutPublicInputs = fields.slice(numPublicInputs);
+        logger.debug(`Circuit type: ${circuitType}, complete proof length: ${fields.length}, without public inputs: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`);
+        const proof = new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProof));
+        return proof;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bb_prover.js","sourceRoot":"","sources":["../../src/prover/bb_prover.ts"],"names":[],"mappings":"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"}

package/dest/prover/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bb_prover.js';
+export * from './bb_native_proof_creator.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prover/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC"}

package/dest/prover/index.js

@@ -0,0 +1,3 @@
+export * from './bb_prover.js';
+export * from './bb_native_proof_creator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyw4QkFBOEIsQ0FBQyJ9

package/dest/prover/verification_key_data.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type Fr, type VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/circuits.js';
+import { type Tuple } from '@aztec/foundation/serialize';
+export declare const AGGREGATION_OBJECT_SIZE = 16;
+export declare const CIRCUIT_SIZE_INDEX = 3;
+export declare const CIRCUIT_PUBLIC_INPUTS_INDEX = 4;
+export declare const CIRCUIT_RECURSIVE_INDEX = 5;
+export type VerificationKeyData = {
+    hash: Fr;
+    keyAsFields: Tuple<Fr, typeof VERIFICATION_KEY_LENGTH_IN_FIELDS>;
+    keyAsBytes: Buffer;
+    numPublicInputs: number;
+    circuitSize: number;
+    isRecursive: boolean;
+};
+//# sourceMappingURL=verification_key_data.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verification_key_data.d.ts","sourceRoot":"","sources":["../../src/prover/verification_key_data.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AACrF,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAC7C,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,EAAE,CAAC;IACT,WAAW,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,iCAAiC,CAAC,CAAC;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC"}

package/dest/prover/verification_key_data.js

@@ -0,0 +1,5 @@
+export const AGGREGATION_OBJECT_SIZE = 16;
+export const CIRCUIT_SIZE_INDEX = 3;
+export const CIRCUIT_PUBLIC_INPUTS_INDEX = 4;
+export const CIRCUIT_RECURSIVE_INDEX = 5;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyaWZpY2F0aW9uX2tleV9kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3Zlci92ZXJpZmljYXRpb25fa2V5X2RhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsRUFBRSxDQUFDO0FBQzFDLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLENBQUMsQ0FBQztBQUNwQyxNQUFNLENBQUMsTUFBTSwyQkFBMkIsR0FBRyxDQUFDLENBQUM7QUFDN0MsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsQ0FBQyxDQUFDIn0=

package/dest/stats.d.ts

@@ -0,0 +1,9 @@
+import { type PublicKernelRequest } from '@aztec/circuit-types';
+import type { CircuitName } from '@aztec/circuit-types/stats';
+import { type Logger } from '@aztec/foundation/log';
+import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+export declare function emitCircuitWitnessGenerationStats(circuitName: CircuitName, duration: number, inputSize: number, outputSize: number, logger: Logger): void;
+export declare function emitCircuitProvingStats(circuitName: CircuitName, duration: number, inputSize: number, outputSize: number, proofSize: number, logger: Logger): void;
+export declare function mapPublicKernelToCircuitName(kernelType: PublicKernelRequest['type']): CircuitName;
+export declare function circuitTypeToCircuitName(circuitType: ServerProtocolArtifact): CircuitName;
+//# sourceMappingURL=stats.d.ts.map

package/dest/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../src/stats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAoB,MAAM,sBAAsB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAsD,MAAM,4BAA4B,CAAC;AAClH,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAElF,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,QAWf;AAED,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,QAYf;AAED,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,mBAAmB,CAAC,MAAM,CAAC,GAAG,WAAW,CAajG;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,sBAAsB,GAAG,WAAW,CAuBzF"}

package/dest/stats.js

@@ -0,0 +1,61 @@
+import { PublicKernelType } from '@aztec/circuit-types';
+export function emitCircuitWitnessGenerationStats(circuitName, duration, inputSize, outputSize, logger) {
+    const stats = {
+        eventName: 'circuit-witness-generation',
+        circuitName,
+        inputSize,
+        outputSize,
+        duration,
+    };
+    logger.debug('Circuit witness generation stats', stats);
+}
+export function emitCircuitProvingStats(circuitName, duration, inputSize, outputSize, proofSize, logger) {
+    const stats = {
+        eventName: 'circuit-proving',
+        circuitName,
+        duration,
+        inputSize,
+        outputSize,
+        proofSize,
+    };
+    logger.debug('Circuit proving stats', stats);
+}
+export function mapPublicKernelToCircuitName(kernelType) {
+    switch (kernelType) {
+        case PublicKernelType.SETUP:
+            return 'public-kernel-setup';
+        case PublicKernelType.APP_LOGIC:
+            return 'public-kernel-app-logic';
+        case PublicKernelType.TEARDOWN:
+            return 'public-kernel-teardown';
+        case PublicKernelType.TAIL:
+            return 'public-kernel-tail';
+        default:
+            throw new Error(`Unknown kernel type: ${kernelType}`);
+    }
+}
+export function circuitTypeToCircuitName(circuitType) {
+    switch (circuitType) {
+        case 'BaseParityArtifact':
+            return 'base-parity';
+        case 'RootParityArtifact':
+            return 'root-parity';
+        case 'BaseRollupArtifact':
+            return 'base-rollup';
+        case 'MergeRollupArtifact':
+            return 'merge-rollup';
+        case 'RootRollupArtifact':
+            return 'root-rollup';
+        case 'PublicKernelSetupArtifact':
+            return 'public-kernel-setup';
+        case 'PublicKernelAppLogicArtifact':
+            return 'public-kernel-app-logic';
+        case 'PublicKernelTeardownArtifact':
+            return 'public-kernel-teardown';
+        case 'PublicKernelTailArtifact':
+            return 'public-kernel-tail';
+        default:
+            throw new Error(`Unknown circuit type: ${circuitType}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvc3RhdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUE0QixnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBS2xGLE1BQU0sVUFBVSxpQ0FBaUMsQ0FDL0MsV0FBd0IsRUFDeEIsUUFBZ0IsRUFDaEIsU0FBaUIsRUFDakIsVUFBa0IsRUFDbEIsTUFBYztJQUVkLE1BQU0sS0FBSyxHQUFrQztRQUMzQyxTQUFTLEVBQUUsNEJBQTRCO1FBQ3ZDLFdBQVc7UUFDWCxTQUFTO1FBQ1QsVUFBVTtRQUNWLFFBQVE7S0FDVCxDQUFDO0lBRUYsTUFBTSxDQUFDLEtBQUssQ0FBQyxrQ0FBa0MsRUFBRSxLQUFLLENBQUMsQ0FBQztBQUMxRCxDQUFDO0FBRUQsTUFBTSxVQUFVLHVCQUF1QixDQUNyQyxXQUF3QixFQUN4QixRQUFnQixFQUNoQixTQUFpQixFQUNqQixVQUFrQixFQUNsQixTQUFpQixFQUNqQixNQUFjO0lBRWQsTUFBTSxLQUFLLEdBQXdCO1FBQ2pDLFNBQVMsRUFBRSxpQkFBaUI7UUFDNUIsV0FBVztRQUNYLFFBQVE7UUFDUixTQUFTO1FBQ1QsVUFBVTtRQUNWLFNBQVM7S0FDVixDQUFDO0lBRUYsTUFBTSxDQUFDLEtBQUssQ0FBQyx1QkFBdUIsRUFBRSxLQUFLLENBQUMsQ0FBQztBQUMvQyxDQUFDO0FBRUQsTUFBTSxVQUFVLDRCQUE0QixDQUFDLFVBQXVDO0lBQ2xGLFFBQVEsVUFBVSxFQUFFLENBQUM7UUFDbkIsS0FBSyxnQkFBZ0IsQ0FBQyxLQUFLO1lBQ3pCLE9BQU8scUJBQXFCLENBQUM7UUFDL0IsS0FBSyxnQkFBZ0IsQ0FBQyxTQUFTO1lBQzdCLE9BQU8seUJBQXlCLENBQUM7UUFDbkMsS0FBSyxnQkFBZ0IsQ0FBQyxRQUFRO1lBQzVCLE9BQU8sd0JBQXdCLENBQUM7UUFDbEMsS0FBSyxnQkFBZ0IsQ0FBQyxJQUFJO1lBQ3hCLE9BQU8sb0JBQW9CLENBQUM7UUFDOUI7WUFDRSxNQUFNLElBQUksS0FBSyxDQUFDLHdCQUF3QixVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQzFELENBQUM7QUFDSCxDQUFDO0FBRUQsTUFBTSxVQUFVLHdCQUF3QixDQUFDLFdBQW1DO0lBQzFFLFFBQVEsV0FBVyxFQUFFLENBQUM7UUFDcEIsS0FBSyxvQkFBb0I7WUFDdkIsT0FBTyxhQUFhLENBQUM7UUFDdkIsS0FBSyxvQkFBb0I7WUFDdkIsT0FBTyxhQUFhLENBQUM7UUFDdkIsS0FBSyxvQkFBb0I7WUFDdkIsT0FBTyxhQUFhLENBQUM7UUFDdkIsS0FBSyxxQkFBcUI7WUFDeEIsT0FBTyxjQUFjLENBQUM7UUFDeEIsS0FBSyxvQkFBb0I7WUFDdkIsT0FBTyxhQUFhLENBQUM7UUFDdkIsS0FBSywyQkFBMkI7WUFDOUIsT0FBTyxxQkFBcUIsQ0FBQztRQUMvQixLQUFLLDhCQUE4QjtZQUNqQyxPQUFPLHlCQUF5QixDQUFDO1FBQ25DLEtBQUssOEJBQThCO1lBQ2pDLE9BQU8sd0JBQXdCLENBQUM7UUFDbEMsS0FBSywwQkFBMEI7WUFDN0IsT0FBTyxvQkFBb0IsQ0FBQztRQUM5QjtZQUNFLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLFdBQVcsRUFBRSxDQUFDLENBQUM7SUFDNUQsQ0FBQztBQUNILENBQUMifQ==

package/dest/test/index.d.ts

@@ -0,0 +1,2 @@
+export * from './test_circuit_prover.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/dest/test/index.js

@@ -0,0 +1,2 @@
+export * from './test_circuit_prover.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDIn0=

package/dest/test/test_circuit_prover.d.ts

@@ -0,0 +1,48 @@
+import { type PublicInputsAndProof, type PublicKernelNonTailRequest, type PublicKernelTailRequest, type ServerCircuitProver } from '@aztec/circuit-types';
+import { type BaseOrMergeRollupPublicInputs, type BaseParityInputs, type BaseRollupInputs, type KernelCircuitPublicInputs, type MergeRollupInputs, NESTED_RECURSIVE_PROOF_LENGTH, type Proof, type PublicKernelCircuitPublicInputs, RECURSIVE_PROOF_LENGTH, RootParityInput, type RootParityInputs, type RootRollupInputs, type RootRollupPublicInputs } from '@aztec/circuits.js';
+import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+import { type SimulationProvider } from '@aztec/simulator';
+/**
+ * A class for use in testing situations (e2e, unit test etc)
+ * Simulates circuits using the most efficient method and performs no proving
+ */
+export declare class TestCircuitProver implements ServerCircuitProver {
+    private simulationProvider?;
+    private logger;
+    private wasmSimulator;
+    constructor(simulationProvider?: SimulationProvider | undefined, logger?: import("@aztec/foundation/log").Logger);
+    /**
+     * Simulates the base parity circuit from its inputs.
+     * @param inputs - Inputs to the circuit.
+     * @returns The public inputs of the parity circuit.
+     */
+    getBaseParityProof(inputs: BaseParityInputs): Promise<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>>;
+    /**
+     * Simulates the root parity circuit from its inputs.
+     * @param inputs - Inputs to the circuit.
+     * @returns The public inputs of the parity circuit.
+     */
+    getRootParityProof(inputs: RootParityInputs): Promise<RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
+    /**
+     * Simulates the base rollup circuit from its inputs.
+     * @param input - Inputs to the circuit.
+     * @returns The public inputs as outputs of the simulation.
+     */
+    getBaseRollupProof(input: BaseRollupInputs): Promise<PublicInputsAndProof<BaseOrMergeRollupPublicInputs>>;
+    /**
+     * Simulates the merge rollup circuit from its inputs.
+     * @param input - Inputs to the circuit.
+     * @returns The public inputs as outputs of the simulation.
+     */
+    getMergeRollupProof(input: MergeRollupInputs): Promise<PublicInputsAndProof<BaseOrMergeRollupPublicInputs>>;
+    /**
+     * Simulates the root rollup circuit from its inputs.
+     * @param input - Inputs to the circuit.
+     * @returns The public inputs as outputs of the simulation.
+     */
+    getRootRollupProof(input: RootRollupInputs): Promise<PublicInputsAndProof<RootRollupPublicInputs>>;
+    getPublicKernelProof(kernelRequest: PublicKernelNonTailRequest): Promise<PublicInputsAndProof<PublicKernelCircuitPublicInputs>>;
+    getPublicTailProof(kernelRequest: PublicKernelTailRequest): Promise<PublicInputsAndProof<KernelCircuitPublicInputs>>;
+    verifyProof(_1: ServerProtocolArtifact, _2: Proof): Promise<void>;
+}
+//# sourceMappingURL=test_circuit_prover.d.ts.map

package/dest/test/test_circuit_prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_circuit_prover.d.ts","sourceRoot":"","sources":["../../src/test/test_circuit_prover.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAE5B,KAAK,mBAAmB,EAEzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,EAC9B,KAAK,iBAAiB,EACtB,6BAA6B,EAC7B,KAAK,KAAK,EACV,KAAK,+BAA+B,EACpC,sBAAsB,EACtB,eAAe,EACf,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAI5B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAML,KAAK,sBAAsB,EAc5B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,KAAK,kBAAkB,EAA6C,MAAM,kBAAkB,CAAC;AAiBtG;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,mBAAmB;IAIzD,OAAO,CAAC,kBAAkB,CAAC;IAC3B,OAAO,CAAC,MAAM;IAJhB,OAAO,CAAC,aAAa,CAAuB;gBAGlC,kBAAkB,CAAC,gCAAoB,EACvC,MAAM,yCAAyC;IAGzD;;;;OAIG;IACU,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,sBAAsB,CAAC,CAAC;IAyBlH;;;;OAIG;IACU,kBAAkB,CAC7B,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,eAAe,CAAC,OAAO,6BAA6B,CAAC,CAAC;IA0BjE;;;;OAIG;IACU,kBAAkB,CAC7B,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,oBAAoB,CAAC,6BAA6B,CAAC,CAAC;IAkB/D;;;;OAIG;IACU,mBAAmB,CAC9B,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,oBAAoB,CAAC,6BAA6B,CAAC,CAAC;IAmB/D;;;;OAIG;IACU,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;IAmBlG,oBAAoB,CAC/B,aAAa,EAAE,0BAA0B,GACxC,OAAO,CAAC,oBAAoB,CAAC,+BAA+B,CAAC,CAAC;IAsBpD,kBAAkB,CAC7B,aAAa,EAAE,uBAAuB,GACrC,OAAO,CAAC,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;IAsBpD,WAAW,CAAC,EAAE,EAAE,sBAAsB,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;CAGzE"}