@aztec/bb-prover 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/src/prover/{bb_private_kernel_prover.ts → client/bb_private_kernel_prover.ts}

@@ -1,6 +1,7 @@
 import { createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
 import {
+  convertHidingKernelPublicInputsToWitnessMapWithAbi,
+  convertHidingKernelToRollupInputsToWitnessMapWithAbi,
   convertPrivateKernelInitInputsToWitnessMapWithAbi,
   convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
   convertPrivateKernelInnerInputsToWitnessMapWithAbi,
@@ -11,13 +12,22 @@ import {
   convertPrivateKernelTailInputsToWitnessMapWithAbi,
   convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
   convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+  foreignCallHandler,
   getPrivateKernelResetArtifactName,
   updateResetCircuitSampleInputs,
 } from '@aztec/noir-protocol-circuits-types/client';
-import type { ArtifactProvider, ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
-import type { SimulationProvider } from '@aztec/simulator/client';
+import {
+  type ArtifactProvider,
+  type ClientProtocolArtifact,
+  mapProtocolArtifactNameToCircuitName,
+} from '@aztec/noir-protocol-circuits-types/types';
+import type { Abi, WitnessMap } from '@aztec/noir-types';
+import type { CircuitSimulator } from '@aztec/simulator/client';
 import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 import type {
+  HidingKernelToPublicPrivateInputs,
+  HidingKernelToRollupPrivateInputs,
+  PrivateExecutionStep,
   PrivateKernelCircuitPublicInputs,
   PrivateKernelInitCircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
@@ -26,18 +36,14 @@ import type {
   PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
-import type { ClientIvcProof } from '@aztec/stdlib/proofs';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
+import type { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
 import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 
-import type { Abi, WitnessMap } from '@noir-lang/types';
-
-import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
-
 export abstract class BBPrivateKernelProver implements PrivateKernelProver {
   constructor(
     protected artifactProvider: ArtifactProvider,
-    protected simulationProvider: SimulationProvider,
+    protected simulator: CircuitSimulator,
     protected log = createLogger('bb-prover'),
   ) {}
 
@@ -150,6 +156,28 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     );
   }
 
+  public async generateHidingToRollupOutput(
+    inputs: HidingKernelToRollupPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'HidingKernelToRollup',
+      convertHidingKernelToRollupInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateHidingToPublicOutput(
+    inputs: HidingKernelToPublicPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'HidingKernelToPublic',
+      convertHidingKernelPublicInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+    );
+  }
+
   public async simulateCircuitOutput<
     I extends { toBuffer: () => Buffer },
     O extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
@@ -159,15 +187,13 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     convertInputs: (inputs: I, abi: Abi) => WitnessMap,
     convertOutputs: (outputs: WitnessMap, abi: Abi) => O,
   ): Promise<PrivateKernelSimulateOutput<O>> {
-    const compiledCircuit: NoirCompiledCircuit = await this.artifactProvider.getSimulatedClientCircuitArtifactByName(
-      circuitType,
-    );
+    const compiledCircuit: NoirCompiledCircuitWithName =
+      await this.artifactProvider.getSimulatedClientCircuitArtifactByName(circuitType);
 
     const witnessMap = convertInputs(inputs, compiledCircuit.abi);
 
-    const timer = new Timer();
-    const outputWitness = await this.simulationProvider
-      .executeProtocolCircuit(witnessMap, compiledCircuit)
+    const outputWitness = await this.simulator
+      .executeProtocolCircuit(witnessMap, compiledCircuit, foreignCallHandler)
       .catch((err: Error) => {
         this.log.debug(`Failed to simulate ${circuitType}`, {
           circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
@@ -175,12 +201,12 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
         });
         throw err;
       });
-    const output = convertOutputs(outputWitness, compiledCircuit.abi);
+    const output = convertOutputs(outputWitness.witness, compiledCircuit.abi);
 
     this.log.debug(`Simulated ${circuitType}`, {
       eventName: 'circuit-simulation',
       circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-      duration: timer.ms(),
+      duration: outputWitness.duration,
       inputSize: inputs.toBuffer().length,
       outputSize: output.toBuffer().length,
     } satisfies CircuitSimulationStats);
@@ -198,30 +224,28 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     convertOutputs: (outputs: WitnessMap, abi: Abi) => O,
   ): Promise<PrivateKernelSimulateOutput<O>> {
     this.log.debug(`Generating witness for ${circuitType}`);
-    const compiledCircuit: NoirCompiledCircuit = await this.artifactProvider.getClientCircuitArtifactByName(
-      circuitType,
-    );
+    const compiledCircuit: NoirCompiledCircuitWithName =
+      await this.artifactProvider.getClientCircuitArtifactByName(circuitType);
 
     const witnessMap = convertInputs(inputs, compiledCircuit.abi);
-    const timer = new Timer();
-    const outputWitness = await this.simulationProvider.executeProtocolCircuit(witnessMap, compiledCircuit);
-    const output = convertOutputs(outputWitness, compiledCircuit.abi);
+    const outputWitness = await this.simulator.executeProtocolCircuit(witnessMap, compiledCircuit, foreignCallHandler);
+    const output = convertOutputs(outputWitness.witness, compiledCircuit.abi);
 
     this.log.debug(`Generated witness for ${circuitType}`, {
       eventName: 'circuit-witness-generation',
       circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-      duration: timer.ms(),
+      duration: outputWitness.duration,
       inputSize: inputs.toBuffer().length,
       outputSize: output.toBuffer().length,
     } satisfies CircuitWitnessGenerationStats);
 
-    const verificationKey = (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields;
+    const verificationKey = await this.artifactProvider.getCircuitVkByName(circuitType);
     const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
 
     const kernelOutput: PrivateKernelSimulateOutput<O> = {
       publicInputs: output,
       verificationKey,
-      outputWitness,
+      outputWitness: outputWitness.witness,
       bytecode,
     };
     return kernelOutput;
@@ -232,14 +256,14 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
   >(publicInputs: PublicInputsType, circuitType: ClientProtocolArtifact) {
     const kernelProofOutput: PrivateKernelSimulateOutput<PublicInputsType> = {
       publicInputs,
-      verificationKey: (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields,
+      verificationKey: await this.artifactProvider.getCircuitVkByName(circuitType),
       outputWitness: new Map(),
       bytecode: Buffer.from([]),
     };
     return kernelProofOutput;
   }
 
-  public createClientIvcProof(_acirs: Buffer[], _witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+  public createChonkProof(_executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs> {
     throw new Error('Not implemented');
   }
 

package/src/prover/{bb_native_private_kernel_prover.ts → client/native/bb_native_private_kernel_prover.ts}

@@ -1,19 +1,17 @@
 import { runInDirectory } from '@aztec/foundation/fs';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
-import type { SimulationProvider } from '@aztec/simulator/server';
-import type { ClientIvcProof } from '@aztec/stdlib/proofs';
+import type { CircuitSimulator } from '@aztec/simulator/server';
+import { type PrivateExecutionStep, serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
+import type { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
 
-import { encode } from '@msgpack/msgpack';
-import { serializeWitness } from '@noir-lang/noirc_abi';
-import type { WitnessMap } from '@noir-lang/types';
 import { promises as fs } from 'fs';
 import path from 'path';
 
-import { BB_RESULT, computeGateCountForCircuit, executeBbClientIvcProof } from '../bb/execute.js';
-import type { BBConfig } from '../config.js';
-import { BBPrivateKernelProver } from './bb_private_kernel_prover.js';
-import { readFromOutputDirectory } from './client_ivc_proof_utils.js';
+import { BB_RESULT, computeGateCountForCircuit, executeBbChonkProof } from '../../../bb/execute.js';
+import type { BBConfig } from '../../../config.js';
+import { readChonkProofFromOutputDirectory } from '../../proof_utils.js';
+import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
 
 /**
  * This proof creator implementation uses the native bb binary.
@@ -23,51 +21,39 @@ export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
     private bbBinaryPath: string,
     private bbWorkingDirectory: string,
     private skipCleanup: boolean,
-    protected override simulationProvider: SimulationProvider,
+    protected override simulator: CircuitSimulator,
     protected override log = createLogger('bb-prover:native'),
   ) {
-    super(new BundleArtifactProvider(), simulationProvider, log);
+    super(new BundleArtifactProvider(), simulator, log);
   }
 
-  public static async new(config: BBConfig, simulationProvider: SimulationProvider, log?: Logger) {
+  public static async new(config: BBConfig, simulator: CircuitSimulator, log?: Logger) {
     await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
     return new BBNativePrivateKernelProver(
       config.bbBinaryPath,
       config.bbWorkingDirectory,
       !!config.bbSkipCleanup,
-      simulationProvider,
+      simulator,
       log,
     );
   }
 
-  private async _createClientIvcProof(
+  private async _createChonkProof(
     directory: string,
-    acirs: Buffer[],
-    witnessStack: WitnessMap[],
-  ): Promise<ClientIvcProof> {
-    // TODO(#7371): Longer term we won't use this hacked together msgpack format
-    // and instead properly create the bincode serialization from rust
-    await fs.writeFile(path.join(directory, 'acir.msgpack'), encode(acirs));
-    await fs.writeFile(
-      path.join(directory, 'witnesses.msgpack'),
-      encode(witnessStack.map(map => serializeWitness(map))),
-    );
-    const provingResult = await executeBbClientIvcProof(
-      this.bbBinaryPath,
-      directory,
-      path.join(directory, 'acir.msgpack'),
-      path.join(directory, 'witnesses.msgpack'),
-      this.log.info,
-    );
+    executionSteps: PrivateExecutionStep[],
+  ): Promise<ChonkProofWithPublicInputs> {
+    const inputsPath = path.join(directory, 'ivc-inputs.msgpack');
+    await fs.writeFile(inputsPath, serializePrivateExecutionSteps(executionSteps));
+    const provingResult = await executeBbChonkProof(this.bbBinaryPath, directory, inputsPath, this.log.info);
 
     if (provingResult.status === BB_RESULT.FAILURE) {
-      this.log.error(`Failed to generate client ivc proof`);
+      this.log.error(`Failed to generate chonk proof`);
       throw new Error(provingResult.reason);
     }
 
-    const proof = await readFromOutputDirectory(directory);
+    const proof = await readChonkProofFromOutputDirectory(directory);
 
-    this.log.info(`Generated IVC proof`, {
+    this.log.info(`Generated Chonk proof`, {
       duration: provingResult.durationMs,
       eventName: 'circuit-proving',
     });
@@ -75,10 +61,10 @@ export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
     return proof;
   }
 
-  public override async createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
-    this.log.info(`Generating Client IVC proof`);
+  public override async createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs> {
+    this.log.info(`Generating Chonk proof`);
     const operation = async (directory: string) => {
-      return await this._createClientIvcProof(directory, acirs, witnessStack);
+      return await this._createChonkProof(directory, executionSteps);
     };
     return await this.runInDirectory(operation);
   }

package/src/{wasm → prover/client/wasm}/bb_wasm_private_kernel_prover.ts

@@ -1,46 +1,49 @@
 import { AztecClientBackend } from '@aztec/bb.js';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import { serializeWitness } from '@aztec/noir-noirc_abi';
 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 { CircuitSimulator } from '@aztec/simulator/client';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
+import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
 
-import { serializeWitness } from '@noir-lang/noirc_abi';
-import type { WitnessMap } from '@noir-lang/types';
 import { ungzip } from 'pako';
 
-import { BBPrivateKernelProver } from '../prover/bb_private_kernel_prover.js';
+import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
 
 export abstract class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
   constructor(
     protected override artifactProvider: ArtifactProvider,
-    protected override simulationProvider: SimulationProvider,
+    protected override simulator: CircuitSimulator,
     private threads: number = 1,
     protected override log = createLogger('bb-prover:wasm'),
   ) {
-    super(artifactProvider, simulationProvider, log);
+    super(artifactProvider, simulator, log);
   }
 
-  public override async createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+  public override async createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs> {
     const timer = new Timer();
-    this.log.info(`Generating ClientIVC proof...`);
+    this.log.info(`Generating Chonk proof...`);
     const backend = new AztecClientBackend(
-      acirs.map(acir => ungzip(acir)),
+      executionSteps.map(step => ungzip(step.bytecode)),
       { 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))));
+    const [proof] = await backend.prove(
+      executionSteps.map(step => ungzip(serializeWitness(step.witness))),
+      executionSteps.map(step => step.vk),
+    );
     await backend.destroy();
-    this.log.info(`Generated ClientIVC proof`, {
-      eventName: 'client-ivc-proof-generation',
+    this.log.info(`Generated Chonk proof`, {
+      eventName: 'chonk-proof-generation',
       duration: timer.ms(),
       proofSize: proof.length,
-      vkSize: vk.length,
     });
-    return new ClientIvcProof(Buffer.from(proof), Buffer.from(vk));
+    return ChonkProofWithPublicInputs.fromBufferArray(proof);
   }
 
   public override async computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number> {
+    // Note we do not pass the vk to the backend. This is unneeded for gate counts.
     const backend = new AztecClientBackend([ungzip(_bytecode)], {
       threads: this.threads,
       logger: this.log.verbose,

package/src/{wasm → prover/client/wasm}/bundle.ts

@@ -1,11 +1,11 @@
 import { createLogger } from '@aztec/foundation/log';
 import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
-import type { SimulationProvider } from '@aztec/simulator/client';
+import type { CircuitSimulator } from '@aztec/simulator/client';
 
 import { BBWASMPrivateKernelProver } from './bb_wasm_private_kernel_prover.js';
 
 export class BBWASMBundlePrivateKernelProver extends BBWASMPrivateKernelProver {
-  constructor(simulationProvider: SimulationProvider, threads = 1, log = createLogger('bb-prover:wasm:bundle')) {
-    super(new BundleArtifactProvider(), simulationProvider, threads, log);
+  constructor(simulator: CircuitSimulator, threads = 16, log = createLogger('bb-prover:wasm:bundle')) {
+    super(new BundleArtifactProvider(), simulator, threads, log);
   }
 }

package/src/{wasm → prover/client/wasm}/lazy.ts

@@ -1,11 +1,11 @@
 import { createLogger } from '@aztec/foundation/log';
 import { LazyArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/lazy';
-import type { SimulationProvider } from '@aztec/simulator/client';
+import type { CircuitSimulator } from '@aztec/simulator/client';
 
 import { BBWASMPrivateKernelProver } from './bb_wasm_private_kernel_prover.js';
 
 export class BBWASMLazyPrivateKernelProver extends BBWASMPrivateKernelProver {
-  constructor(simulationProvider: SimulationProvider, threads = 1, log = createLogger('bb-prover:wasm:lazy')) {
-    super(new LazyArtifactProvider(), simulationProvider, threads, log);
+  constructor(simulator: CircuitSimulator, threads = 16, log = createLogger('bb-prover:wasm:lazy')) {
+    super(new LazyArtifactProvider(), simulator, threads, log);
   }
 }

package/src/prover/index.ts

@@ -1,3 +1,2 @@
-export * from './bb_prover.js';
-export * from './bb_native_private_kernel_prover.js';
-export * from './client_ivc_proof_utils.js';
+export * from './server/bb_prover.js';
+export * from './proof_utils.js';

package/src/prover/proof_utils.ts

@@ -0,0 +1,115 @@
+import {
+  CHONK_PROOF_LENGTH,
+  HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE,
+  IPA_CLAIM_SIZE,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  PAIRING_POINTS_SIZE,
+  ULTRA_KECCAK_PROOF_LENGTH,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { ChonkProofWithPublicInputs, Proof, RecursiveProof } from '@aztec/stdlib/proofs';
+import type { VerificationKeyData } from '@aztec/stdlib/vks';
+
+import assert from 'assert';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+
+import { PROOF_FILENAME, PUBLIC_INPUTS_FILENAME } from '../bb/execute.js';
+
+/**
+ * Create a ChonkProof proof file.
+ *
+ * @param directory the directory to read the proof from.
+ * @returns the encapsulated chonk proof
+ */
+export async function readChonkProofFromOutputDirectory(directory: string) {
+  const proofFilename = path.join(directory, PROOF_FILENAME);
+  const binaryProof = await fs.readFile(proofFilename);
+  const proofFields = splitBufferIntoFields(binaryProof);
+  return new ChonkProofWithPublicInputs(proofFields);
+}
+
+/**
+ * Serialize a ChonkProof to a proof file.
+ *
+ * @param proof the ChonkProof from object
+ * @param directory the directory to write in
+ */
+export async function writeChonkProofToPath(chonkProof: ChonkProofWithPublicInputs, outputPath: string) {
+  // NB: Don't use chonkProof.toBuffer here because it will include the proof length.
+  const fieldsBuf = Buffer.concat(chonkProof.fieldsWithPublicInputs.map(field => field.toBuffer()));
+  await fs.writeFile(outputPath, fieldsBuf);
+}
+
+function getNumCustomPublicInputs(proofLength: number, vkData: VerificationKeyData) {
+  let numPublicInputs = vkData.numPublicInputs;
+  if (proofLength == CHONK_PROOF_LENGTH) {
+    numPublicInputs -= HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE;
+  } else {
+    numPublicInputs -= PAIRING_POINTS_SIZE;
+    if (proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH) {
+      numPublicInputs -= IPA_CLAIM_SIZE;
+    }
+  }
+  return numPublicInputs;
+}
+
+function splitBufferIntoFields(buffer: Buffer): Fr[] {
+  const fields: Fr[] = [];
+  for (let i = 0; i < buffer.length / Fr.SIZE_IN_BYTES; i++) {
+    fields.push(Fr.fromBuffer(buffer.subarray(i * Fr.SIZE_IN_BYTES, (i + 1) * Fr.SIZE_IN_BYTES)));
+  }
+  return fields;
+}
+
+export async function readProofsFromOutputDirectory<PROOF_LENGTH extends number>(
+  directory: string,
+  vkData: VerificationKeyData,
+  proofLength: PROOF_LENGTH,
+  logger: Logger,
+): Promise<RecursiveProof<PROOF_LENGTH>> {
+  assert(
+    proofLength == CHONK_PROOF_LENGTH ||
+      proofLength == NESTED_RECURSIVE_PROOF_LENGTH ||
+      proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH ||
+      proofLength == ULTRA_KECCAK_PROOF_LENGTH,
+    `Proof length must be one of the expected proof lengths, received ${proofLength}`,
+  );
+
+  const publicInputsFilename = path.join(directory, PUBLIC_INPUTS_FILENAME);
+  const proofFilename = path.join(directory, PROOF_FILENAME);
+
+  // Handle CHONK separately because bb outputs the proof fields with public inputs for CHONK.
+  const isChonk = proofLength == CHONK_PROOF_LENGTH;
+
+  const [binaryPublicInputs, binaryProof] = await Promise.all([
+    isChonk ? Buffer.alloc(0) : fs.readFile(publicInputsFilename),
+    fs.readFile(proofFilename),
+  ]);
+
+  const numPublicInputs = getNumCustomPublicInputs(proofLength, vkData);
+  let fieldsWithoutPublicInputs = splitBufferIntoFields(binaryProof);
+  if (isChonk) {
+    fieldsWithoutPublicInputs = fieldsWithoutPublicInputs.slice(numPublicInputs);
+  }
+
+  assert(
+    fieldsWithoutPublicInputs.length == proofLength,
+    `Proof fields length mismatch: ${fieldsWithoutPublicInputs.length} != ${proofLength}`,
+  );
+
+  // Concat binary public inputs and binary proof
+  // This buffer will have the form: [binary public inputs, binary proof]
+  const binaryProofWithPublicInputs = Buffer.concat([binaryPublicInputs, binaryProof]);
+  logger.debug(
+    `Circuit path: ${directory}, proof fields length: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}`,
+  );
+  return new RecursiveProof(
+    fieldsWithoutPublicInputs,
+    new Proof(binaryProofWithPublicInputs, numPublicInputs),
+    true,
+    proofLength,
+  );
+}