@aztec/bb-prover 0.66.0 → 0.67.1-devnet

package/src/test/test_circuit_prover.ts

@@ -35,7 +35,7 @@ import {
   makeEmptyRecursiveProof,
   makeRecursiveProof,
 } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
 import {
@@ -46,8 +46,6 @@ import {
   convertBaseParityOutputsFromWitnessMap,
   convertBlockMergeRollupInputsToWitnessMap,
   convertBlockMergeRollupOutputsFromWitnessMap,
-  convertBlockRootRollupInputsToWitnessMap,
-  convertBlockRootRollupOutputsFromWitnessMap,
   convertEmptyBlockRootRollupInputsToWitnessMap,
   convertEmptyBlockRootRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
@@ -57,6 +55,8 @@ import {
   convertRootParityOutputsFromWitnessMap,
   convertRootRollupInputsToWitnessMap,
   convertRootRollupOutputsFromWitnessMap,
+  convertSimulatedBlockRootRollupInputsToWitnessMap,
+  convertSimulatedBlockRootRollupOutputsFromWitnessMap,
   convertSimulatedPrivateBaseRollupInputsToWitnessMap,
   convertSimulatedPrivateBaseRollupOutputsFromWitnessMap,
   convertSimulatedPrivateKernelEmptyOutputsFromWitnessMap,
@@ -78,7 +78,7 @@ import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 export class TestCircuitProver implements ServerCircuitProver {
   private wasmSimulator = new WASMSimulator();
   private instrumentation: ProverInstrumentation;
-  private logger = createDebugLogger('aztec:test-prover');
+  private logger = createLogger('bb-prover:test-prover');
 
   constructor(
     telemetry: TelemetryClient,
@@ -215,8 +215,8 @@ export class TestCircuitProver implements ServerCircuitProver {
       input,
       'BlockRootRollupArtifact',
       NESTED_RECURSIVE_PROOF_LENGTH,
-      convertBlockRootRollupInputsToWitnessMap,
-      convertBlockRootRollupOutputsFromWitnessMap,
+      convertSimulatedBlockRootRollupInputsToWitnessMap,
+      convertSimulatedBlockRootRollupOutputsFromWitnessMap,
     );
   }
 
@@ -313,7 +313,12 @@ export class TestCircuitProver implements ServerCircuitProver {
     const witnessMap = convertInput(input);
     const circuitName = mapProtocolArtifactNameToCircuitName(artifactName);
 
-    const simulationProvider = this.simulationProvider ?? this.wasmSimulator;
+    let simulationProvider = this.simulationProvider ?? this.wasmSimulator;
+    if (artifactName == 'BlockRootRollupArtifact') {
+      // TODO(#10323): temporarily force block root to use wasm while we simulate
+      // the blob operations with an oracle. Appears to be no way to provide nativeACVM with a foreign call hander.
+      simulationProvider = this.wasmSimulator;
+    }
     const witness = await simulationProvider.simulateCircuit(witnessMap, SimulatedServerCircuitArtifacts[artifactName]);
 
     const result = convertOutput(witness);

package/src/verification_key/verification_key_data.ts

@@ -7,7 +7,7 @@ import {
 import { hashVK } from '@aztec/circuits.js/hash';
 
 import { strict as assert } from 'assert';
-import * as fs from 'fs/promises';
+import { promises as fs } from 'fs';
 import * as path from 'path';
 
 import { VK_FIELDS_FILENAME, VK_FILENAME } from '../bb/execute.js';
@@ -23,7 +23,7 @@ export async function extractVkData(vkDirectoryPath: string): Promise<Verificati
     fs.readFile(path.join(vkDirectoryPath, VK_FILENAME)),
   ]);
   const fieldsJson = JSON.parse(rawFields);
-  const fields = fieldsJson.map(Fr.fromString);
+  const fields = fieldsJson.map(Fr.fromHexString);
   // The hash is not included in the BB response
   const vkHash = hashVK(fields);
   const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
@@ -37,7 +37,7 @@ export async function extractAvmVkData(vkDirectoryPath: string): Promise<Verific
     fs.readFile(path.join(vkDirectoryPath, VK_FILENAME)),
   ]);
   const fieldsJson = JSON.parse(rawFields);
-  const fields = fieldsJson.map(Fr.fromString);
+  const fields = fieldsJson.map(Fr.fromHexString);
   // The first item is the hash, this is not part of the actual VK
   // TODO: is the above actually the case?
   const vkHash = fields[0];

package/src/verifier/bb_verifier.ts

@@ -2,14 +2,14 @@ import { type ClientProtocolCircuitVerifier, Tx } from '@aztec/circuit-types';
 import { type CircuitVerificationStats } from '@aztec/circuit-types/stats';
 import { type Proof, type VerificationKeyData } from '@aztec/circuits.js';
 import { runInDirectory } from '@aztec/foundation/fs';
-import { type DebugLogger, type LogFn, createDebugLogger } from '@aztec/foundation/log';
+import { type LogFn, type Logger, createLogger } from '@aztec/foundation/log';
 import {
   type ClientProtocolArtifact,
   type ProtocolArtifact,
   ProtocolCircuitArtifacts,
 } from '@aztec/noir-protocol-circuits-types';
 
-import * as fs from 'fs/promises';
+import { promises as fs } from 'fs';
 import * as path from 'path';
 
 import {
@@ -23,6 +23,7 @@ import {
 } from '../bb/execute.js';
 import { type BBConfig } from '../config.js';
 import { type UltraKeccakHonkProtocolArtifact, getUltraHonkFlavorForCircuit } from '../honk.js';
+import { writeToOutputDirectory } from '../prover/client_ivc_proof_utils.js';
 import { isProtocolArtifactRecursive, mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
 
@@ -30,13 +31,13 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
   private constructor(
     private config: BBConfig,
     private verificationKeys = new Map<ProtocolArtifact, Promise<VerificationKeyData>>(),
-    private logger: DebugLogger,
+    private logger: Logger,
   ) {}
 
   public static async new(
     config: BBConfig,
     initialCircuits: ProtocolArtifact[] = [],
-    logger = createDebugLogger('aztec:bb-verifier'),
+    logger = createLogger('bb-prover:verifier'),
   ) {
     await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
     const keys = new Map<ProtocolArtifact, Promise<VerificationKeyData>>();
@@ -162,7 +163,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
           this.logger.debug(`${circuit} BB out - ${message}`);
         };
 
-        await tx.clientIvcProof.writeToOutputDirectory(bbWorkingDirectory);
+        await writeToOutputDirectory(tx.clientIvcProof, bbWorkingDirectory);
         const result = await verifyClientIvcProof(this.config.bbBinaryPath, bbWorkingDirectory, logFunction);
 
         if (result.status === BB_RESULT.FAILURE) {

package/src/wasm/index.ts

@@ -0,0 +1,155 @@
+import { AztecClientBackend } from '@aztec/bb.js';
+import { type PrivateKernelProver, type PrivateKernelSimulateOutput } from '@aztec/circuit-types';
+import {
+  ClientIvcProof,
+  type PrivateKernelCircuitPublicInputs,
+  type PrivateKernelInitCircuitPrivateInputs,
+  type PrivateKernelInnerCircuitPrivateInputs,
+  type PrivateKernelResetCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPublicInputs,
+} from '@aztec/circuits.js';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import {
+  ClientCircuitArtifacts,
+  ClientCircuitVks,
+  type ClientProtocolArtifact,
+  convertPrivateKernelInitInputsToWitnessMap,
+  convertPrivateKernelInitOutputsFromWitnessMap,
+  convertPrivateKernelInnerInputsToWitnessMap,
+  convertPrivateKernelInnerOutputsFromWitnessMap,
+  convertPrivateKernelResetInputsToWitnessMap,
+  convertPrivateKernelResetOutputsFromWitnessMap,
+  convertPrivateKernelTailForPublicOutputsFromWitnessMap,
+  convertPrivateKernelTailInputsToWitnessMap,
+  convertPrivateKernelTailOutputsFromWitnessMap,
+  convertPrivateKernelTailToPublicInputsToWitnessMap,
+  getPrivateKernelResetArtifactName,
+} from '@aztec/noir-protocol-circuits-types/client';
+import { WASMSimulator } from '@aztec/simulator/client';
+import { type NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { type WitnessMap } from '@noir-lang/noir_js';
+import { serializeWitness } from '@noir-lang/noirc_abi';
+import { ungzip } from 'pako';
+
+export class BBWasmPrivateKernelProver implements PrivateKernelProver {
+  private simulator = new WASMSimulator();
+
+  constructor(private threads: number = 1, private log = createLogger('bb-prover:wasm')) {}
+
+  public async simulateProofInit(
+    inputs: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulate(
+      inputs,
+      'PrivateKernelInitArtifact',
+      convertPrivateKernelInitInputsToWitnessMap,
+      convertPrivateKernelInitOutputsFromWitnessMap,
+    );
+  }
+
+  public async simulateProofInner(
+    inputs: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulate(
+      inputs,
+      'PrivateKernelInnerArtifact',
+      convertPrivateKernelInnerInputsToWitnessMap,
+      convertPrivateKernelInnerOutputsFromWitnessMap,
+    );
+  }
+
+  public async simulateProofReset(
+    inputs: PrivateKernelResetCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    const variantInputs = inputs.trimToSizes();
+    const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
+    return await this.simulate(
+      variantInputs,
+      artifactName,
+      variantInputs => convertPrivateKernelResetInputsToWitnessMap(variantInputs, artifactName),
+      output => convertPrivateKernelResetOutputsFromWitnessMap(output, artifactName),
+    );
+  }
+
+  public async simulateProofTail(
+    inputs: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (!inputs.isForPublic()) {
+      return await this.simulate(
+        inputs,
+        'PrivateKernelTailArtifact',
+        convertPrivateKernelTailInputsToWitnessMap,
+        convertPrivateKernelTailOutputsFromWitnessMap,
+      );
+    }
+    return await this.simulate(
+      inputs,
+      'PrivateKernelTailToPublicArtifact',
+      convertPrivateKernelTailToPublicInputsToWitnessMap,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMap,
+    );
+  }
+
+  private async simulate<
+    I extends { toBuffer: () => Buffer },
+    O extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
+  >(
+    inputs: I,
+    circuitType: ClientProtocolArtifact,
+    convertInputs: (inputs: I) => WitnessMap,
+    convertOutputs: (outputs: WitnessMap) => O,
+  ): Promise<PrivateKernelSimulateOutput<O>> {
+    this.log.debug(`Generating witness for ${circuitType}`);
+    const compiledCircuit: NoirCompiledCircuit = ClientCircuitArtifacts[circuitType];
+
+    const witnessMap = convertInputs(inputs);
+    const timer = new Timer();
+    const outputWitness = await this.simulator.simulateCircuit(witnessMap, compiledCircuit);
+    const output = convertOutputs(outputWitness);
+
+    this.log.debug(`Generated witness for ${circuitType}`, {
+      eventName: 'circuit-witness-generation',
+      circuitName: circuitType,
+      duration: timer.ms(),
+      inputSize: inputs.toBuffer().length,
+      outputSize: output.toBuffer().length,
+    });
+
+    const verificationKey = ClientCircuitVks[circuitType].keyAsFields;
+    const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+
+    const kernelOutput: PrivateKernelSimulateOutput<O> = {
+      publicInputs: output,
+      verificationKey,
+      outputWitness,
+      bytecode,
+    };
+    return kernelOutput;
+  }
+
+  async createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+    const timer = new Timer();
+    this.log.info(`Generating ClientIVC proof...`);
+    const backend = new AztecClientBackend(
+      acirs.map(acir => ungzip(acir)),
+      { threads: this.threads },
+    );
+
+    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));
+  }
+
+  computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number> {
+    return Promise.resolve(0);
+  }
+}