@aztec/bb.js 1.0.0-nightly.20250613 → 1.0.0-nightly.20250615

package/src/barretenberg/backend.ts

@@ -92,18 +92,6 @@ export class UltraHonkBackend {
   async generateProof(compressedWitness: Uint8Array, options?: UltraHonkBackendOptions): Promise<ProofData> {
     await this.instantiate();
 
-    const proveUltraHonk = options?.keccak
-      ? this.api.acirProveUltraKeccakHonk.bind(this.api)
-      : options?.keccakZK
-        ? this.api.acirProveUltraKeccakZkHonk.bind(this.api)
-        : options?.starknet
-          ? this.api.acirProveUltraStarknetHonk.bind(this.api)
-          : options?.starknetZK
-            ? this.api.acirProveUltraStarknetZkHonk.bind(this.api)
-            : this.api.acirProveUltraHonk.bind(this.api);
-
-    const proofWithPublicInputs = await proveUltraHonk(this.acirUncompressedBytecode, ungzip(compressedWitness));
-
     // Write VK to get the number of public inputs
     const writeVKUltraHonk = options?.keccak
       ? this.api.acirWriteVkUltraKeccakHonk.bind(this.api)
@@ -115,8 +103,24 @@ export class UltraHonkBackend {
             ? this.api.acirWriteVkUltraStarknetZkHonk.bind(this.api)
             : this.api.acirWriteVkUltraHonk.bind(this.api);
 
-    const vk = await writeVKUltraHonk(this.acirUncompressedBytecode);
-    const vkAsFields = await this.api.acirVkAsFieldsUltraHonk(new RawBuffer(vk));
+    const vkBuf = await writeVKUltraHonk(this.acirUncompressedBytecode);
+    const vkAsFields = await this.api.acirVkAsFieldsUltraHonk(new RawBuffer(vkBuf));
+
+    const proveUltraHonk = options?.keccak
+      ? this.api.acirProveUltraKeccakHonk.bind(this.api)
+      : options?.keccakZK
+        ? this.api.acirProveUltraKeccakZkHonk.bind(this.api)
+        : options?.starknet
+          ? this.api.acirProveUltraStarknetHonk.bind(this.api)
+          : options?.starknetZK
+            ? this.api.acirProveUltraStarknetZkHonk.bind(this.api)
+            : this.api.acirProveUltraHonk.bind(this.api);
+
+    const proofWithPublicInputs = await proveUltraHonk(
+      this.acirUncompressedBytecode,
+      ungzip(compressedWitness),
+      new RawBuffer(vkBuf),
+    );
 
     // Item at index 1 in VK is the number of public inputs
     const publicInputsSizeIndex = 1; // index into VK for numPublicInputs

package/src/barretenberg_api/index.ts

@@ -223,7 +223,6 @@ export class BarretenbergApi {
     return out as any;
   }
 
-
   async acirProveAndVerifyUltraHonk(constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): Promise<boolean> {
     const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
@@ -384,8 +383,8 @@ export class BarretenbergApi {
     return out as any;
   }
 
-  async acirProveUltraHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
-    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+  async acirProveUltraHonk(acirVec: Uint8Array, witnessVec: Uint8Array, vkBuf: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_ultra_honk',
@@ -396,8 +395,8 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirProveUltraKeccakHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
-    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+  async acirProveUltraKeccakHonk(acirVec: Uint8Array, witnessVec: Uint8Array, vkBuf: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_ultra_keccak_honk',
@@ -408,8 +407,12 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirProveUltraKeccakZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
-    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+  async acirProveUltraKeccakZkHonk(
+    acirVec: Uint8Array,
+    witnessVec: Uint8Array,
+    vkBuf: Uint8Array,
+  ): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_ultra_keccak_zk_honk',
@@ -420,8 +423,12 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirProveUltraStarknetHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
-    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+  async acirProveUltraStarknetHonk(
+    acirVec: Uint8Array,
+    witnessVec: Uint8Array,
+    vkBuf: Uint8Array,
+  ): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_ultra_starknet_honk',
@@ -432,8 +439,12 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirProveUltraStarknetZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
-    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+  async acirProveUltraStarknetZkHonk(
+    acirVec: Uint8Array,
+    witnessVec: Uint8Array,
+    vkBuf: Uint8Array,
+  ): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_ultra_starknet_zk_honk',
@@ -819,7 +830,6 @@ export class BarretenbergApiSync {
     return out as any;
   }
 
-
   acirProveAndVerifyUltraHonk(constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): boolean {
     const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];

package/src/main.ts

@@ -148,6 +148,7 @@ export async function proveUltraHonk(
   bytecodePath: string,
   witnessPath: string,
   crsPath: string,
+  vkPath: string,
   outputPath: string,
   options?: UltraHonkBackendOptions,
 ) {
@@ -166,7 +167,7 @@ export async function proveUltraHonk(
           : options?.starknetZK
             ? api.acirProveUltraStarknetZkHonk.bind(api)
             : api.acirProveUltraHonk.bind(api);
-    const proof = await acirProveUltraHonk(bytecode, witness);
+    const proof = await acirProveUltraHonk(bytecode, witness, new RawBuffer(readFileSync(vkPath)));
 
     if (outputPath === '-') {
       process.stdout.write(proof);
@@ -414,11 +415,12 @@ program
   .description('Generate a proof and write it to a file.')
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+  .option('-k, --vk-path <path>', 'path to a verification key. avoids recomputation.')
   .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
-  .action(async ({ bytecodePath, witnessPath, outputPath }) => {
+  .action(async ({ bytecodePath, witnessPath, vkPath, outputPath }) => {
     const { crsPath } = handleGlobalOptions();
-    debug(`Creating UltraHonk proof bytecode=${bytecodePath}`);
-    await proveUltraHonk(bytecodePath, witnessPath, crsPath, outputPath);
+    debug(`Creating UltraHonk proof bytecodePath=${bytecodePath}, witnessPath=${witnessPath}, vkPath=${vkPath}`);
+    await proveUltraHonk(bytecodePath, witnessPath, crsPath, vkPath, outputPath);
   });
 
 program
@@ -426,22 +428,23 @@ program
   .description('Generate a proof and write it to a file.')
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+  .option('-k, --vk-path <path>', 'path to a verification key. avoids recomputation.')
   .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
-  .action(async ({ bytecodePath, witnessPath, outputPath }) => {
+  .action(async ({ bytecodePath, witnessPath, vkPath, outputPath }) => {
     const { crsPath } = handleGlobalOptions();
-    await proveUltraHonk(bytecodePath, witnessPath, crsPath, outputPath, { keccak: true });
+    await proveUltraHonk(bytecodePath, witnessPath, crsPath, vkPath, outputPath, { keccak: true });
   });
 
 program
   .command('prove_ultra_starknet_honk')
   .description('Generate a proof and write it to a file.')
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
-  .option('-r, --recursive', 'Create a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
+  .option('-k, --vk-path <path>', 'path to a verification key. avoids recomputation.')
   .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
-  .action(async ({ bytecodePath, witnessPath, outputPath }) => {
+  .action(async ({ bytecodePath, witnessPath, vkPath, outputPath }) => {
     const { crsPath } = handleGlobalOptions();
-    await proveUltraHonk(bytecodePath, witnessPath, crsPath, outputPath, { starknet: true });
+    await proveUltraHonk(bytecodePath, witnessPath, crsPath, vkPath, outputPath, { starknet: true });
   });
 
 program
@@ -469,7 +472,6 @@ program
   .command('write_vk_ultra_starknet_honk')
   .description('Output verification key.')
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
-  .option('-r, --recursive', 'Create a SNARK friendly proof', false)
   .requiredOption('-o, --output-path <path>', 'Specify the path to write the key')
   .action(async ({ bytecodePath, outputPath }) => {
     const { crsPath } = handleGlobalOptions();
@@ -480,10 +482,10 @@ program
   .command('verify_ultra_honk')
   .description('Verify a proof. Process exists with success or failure code.')
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
-  .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
-  .action(async ({ proofPath, vk }) => {
+  .requiredOption('-k, --vk-path <path>', 'path to a verification key. avoids recomputation.')
+  .action(async ({ proofPath, vkPath }) => {
     const { crsPath } = handleGlobalOptions();
-    const result = await verifyUltraHonk(proofPath, vk, crsPath);
+    const result = await verifyUltraHonk(proofPath, vkPath, crsPath);
     process.exit(result ? 0 : 1);
   });
 
@@ -491,10 +493,10 @@ program
   .command('verify_ultra_keccak_honk')
   .description('Verify a proof. Process exists with success or failure code.')
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
-  .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
-  .action(async ({ proofPath, vk }) => {
+  .requiredOption('-k, --vk-path <path>', 'path to a verification key. avoids recomputation.')
+  .action(async ({ proofPath, vkPath }) => {
     const { crsPath } = handleGlobalOptions();
-    const result = await verifyUltraHonk(proofPath, vk, crsPath, { keccak: true });
+    const result = await verifyUltraHonk(proofPath, vkPath, crsPath, { keccak: true });
     process.exit(result ? 0 : 1);
   });