@aztec/bb-prover 0.48.0 → 0.50.1

package/src/bb/execute.ts

@@ -811,7 +811,7 @@ export async function generateContractForVerificationKey(
     try {
       const args = ['-k', vkFilePath, '-o', contractPath, '-v'];
       const timer = new Timer();
-      const result = await executeBB(pathToBB, 'contract', args, log);
+      const result = await executeBB(pathToBB, 'contract_ultra_honk', args, log);
       const duration = timer.ms();
       if (result.status == BB_RESULT.SUCCESS) {
         return { status: BB_RESULT.SUCCESS, durationMs: duration, contractPath };

package/src/config.ts

@@ -1,6 +1,8 @@
 export interface BBConfig {
   bbBinaryPath: string;
   bbWorkingDirectory: string;
+  /** Whether to skip tmp dir cleanup for debugging purposes */
+  bbSkipCleanup?: boolean;
 }
 
 export interface ACVMConfig {

package/src/index.ts

@@ -2,3 +2,4 @@ export * from './prover/index.js';
 export * from './test/index.js';
 export * from './verifier/index.js';
 export * from './config.js';
+export * from './bb/execute.js';

package/src/prover/bb_private_kernel_prover.ts

@@ -22,7 +22,7 @@ import {
 } from '@aztec/circuits.js';
 import { siloNoteHash } from '@aztec/circuits.js/hash';
 import { runInDirectory } from '@aztec/foundation/fs';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import {
   ClientCircuitArtifacts,
@@ -57,6 +57,7 @@ import {
   executeBbClientIvcProof,
   verifyProof,
 } from '../bb/execute.js';
+import { type BBConfig } from '../config.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
 
@@ -73,12 +74,18 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     Promise<VerificationKeyData>
   >();
 
-  constructor(
+  private constructor(
     private bbBinaryPath: string,
     private bbWorkingDirectory: string,
+    private skipCleanup: boolean,
     private log = createDebugLogger('aztec:bb-native-prover'),
   ) {}
 
+  public static async new(config: BBConfig, log?: DebugLogger) {
+    await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
+    return new BBNativePrivateKernelProver(config.bbBinaryPath, config.bbWorkingDirectory, !!config.bbSkipCleanup, log);
+  }
+
   private async _createClientIvcProof(
     directory: string,
     acirs: Buffer[],
@@ -119,7 +126,7 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     const operation = async (directory: string) => {
       return await this._createClientIvcProof(directory, acirs, witnessStack);
     };
-    return await runInDirectory(this.bbWorkingDirectory, operation);
+    return await this.runInDirectory(operation);
   }
 
   public getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs) {
@@ -189,7 +196,7 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
       return await this.computeVerificationKey(directory, bytecode, 'App', appCircuitName);
     };
 
-    return await runInDirectory(this.bbWorkingDirectory, operation);
+    return await this.runInDirectory(operation);
   }
 
   /**
@@ -229,7 +236,7 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
       await fs.writeFile(verificationKeyPath, verificationKey);
       return await verifyProof(this.bbBinaryPath, proofFileName, verificationKeyPath!, logFunction);
     };
-    return await runInDirectory(this.bbWorkingDirectory, operation);
+    return await this.runInDirectory(operation);
   }
 
   /**
@@ -270,7 +277,7 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     } satisfies CircuitWitnessGenerationStats);
 
     // TODO(#7410) we dont need to generate vk's for these circuits, they are in the vk tree
-    const { verificationKey } = await runInDirectory(this.bbWorkingDirectory, dir =>
+    const { verificationKey } = await this.runInDirectory(dir =>
       this.computeVerificationKey(dir, Buffer.from(compiledCircuit.bytecode, 'base64'), circuitType),
     );
     const kernelOutput: PrivateKernelSimulateOutput<O> = {
@@ -352,7 +359,6 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     const json = JSON.parse(proofString);
     const fields = json.map(Fr.fromString);
     const numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-
     const fieldsWithoutPublicInputs = fields.slice(numPublicInputs);
     this.log.info(
       `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}`,
@@ -364,4 +370,17 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     );
     return proof;
   }
+
+  private runInDirectory<T>(fn: (dir: string) => Promise<T>) {
+    const log = this.log;
+    return runInDirectory(
+      this.bbWorkingDirectory,
+      (dir: string) =>
+        fn(dir).catch(err => {
+          log.error(`Error running operation at ${dir}: ${err}`);
+          throw err;
+        }),
+      this.skipCleanup,
+    );
+  }
 }

package/src/prover/bb_prover.ts

@@ -14,6 +14,9 @@ import {
   type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
   type BaseRollupInputs,
+  type BlockMergeRollupInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  type BlockRootRollupInputs,
   EmptyNestedCircuitInputs,
   EmptyNestedData,
   Fr,
@@ -47,6 +50,10 @@ import {
   convertBaseParityOutputsFromWitnessMap,
   convertBaseRollupInputsToWitnessMap,
   convertBaseRollupOutputsFromWitnessMap,
+  convertBlockMergeRollupInputsToWitnessMap,
+  convertBlockMergeRollupOutputsFromWitnessMap,
+  convertBlockRootRollupInputsToWitnessMap,
+  convertBlockRootRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
   convertPrivateKernelEmptyInputsToWitnessMap,
@@ -324,6 +331,55 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     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.
+   */
+  public async getBlockRootRollupProof(
+    input: BlockRootRollupInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    // TODO(#7346): When batch rollups are integrated, we probably want the below to be this.createRecursiveProof
+    // since we will no longer be verifying it directly on L1
+    const { circuitOutput, proof } = await this.createProof(
+      input,
+      'BlockRootRollupArtifact',
+      convertBlockRootRollupInputsToWitnessMap,
+      convertBlockRootRollupOutputsFromWitnessMap,
+    );
+
+    const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
+
+    const verificationKey = await this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
+
+    await this.verifyProof('BlockRootRollupArtifact', proof);
+
+    return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, 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.
+   */
+  public async getBlockMergeRollupProof(
+    input: BlockMergeRollupInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    const { circuitOutput, proof } = await this.createRecursiveProof(
+      input,
+      'BlockMergeRollupArtifact',
+      NESTED_RECURSIVE_PROOF_LENGTH,
+      convertBlockMergeRollupInputsToWitnessMap,
+      convertBlockMergeRollupOutputsFromWitnessMap,
+    );
+
+    const verificationKey = await 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.
@@ -538,7 +594,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
       return { circuitOutput: output, proof };
     };
-    return await runInDirectory(this.config.bbWorkingDirectory, operation);
+    return await this.runInDirectory(operation);
   }
 
   private async generateAvmProofWithBB(input: AvmCircuitInputs, workingDirectory: string): Promise<BBSuccess> {
@@ -571,11 +627,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }
 
   private async createAvmProof(input: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
-    const cleanupDir: boolean = !process.env.AVM_PROVING_PRESERVE_WORKING_DIR;
     const operation = async (bbWorkingDirectory: string): Promise<ProofAndVerificationKey> => {
-      if (!cleanupDir) {
-        logger.info(`Preserving working directory ${bbWorkingDirectory}`);
-      }
       const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
 
       const rawProof = await fs.readFile(provingResult.proofPath!);
@@ -608,7 +660,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
       return { proof, verificationKey };
     };
-    return await runInDirectory(this.config.bbWorkingDirectory, operation, cleanupDir);
+    return await this.runInDirectory(operation);
   }
 
   public async getTubeProof(
@@ -640,7 +692,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
       return { tubeVK, tubeProof };
     };
-    return await runInDirectory(this.config.bbWorkingDirectory, operation);
+    return await this.runInDirectory(operation);
   }
 
   /**
@@ -699,7 +751,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         proof,
       };
     };
-    return await runInDirectory(this.config.bbWorkingDirectory, operation);
+    return await this.runInDirectory(operation);
   }
 
   /**
@@ -752,7 +804,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
     };
 
-    await runInDirectory(this.config.bbWorkingDirectory, operation);
+    await this.runInDirectory(operation);
   }
 
   /**
@@ -824,7 +876,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         true,
       );
     };
-    return await runInDirectory(this.config.bbWorkingDirectory, operation);
+    return await this.runInDirectory(operation);
   }
 
   /**
@@ -895,7 +947,6 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       throw new Error(`Invalid verification key for ${circuitType}`);
     }
     const numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-
     const fieldsWithoutPublicInputs = json
       .slice(0, 3)
       .map(Fr.fromString)
@@ -959,4 +1010,16 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     return proof;
   }
+
+  private runInDirectory<T>(fn: (dir: string) => Promise<T>) {
+    return runInDirectory(
+      this.config.bbWorkingDirectory,
+      (dir: string) =>
+        fn(dir).catch(err => {
+          logger.error(`Error running operation at ${dir}: ${err}`);
+          throw err;
+        }),
+      this.config.bbSkipCleanup,
+    );
+  }
 }

package/src/stats.ts

@@ -15,6 +15,10 @@ export function mapProtocolArtifactNameToCircuitName(
       return 'base-rollup';
     case 'MergeRollupArtifact':
       return 'merge-rollup';
+    case 'BlockRootRollupArtifact':
+      return 'block-root-rollup';
+    case 'BlockMergeRollupArtifact':
+      return 'block-merge-rollup';
     case 'RootRollupArtifact':
       return 'root-rollup';
     case 'PublicKernelSetupArtifact':
@@ -35,6 +39,8 @@ export function mapProtocolArtifactNameToCircuitName(
       return 'private-kernel-tail-to-public';
     case 'PrivateKernelResetFullArtifact':
       return 'private-kernel-reset-full';
+    case 'PrivateKernelResetFullInnerArtifact':
+      return 'private-kernel-reset-full-inner';
     case 'PrivateKernelResetBigArtifact':
       return 'private-kernel-reset-big';
     case 'PrivateKernelResetMediumArtifact':

package/src/test/test_circuit_prover.ts

@@ -11,6 +11,9 @@ import {
   type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
   type BaseRollupInputs,
+  type BlockMergeRollupInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  type BlockRootRollupInputs,
   EmptyNestedData,
   type KernelCircuitPublicInputs,
   type MergeRollupInputs,
@@ -42,6 +45,10 @@ import {
   SimulatedServerCircuitArtifacts,
   convertBaseParityInputsToWitnessMap,
   convertBaseParityOutputsFromWitnessMap,
+  convertBlockMergeRollupInputsToWitnessMap,
+  convertBlockMergeRollupOutputsFromWitnessMap,
+  convertBlockRootRollupInputsToWitnessMap,
+  convertBlockRootRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
   convertPrivateKernelEmptyInputsToWitnessMap,
@@ -65,8 +72,8 @@ import { SimulatedPublicKernelArtifactMapping } from '../mappings/mappings.js';
 import { mapPublicKernelToCircuitName } from '../stats.js';
 
 /**
- * A class for use in testing situations (e2e, unit test etc)
- * Simulates circuits using the most efficient method and performs no proving
+ * A class for use in testing situations (e2e, unit test, etc) and temporarily for assembling a block in the sequencer.
+ * Simulates circuits using the most efficient method and performs no proving.
  */
 export class TestCircuitProver implements ServerCircuitProver {
   private wasmSimulator = new WASMSimulator();
@@ -299,6 +306,76 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
+  /**
+   * Simulates the block root rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  @trackSpan('TestCircuitProver.getBlockRootRollupProof')
+  public async getBlockRootRollupProof(
+    input: BlockRootRollupInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    const timer = new Timer();
+    const witnessMap = convertBlockRootRollupInputsToWitnessMap(input);
+
+    // use WASM here as it is faster for small circuits
+    const witness = await this.wasmSimulator.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.BlockRootRollupArtifact,
+    );
+
+    const result = convertBlockRootRollupOutputsFromWitnessMap(witness);
+
+    this.instrumentation.recordDuration('simulationDuration', 'block-root-rollup', timer);
+    emitCircuitSimulationStats(
+      'block-root-rollup',
+      timer.ms(),
+      input.toBuffer().length,
+      result.toBuffer().length,
+      this.logger,
+    );
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      ProtocolCircuitVks['BlockRootRollupArtifact'],
+    );
+  }
+
+  /**
+   * Simulates the block merge rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  @trackSpan('TestCircuitProver.getBlockMergeRollupProof')
+  public async getBlockMergeRollupProof(
+    input: BlockMergeRollupInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    const timer = new Timer();
+    const witnessMap = convertBlockMergeRollupInputsToWitnessMap(input);
+
+    // use WASM here as it is faster for small circuits
+    const witness = await this.wasmSimulator.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.BlockMergeRollupArtifact,
+    );
+
+    const result = convertBlockMergeRollupOutputsFromWitnessMap(witness);
+
+    this.instrumentation.recordDuration('simulationDuration', 'block-merge-rollup', timer);
+    emitCircuitSimulationStats(
+      'block-merge-rollup',
+      timer.ms(),
+      input.toBuffer().length,
+      result.toBuffer().length,
+      this.logger,
+    );
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      ProtocolCircuitVks['BlockMergeRollupArtifact'],
+    );
+  }
+
   /**
    * Simulates the root rollup circuit from its inputs.
    * @param input - Inputs to the circuit.

package/src/verifier/bb_verifier.ts

@@ -37,6 +37,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
     initialCircuits: ProtocolArtifact[] = [],
     logger = createDebugLogger('aztec:bb-verifier'),
   ) {
+    await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
     const keys = new Map<ProtocolArtifact, Promise<VerificationKeyData>>();
     for (const circuit of initialCircuits) {
       const vkData = await this.generateVerificationKey(
@@ -116,7 +117,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
         proofType: 'ultra-honk',
       } satisfies CircuitVerificationStats);
     };
-    await runInDirectory(this.config.bbWorkingDirectory, operation);
+    await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup);
   }
 
   public async generateSolidityContract(circuit: ProtocolArtifact, contractName: string) {
@@ -168,7 +169,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
           proofType: 'client-ivc',
         } satisfies CircuitVerificationStats);
       };
-      await runInDirectory(this.config.bbWorkingDirectory, operation);
+      await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup);
       return true;
     } catch (err) {
       this.logger.warn(`Failed to verify ClientIVC proof for tx ${Tx.getHash(tx)}: ${String(err)}`);