@aztec/bb.js 0.84.0 → 0.85.0

package/src/barretenberg_api/index.ts

@@ -447,10 +447,9 @@ export class BarretenbergApi {
 
   async acirProveAndVerifyUltraHonk(
     constraintSystemBuf: Uint8Array,
-    recursive: boolean,
     witnessBuf: Uint8Array,
   ): Promise<boolean> {
-    const inArgs = [constraintSystemBuf, recursive, witnessBuf].map(serializeBufferable);
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_and_verify_ultra_honk',
@@ -463,10 +462,9 @@ export class BarretenbergApi {
 
   async acirProveAndVerifyMegaHonk(
     constraintSystemBuf: Uint8Array,
-    recursive: boolean,
     witnessBuf: Uint8Array,
   ): Promise<boolean> {
-    const inArgs = [constraintSystemBuf, recursive, witnessBuf].map(serializeBufferable);
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_and_verify_mega_honk',
@@ -477,22 +475,6 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirFoldAndVerifyProgramStack(
-    constraintSystemBuf: Uint8Array,
-    recursive: boolean,
-    witnessBuf: Uint8Array,
-  ): Promise<boolean> {
-    const inArgs = [constraintSystemBuf, recursive, witnessBuf].map(serializeBufferable);
-    const outTypes: OutputType[] = [BoolDeserializer()];
-    const result = await this.wasm.callWasmExport(
-      'acir_fold_and_verify_program_stack',
-      inArgs,
-      outTypes.map(t => t.SIZE_IN_BYTES),
-    );
-    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
-    return out[0];
-  }
-
   async acirLoadVerificationKey(acirComposerPtr: Ptr, vkBuf: Uint8Array): Promise<void> {
     const inArgs = [acirComposerPtr, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [];
@@ -629,8 +611,8 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirProveUltraHonk(acirVec: Uint8Array, recursive: boolean, witnessVec: Uint8Array): Promise<Uint8Array> {
-    const inArgs = [acirVec, recursive, witnessVec].map(serializeBufferable);
+  async acirProveUltraHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_ultra_honk',
@@ -641,8 +623,8 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirProveUltraKeccakHonk(acirVec: Uint8Array, recursive: boolean, witnessVec: Uint8Array): Promise<Uint8Array> {
-    const inArgs = [acirVec, recursive, witnessVec].map(serializeBufferable);
+  async acirProveUltraKeccakHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_prove_ultra_keccak_honk',
@@ -677,8 +659,8 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirWriteVkUltraHonk(acirVec: Uint8Array, recursive: boolean): Promise<Uint8Array> {
-    const inArgs = [acirVec, recursive].map(serializeBufferable);
+  async acirWriteVkUltraHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_write_vk_ultra_honk',
@@ -689,8 +671,8 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirWriteVkUltraKeccakHonk(acirVec: Uint8Array, recursive: boolean): Promise<Uint8Array> {
-    const inArgs = [acirVec, recursive].map(serializeBufferable);
+  async acirWriteVkUltraKeccakHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
       'acir_write_vk_ultra_keccak_honk',
@@ -1146,8 +1128,8 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
-  acirProveAndVerifyUltraHonk(constraintSystemBuf: Uint8Array, recursive: boolean, witnessBuf: Uint8Array): boolean {
-    const inArgs = [constraintSystemBuf, recursive, witnessBuf].map(serializeBufferable);
+  acirProveAndVerifyUltraHonk(constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): boolean {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
     const result = this.wasm.callWasmExport(
       'acir_prove_and_verify_ultra_honk',
@@ -1158,8 +1140,8 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
-  acirProveAndVerifyMegaHonk(constraintSystemBuf: Uint8Array, recursive: boolean, witnessBuf: Uint8Array): boolean {
-    const inArgs = [constraintSystemBuf, recursive, witnessBuf].map(serializeBufferable);
+  acirProveAndVerifyMegaHonk(constraintSystemBuf: Uint8Array, witnessBuf: Uint8Array): boolean {
+    const inArgs = [constraintSystemBuf, witnessBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
     const result = this.wasm.callWasmExport(
       'acir_prove_and_verify_mega_honk',
@@ -1170,18 +1152,6 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
-  acirFoldAndVerifyProgramStack(constraintSystemBuf: Uint8Array, recursive: boolean, witnessBuf: Uint8Array): boolean {
-    const inArgs = [constraintSystemBuf, recursive, witnessBuf].map(serializeBufferable);
-    const outTypes: OutputType[] = [BoolDeserializer()];
-    const result = this.wasm.callWasmExport(
-      'acir_fold_and_verify_program_stack',
-      inArgs,
-      outTypes.map(t => t.SIZE_IN_BYTES),
-    );
-    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
-    return out[0];
-  }
-
   acirLoadVerificationKey(acirComposerPtr: Ptr, vkBuf: Uint8Array): void {
     const inArgs = [acirComposerPtr, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [];
@@ -1278,8 +1248,8 @@ export class BarretenbergApiSync {
     return out as any;
   }
 
-  acirProveUltraHonk(acirVec: Uint8Array, recursive: boolean, witnessVec: Uint8Array): Uint8Array {
-    const inArgs = [acirVec, recursive, witnessVec].map(serializeBufferable);
+  acirProveUltraHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = this.wasm.callWasmExport(
       'acir_prove_ultra_honk',
@@ -1302,8 +1272,8 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
-  acirWriteVkUltraHonk(acirVec: Uint8Array, recursive: boolean): Uint8Array {
-    const inArgs = [acirVec, recursive].map(serializeBufferable);
+  acirWriteVkUltraHonk(acirVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = this.wasm.callWasmExport(
       'acir_write_vk_ultra_honk',

package/src/index.ts

@@ -10,4 +10,4 @@ export {
 } from './barretenberg/index.js';
 
 export { RawBuffer, Fr } from './types/index.js';
-export { splitHonkProof, reconstructHonkProof, ProofData } from './proof/index.js';
+export { splitHonkProof, reconstructHonkProof, deflattenFields, ProofData } from './proof/index.js';

package/src/main.ts

@@ -108,12 +108,13 @@ async function initUltraPlonk(
   return { api, acirComposer, circuitSize, subgroupSize };
 }
 
-async function initUltraHonk(bytecodePath: string, recursive: boolean, crsPath: string) {
+async function initUltraHonk(bytecodePath: string, crsPath: string) {
   const api = await Barretenberg.new({ threads });
 
   // TODO(https://github.com/AztecProtocol/barretenberg/issues/1248): Get rid of this call to avoid building the circuit twice.
   // TODO(https://github.com/AztecProtocol/barretenberg/issues/1126): use specific UltraHonk function
-  const circuitSize = await getGatesUltra(bytecodePath, recursive, /*honkRecursion=*/ true, api);
+  // recursive here is useless for UH, as it does not affect anything
+  const circuitSize = await getGatesUltra(bytecodePath, /*recursive=*/ false, /*honkRecursion=*/ true, api);
   // TODO(https://github.com/AztecProtocol/barretenberg/issues/811): remove subgroupSizeOverride hack for goblin
   const dyadicCircuitSize = Math.pow(2, Math.ceil(Math.log2(circuitSize)));
 
@@ -185,17 +186,16 @@ export async function proveAndVerify(bytecodePath: string, recursive: boolean, w
 
 export async function proveAndVerifyUltraHonk(
   bytecodePath: string,
-  recursive: boolean,
   witnessPath: string,
   crsPath: string,
 ) {
   /* eslint-disable camelcase */
-  const { api } = await initUltraHonk(bytecodePath, false, crsPath);
+  const { api } = await initUltraHonk(bytecodePath, crsPath);
   try {
     const bytecode = getBytecode(bytecodePath);
     const witness = getWitness(witnessPath);
 
-    const verified = await api.acirProveAndVerifyUltraHonk(bytecode, recursive, witness);
+    const verified = await api.acirProveAndVerifyUltraHonk(bytecode, witness);
     return verified;
   } finally {
     await api.destroy();
@@ -205,7 +205,6 @@ export async function proveAndVerifyUltraHonk(
 
 export async function proveAndVerifyMegaHonk(
   bytecodePath: string,
-  recursive: boolean,
   witnessPath: string,
   crsPath: string,
 ) {
@@ -215,7 +214,7 @@ export async function proveAndVerifyMegaHonk(
     const bytecode = getBytecode(bytecodePath);
     const witness = getWitness(witnessPath);
 
-    const verified = await api.acirProveAndVerifyMegaHonk(bytecode, recursive, witness);
+    const verified = await api.acirProveAndVerifyMegaHonk(bytecode, witness);
     return verified;
   } finally {
     await api.destroy();
@@ -239,27 +238,6 @@ export async function proveAndVerifyAztecClient(bytecodePath: string, witnessPat
   /* eslint-enable camelcase */
 }
 
-export async function foldAndVerifyProgram(
-  bytecodePath: string,
-  recursive: boolean,
-  witnessPath: string,
-  crsPath: string,
-) {
-  /* eslint-disable camelcase */
-  const { api } = await initClientIVC(crsPath);
-  try {
-    const bytecode = getBytecode(bytecodePath);
-    const witness = getWitness(witnessPath);
-
-    const verified = await api.acirFoldAndVerifyProgramStack(bytecode, recursive, witness);
-    debug(`Verification ${verified ? 'successful' : 'failed'}`);
-    return verified;
-  } finally {
-    await api.destroy();
-  }
-  /* eslint-enable camelcase */
-}
-
 export async function prove(
   bytecodePath: string,
   recursive: boolean,
@@ -335,7 +313,7 @@ export async function contract(outputPath: string, vkPath: string, crsPath: stri
 }
 
 export async function contractUltraHonk(bytecodePath: string, vkPath: string, crsPath: string, outputPath: string) {
-  const { api } = await initUltraHonk(bytecodePath, false, crsPath);
+  const { api } = await initUltraHonk(bytecodePath, crsPath);
   try {
     debug(`Creating UltraHonk verifier contract bytecode=${bytecodePath} vk=${vkPath}`);
     const bytecode = getBytecode(bytecodePath);
@@ -444,22 +422,21 @@ export async function vkAsFields(vkPath: string, vkeyOutputPath: string, crsPath
 
 export async function proveUltraHonk(
   bytecodePath: string,
-  recursive: boolean,
   witnessPath: string,
   crsPath: string,
   outputPath: string,
   options?: UltraHonkBackendOptions,
 ) {
-  const { api } = await initUltraHonk(bytecodePath, recursive, crsPath);
+  const { api } = await initUltraHonk(bytecodePath, crsPath);
   try {
-    debug(`Creating UltraHonk proof bytecode=${bytecodePath} recursive=${recursive}`);
+    debug(`Creating UltraHonk proof bytecode=${bytecodePath}`);
     const bytecode = getBytecode(bytecodePath);
     const witness = getWitness(witnessPath);
 
     const acirProveUltraHonk = options?.keccak
       ? api.acirProveUltraKeccakHonk.bind(api)
       : api.acirProveUltraHonk.bind(api);
-    const proof = await acirProveUltraHonk(bytecode, recursive, witness);
+    const proof = await acirProveUltraHonk(bytecode, witness);
 
     if (outputPath === '-') {
       process.stdout.write(proof);
@@ -475,20 +452,19 @@ export async function proveUltraHonk(
 
 export async function writeVkUltraHonk(
   bytecodePath: string,
-  recursive: boolean,
   crsPath: string,
   outputPath: string,
   options?: UltraHonkBackendOptions,
 ) {
-  const { api } = await initUltraHonk(bytecodePath, recursive, crsPath);
+  const { api } = await initUltraHonk(bytecodePath, crsPath);
   try {
     const bytecode = getBytecode(bytecodePath);
-    debug(`Initializing UltraHonk verification key bytecode=${bytecodePath} recursive=${recursive}`);
+    debug(`Initializing UltraHonk verification key bytecode=${bytecodePath}`);
 
     const acirWriteVkUltraHonk = options?.keccak
       ? api.acirWriteVkUltraKeccakHonk.bind(api)
       : api.acirWriteVkUltraHonk.bind(api);
-    const vk = await acirWriteVkUltraHonk(bytecode, recursive);
+    const vk = await acirWriteVkUltraHonk(bytecode);
 
     if (outputPath === '-') {
       process.stdout.write(vk);
@@ -592,11 +568,10 @@ program
   .command('prove_and_verify_ultra_honk')
   .description('Generate an UltraHonk proof and verify it. Process exits with success or failure code.')
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
-  .option('-r, --recursive', 'Whether to use a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
-  .action(async ({ bytecodePath, recursive, witnessPath }) => {
+  .action(async ({ bytecodePath, witnessPath }) => {
     const { crsPath } = handleGlobalOptions();
-    const result = await proveAndVerifyUltraHonk(bytecodePath, recursive, witnessPath, crsPath);
+    const result = await proveAndVerifyUltraHonk(bytecodePath, witnessPath, crsPath);
     process.exit(result ? 0 : 1);
   });
 
@@ -604,11 +579,10 @@ program
   .command('prove_and_verify_mega_honk')
   .description('Generate a MegaHonk proof and verify it. Process exits with success or failure code.')
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
-  .option('-r, --recursive', 'Whether to use a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
-  .action(async ({ bytecodePath, recursive, witnessPath }) => {
+  .action(async ({ bytecodePath, witnessPath }) => {
     const { crsPath } = handleGlobalOptions();
-    const result = await proveAndVerifyMegaHonk(bytecodePath, recursive, witnessPath, crsPath);
+    const result = await proveAndVerifyMegaHonk(bytecodePath, witnessPath, crsPath);
     process.exit(result ? 0 : 1);
   });
 
@@ -623,18 +597,6 @@ program
     process.exit(result ? 0 : 1);
   });
 
-program
-  .command('fold_and_verify_program')
-  .description('Accumulate a set of circuits using ClientIvc then verify. Process exits with success or failure code.')
-  .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')
-  .action(async ({ bytecodePath, recursive, witnessPath }) => {
-    const { crsPath } = handleGlobalOptions();
-    const result = await foldAndVerifyProgram(bytecodePath, recursive, witnessPath, crsPath);
-    process.exit(result ? 0 : 1);
-  });
-
 program
   .command('prove')
   .description('Generate a proof and write it to a file.')
@@ -738,46 +700,42 @@ program
   .command('prove_ultra_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('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
-  .action(async ({ bytecodePath, recursive, witnessPath, outputPath }) => {
+  .action(async ({ bytecodePath, witnessPath, outputPath }) => {
     const { crsPath } = handleGlobalOptions();
-    await proveUltraHonk(bytecodePath, recursive, witnessPath, crsPath, outputPath);
+    await proveUltraHonk(bytecodePath, witnessPath, crsPath, outputPath);
   });
 
 program
   .command('prove_ultra_keccak_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('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
-  .action(async ({ bytecodePath, recursive, witnessPath, outputPath, crsPath }) => {
+  .action(async ({ bytecodePath, witnessPath, outputPath, crsPath }) => {
     handleGlobalOptions();
-    await proveUltraHonk(bytecodePath, recursive, witnessPath, crsPath, outputPath, { keccak: true });
+    await proveUltraHonk(bytecodePath, witnessPath, crsPath, outputPath, { keccak: true });
   });
 
 program
   .command('write_vk_ultra_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, recursive, outputPath }) => {
+  .action(async ({ bytecodePath, outputPath }) => {
     const { crsPath } = handleGlobalOptions();
-    await writeVkUltraHonk(bytecodePath, recursive, crsPath, outputPath);
+    await writeVkUltraHonk(bytecodePath, crsPath, outputPath);
   });
 
 program
   .command('write_vk_ultra_keccak_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, recursive, outputPath, crsPath }) => {
+  .action(async ({ bytecodePath, outputPath, crsPath }) => {
     handleGlobalOptions();
-    await writeVkUltraHonk(bytecodePath, recursive, crsPath, outputPath, { keccak: true });
+    await writeVkUltraHonk(bytecodePath, crsPath, outputPath, { keccak: true });
   });
 
 program

package/src/proof/index.ts

@@ -11,16 +11,7 @@ export type ProofData = {
   proof: Uint8Array;
 };
 
-/**
- * @description
- * The representation of a proof
- * */
-export type ProofDataForRecursion = {
-  /** @description Public inputs of a proof */
-  publicInputs: string[];
-  /** @description An byte array representing the proof */
-  proof: string[];
-};
+export const AGGREGATION_OBJECT_LENGTH = 16;
 
 // Fields are 32 bytes
 const fieldByteSize = 32;