@aztec/bb-prover 0.39.0

package/dest/prover/bb_native_proof_creator.js

@@ -0,0 +1,238 @@
+import { Fr, NESTED_RECURSIVE_PROOF_LENGTH, Proof, RECURSIVE_PROOF_LENGTH, RecursiveProof, VerificationKeyAsFields, } from '@aztec/circuits.js';
+import { siloNoteHash } from '@aztec/circuits.js/hash';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { ClientCircuitArtifacts, convertPrivateKernelInitInputsToWitnessMap, convertPrivateKernelInitOutputsFromWitnessMap, convertPrivateKernelInnerInputsToWitnessMap, convertPrivateKernelInnerOutputsFromWitnessMap, convertPrivateKernelTailForPublicOutputsFromWitnessMap, convertPrivateKernelTailInputsToWitnessMap, convertPrivateKernelTailOutputsFromWitnessMap, convertPrivateKernelTailToPublicInputsToWitnessMap, } from '@aztec/noir-protocol-circuits-types';
+import { WASMSimulator } from '@aztec/simulator';
+import { serializeWitness } from '@noir-lang/noirc_abi';
+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 { AGGREGATION_OBJECT_SIZE, CIRCUIT_PUBLIC_INPUTS_INDEX, CIRCUIT_RECURSIVE_INDEX, CIRCUIT_SIZE_INDEX, } from './verification_key_data.js';
+const PrivateKernelArtifactMapping = {
+    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');
+        }
+        const witnessMap = convertPrivateKernelTailToPublicInputsToWitnessMap(inputs);
+        return await this.createSafeProof(witnessMap, 'PrivateKernelTailToPublicArtifact');
+    }
+    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 proofOutput = await this.createProof(directory, partialWitness, bytecode, 'App');
+            if (proofOutput.proof.proof.length != RECURSIVE_PROOF_LENGTH) {
+                throw new Error(`Incorrect proof length`);
+            }
+            const proof = proofOutput.proof;
+            const output = {
+                proof,
+                verificationKey: proofOutput.verificationKey,
+            };
+            return output;
+        }
+        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 verifyProofForProtocolCircuit(circuitType, proof) {
+        const verificationKey = await this.getVerificationKeyDataForCircuit(circuitType);
+        this.log.debug(`Verifying with key: ${verificationKey.hash.toString()}`);
+        const logFunction = (message) => {
+            this.log.debug(`${circuitType} BB out - ${message}`);
+        };
+        const result = await this.verifyProofFromKey(verificationKey.keyAsBytes, proof, logFunction);
+        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`);
+    }
+    async verifyProofFromKey(verificationKey, proof, logFunction = () => { }) {
+        // 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`;
+        await fs.writeFile(proofFileName, proof.buffer);
+        await fs.writeFile(verificationKeyPath, verificationKey);
+        try {
+            return await verifyProof(this.bbBinaryPath, proofFileName, verificationKeyPath, logFunction);
+        }
+        finally {
+            await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
+        }
+    }
+    /**
+     * 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);
+        }
+        return 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 = PrivateKernelArtifactMapping[circuitType].convertOutputs(outputWitness);
+        const proofOutput = await this.createProof(directory, outputWitness, Buffer.from(compiledCircuit.bytecode, 'base64'), circuitType);
+        if (proofOutput.proof.proof.length != NESTED_RECURSIVE_PROOF_LENGTH) {
+            throw new Error(`Incorrect proof length`);
+        }
+        const nestedProof = proofOutput.proof;
+        const kernelOutput = {
+            publicInputs,
+            proof: nestedProof,
+            verificationKey: proofOutput.verificationKey,
+        };
+        return kernelOutput;
+    }
+    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') {
+            const vkData = await this.convertVk(directory);
+            const proof = await this.readProofAsFields(directory, circuitType, vkData);
+            return { proof, verificationKey: new VerificationKeyAsFields(vkData.keyAsFields, vkData.hash) };
+        }
+        const vkData = await this.updateVerificationKeyAfterProof(directory, circuitType);
+        const proof = await this.readProofAsFields(directory, circuitType, vkData);
+        return { proof, verificationKey: new VerificationKeyAsFields(vkData.keyAsFields, vkData.hash) };
+    }
+    /**
+     * 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, vkData) {
+        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 numPublicInputs = circuitType === 'App' ? vkData.numPublicInputs : vkData.numPublicInputs - AGGREGATION_OBJECT_SIZE;
+        const fieldsWithoutPublicInputs = fields.slice(numPublicInputs);
+        this.log.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_native_proof_creator.js","sourceRoot":"","sources":["../../src/prover/bb_native_proof_creator.ts"],"names":[],"mappings":"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"}

package/dest/prover/bb_prover.d.ts

@@ -0,0 +1,110 @@
+import { type PublicInputsAndProof, type PublicKernelNonTailRequest, type PublicKernelTailRequest, type ServerCircuitProver } from '@aztec/circuit-types';
+import { type BaseOrMergeRollupPublicInputs, type BaseParityInputs, type BaseRollupInputs, type KernelCircuitPublicInputs, type MergeRollupInputs, type NESTED_RECURSIVE_PROOF_LENGTH, Proof, type PublicKernelCircuitPublicInputs, type RECURSIVE_PROOF_LENGTH, RecursiveProof, RootParityInput, type RootParityInputs, type RootRollupInputs, type RootRollupPublicInputs, VerificationKeyAsFields } from '@aztec/circuits.js';
+import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+import { type WitnessMap } from '@noir-lang/types';
+export type BBProverConfig = {
+    bbBinaryPath: string;
+    bbWorkingDirectory: string;
+    acvmBinaryPath: string;
+    acvmWorkingDirectory: string;
+    circuitFilter?: ServerProtocolArtifact[];
+};
+/**
+ * Prover implementation that uses barretenberg native proving
+ */
+export declare class BBNativeRollupProver implements ServerCircuitProver {
+    private config;
+    private verificationKeys;
+    constructor(config: BBProverConfig);
+    static new(config: BBProverConfig): Promise<BBNativeRollupProver>;
+    /**
+     * 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>>;
+    /**
+     * 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
+     */
+    getPublicKernelProof(kernelRequest: PublicKernelNonTailRequest): Promise<PublicInputsAndProof<PublicKernelCircuitPublicInputs>>;
+    /**
+     * 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
+     */
+    getPublicTailProof(kernelRequest: PublicKernelTailRequest): Promise<PublicInputsAndProof<KernelCircuitPublicInputs>>;
+    /**
+     * 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>>;
+    createProof(witnessMap: WitnessMap, circuitType: ServerProtocolArtifact): Promise<[WitnessMap, 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
+     */
+    createRecursiveProof<PROOF_LENGTH extends number, CircuitOutputType>(witnessMap: WitnessMap, circuitType: ServerProtocolArtifact, convertOutput: (outputWitness: WitnessMap) => CircuitOutputType): Promise<[CircuitOutputType, RecursiveProof<PROOF_LENGTH>]>;
+    /**
+     * 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
+     */
+    verifyProof(circuitType: ServerProtocolArtifact, proof: Proof): Promise<void>;
+    /**
+     * 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
+     */
+    getVerificationKeyForCircuit(circuitType: ServerProtocolArtifact): Promise<VerificationKeyAsFields>;
+    private verifyPreviousRollupProof;
+    /**
+     * 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
+     */
+    private getVerificationKeyDataForCircuit;
+    /**
+     * 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
+     */
+    private convertVk;
+    /**
+     * 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
+     */
+    private updateVerificationKeyAfterProof;
+    /**
+     * 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
+     */
+    private readProofAsFields;
+}
+//# sourceMappingURL=bb_prover.d.ts.map

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

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