@aztec/bb.js 1.0.0-nightly.20250725 → 1.0.0-nightly.20250726

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aztec/bb.js",
   "packageManager": "yarn@4.5.2",
-  "version": "1.0.0-nightly.20250725",
+  "version": "1.0.0-nightly.20250726",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/ts",
   "license": "MIT",
   "type": "module",
@@ -21,13 +21,14 @@
     "README.md"
   ],
   "scripts": {
-    "clean": "rm -rf ./dest .tsbuildinfo .tsbuildinfo.cjs",
-    "build": "yarn clean && yarn build:wasm && yarn build:esm && yarn build:cjs && yarn build:browser",
+    "clean": "rm -rf ./dest .tsbuildinfo .tsbuildinfo.cjs ./src/cbind/generated",
+    "build": "yarn clean && yarn generate && yarn build:wasm && yarn build:esm && yarn build:cjs && yarn build:browser",
     "build:wasm": "./scripts/build_wasm.sh",
     "build:esm": "tsc -b tsconfig.esm.json && chmod +x ./dest/node/main.js",
     "build:cjs": "tsc -b tsconfig.cjs.json && ./scripts/cjs_postprocess.sh",
     "build:browser": "tsc -b tsconfig.browser.json && ./scripts/browser_postprocess.sh",
     "build:bindings": "cd .. && ./scripts/bindgen.sh",
+    "generate": "NODE_OPTIONS='--loader ts-node/esm' NODE_NO_WARNINGS=1 ts-node src/cbind/generate.ts",
     "formatting": "prettier --check ./src && eslint --max-warnings 0 ./src",
     "formatting:fix": "prettier -w ./src",
     "test": "NODE_OPTIONS='--loader ts-node/esm' NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --passWithNoTests",

package/src/barretenberg/backend.ts

@@ -8,8 +8,10 @@ import {
   splitHonkProof,
   PAIRING_POINTS_SIZE,
 } from '../proof/index.js';
-import { Encoder } from 'msgpackr/pack';
+import { fromClientIVCProof, toClientIVCProof } from '../cbind/generated/api_types.js';
 import { ungzip } from 'pako';
+import { Buffer } from 'buffer';
+import { Decoder, Encoder } from 'msgpackr';
 
 export class AztecClientBackendError extends Error {
   constructor(message: string) {
@@ -17,23 +19,6 @@ export class AztecClientBackendError extends Error {
   }
 }
 
-// Utility for parsing gate counts from buffer
-// TODO: Where should this logic live? Should go away with move to msgpack.
-function parseBigEndianU32Array(buffer: Uint8Array): number[] {
-  const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-
-  let offset = 0;
-  const count = buffer.byteLength >>> 2; // default is entire buffer length / 4
-
-  const out: number[] = new Array(count);
-  for (let i = 0; i < count; i++) {
-    out[i] = dv.getUint32(offset, false);
-    offset += 4;
-  }
-
-  return out;
-}
-
 /**
  * Options for the UltraHonkBackend.
  */
@@ -219,39 +204,6 @@ export class UltraHonkBackend {
     await this.api.destroy();
   }
 }
-interface AztecClientExecutionStep {
-  functionName: string;
-  gateCount?: number;
-  // Note: not gzipped like in native code
-  bytecode: Uint8Array;
-  // Note: not gzipped like in native code. Already bincoded.
-  witness: Uint8Array;
-  /* TODO(https://github.com/AztecProtocol/barretenberg/issues/1328) this should get its own proper class. */
-  vk: Uint8Array;
-}
-
-function serializeAztecClientExecutionSteps(
-  acirBuf: Uint8Array[],
-  witnessBuf: Uint8Array[],
-  vksBuf: Uint8Array[],
-): Uint8Array {
-  const steps: AztecClientExecutionStep[] = [];
-  for (let i = 0; i < acirBuf.length; i++) {
-    const bytecode = acirBuf[i];
-    // Witnesses are not provided at all for gates info.
-    const witness = witnessBuf[i] || Buffer.from([]);
-    // VKs are optional for proving (deprecated feature) or not provided at all for gates info.
-    const vk = vksBuf[i] || Buffer.from([]);
-    const functionName = `unknown_wasm_${i}`;
-    steps.push({
-      bytecode,
-      witness,
-      vk,
-      functionName,
-    });
-  }
-  return new Encoder({ useRecords: false }).pack(steps);
-}
 
 export class AztecClientBackend {
   // These type assertions are used so that we don't
@@ -284,26 +236,73 @@ export class AztecClientBackend {
       throw new AztecClientBackendError('Witness and VKs must have the same stack depth!');
     }
     await this.instantiate();
-    const ivcInputsBuf = serializeAztecClientExecutionSteps(this.acirBuf, witnessBuf, vksBuf);
-    const proofAndVk = await this.api.acirProveAztecClient(ivcInputsBuf);
-    const [proof, vk] = proofAndVk;
-    if (!(await this.verify(proof, vk))) {
+
+    // Queue IVC start with the number of circuits
+    this.api.clientIvcStart({ numCircuits: this.acirBuf.length });
+
+    // Queue load and accumulate for each circuit
+    for (let i = 0; i < this.acirBuf.length; i++) {
+      const bytecode = this.acirBuf[i];
+      const witness = witnessBuf[i] || Buffer.from([]);
+      const vk = vksBuf[i] || Buffer.from([]);
+      const functionName = `unknown_wasm_${i}`;
+
+      // Load the circuit
+      this.api.clientIvcLoad({
+        circuit: {
+          name: functionName,
+          bytecode: Buffer.from(bytecode),
+          verificationKey: Buffer.from(vk),
+        }
+      });
+
+      // Accumulate with witness
+      this.api.clientIvcAccumulate({
+        witness: Buffer.from(witness),
+      });
+    }
+
+    // Generate the proof (and wait for all previous steps to finish)
+    const proveResult = await this.api.clientIvcProve({});
+
+    // The API currently expects a msgpack-encoded API.
+    const proof = new Encoder({useRecords: false}).encode(fromClientIVCProof(proveResult.proof));
+    // Generate the VK
+    const vkResult = await this.api.clientIvcComputeIvcVk({ circuit: {
+      name: 'tail',
+      bytecode: this.acirBuf[this.acirBuf.length - 1],
+    } });
+
+    // Note: Verification may not work correctly until we properly serialize the proof
+    if (!(await this.verify(proof, vkResult.bytes))) {
       throw new AztecClientBackendError('Failed to verify the private (ClientIVC) transaction proof!');
     }
-    return proofAndVk;
+    return [proof, vkResult.bytes];
   }
 
   async verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean> {
     await this.instantiate();
-    return this.api.acirVerifyAztecClient(proof, vk);
+    const result = await this.api.clientIvcVerify({
+      proof: toClientIVCProof(new Decoder({useRecords: false}).decode(proof)),
+      vk: Buffer.from(vk),
+    });
+    return result.valid;
   }
 
   async gates(): Promise<number[]> {
-    // call function on API
     await this.instantiate();
-    const ivcInputsBuf = serializeAztecClientExecutionSteps(this.acirBuf, [], []);
-    const resultBuffer = await this.api.acirGatesAztecClient(ivcInputsBuf);
-    return parseBigEndianU32Array(resultBuffer);
+    const circuitSizes: number[] = [];
+    for (const buf of this.acirBuf) {
+      const gates = await this.api.clientIvcGates({
+        circuit: {
+          name: 'circuit',
+          bytecode: buf,
+        },
+        includeGatesPerOpcode: false
+      });
+      circuitSizes.push(gates.circuitSize);
+    }
+    return circuitSizes;
   }
 
   async destroy(): Promise<void> {

package/src/barretenberg/index.ts

@@ -7,6 +7,8 @@ import { Crs, GrumpkinCrs } from '../crs/index.js';
 import { RawBuffer } from '../types/raw_buffer.js';
 import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
 import { createDebugLogger } from '../log/index.js';
+import { AsyncApi } from '../cbind/generated/async.js';
+import { BbApiBase } from '../cbind/generated/api_types.js';
 
 export { BarretenbergVerifier } from './verifier.js';
 export { UltraHonkBackend, AztecClientBackend } from './backend.js';
@@ -39,6 +41,7 @@ export type CircuitOptions = {
  */
 export class Barretenberg extends BarretenbergApi {
   private options: BackendOptions;
+  private bbApi: BbApiBase;
 
   private constructor(
     private worker: any,
@@ -47,6 +50,7 @@ export class Barretenberg extends BarretenbergApi {
   ) {
     super(wasm);
     this.options = options;
+    this.bbApi = new AsyncApi(wasm);
   }
 
   /**
@@ -114,6 +118,39 @@ export class Barretenberg extends BarretenbergApi {
   getWasm() {
     return this.wasm;
   }
+
+  getBbApi(): BbApiBase {
+    return this.bbApi;
+  }
+
+  // Wrap ClientIVC methods used by AztecClientBackend
+  async clientIvcStart(command: Parameters<BbApiBase['clientIvcStart']>[0]) {
+    return this.bbApi.clientIvcStart(command);
+  }
+
+  async clientIvcLoad(command: Parameters<BbApiBase['clientIvcLoad']>[0]) {
+    return this.bbApi.clientIvcLoad(command);
+  }
+
+  async clientIvcAccumulate(command: Parameters<BbApiBase['clientIvcAccumulate']>[0]) {
+    return this.bbApi.clientIvcAccumulate(command);
+  }
+
+  async clientIvcProve(command: Parameters<BbApiBase['clientIvcProve']>[0]) {
+    return this.bbApi.clientIvcProve(command);
+  }
+
+  async clientIvcVerify(command: Parameters<BbApiBase['clientIvcVerify']>[0]) {
+    return this.bbApi.clientIvcVerify(command);
+  }
+
+  async clientIvcComputeIvcVk(command: Parameters<BbApiBase['clientIvcComputeIvcVk']>[0]) {
+    return this.bbApi.clientIvcComputeIvcVk(command);
+  }
+
+  async clientIvcGates(command: Parameters<BbApiBase['clientIvcGates']>[0]) {
+    return this.bbApi.clientIvcGates(command);
+  }
 }
 
 let barretenbergSyncSingletonPromise: Promise<BarretenbergSync>;

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -49,9 +49,11 @@ export class BarretenbergWasmBase {
           const m = this.getMemory();
           const str2 = `${str} (mem: ${(m.length / (1024 * 1024)).toFixed(2)}MiB)`;
           this.logger(str2);
-          // if (str2.startsWith('WARNING:')) {
-          //   this.logger(new Error().stack!);
-          // }
+        },
+
+        throw_or_abort_impl: (addr: number) => {
+          const str = this.stringFromAddress(addr);
+          throw new Error(str);
         },
 
         get_data: (keyAddr: number, outBufAddr: number) => {

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -136,6 +136,29 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
       return this.getMemorySlice(ptr + 4, ptr + 4 + length);
     });
   }
+
+  cbindCall(cbind: string, inputBuffer: Uint8Array): any {
+    const outputSizePtr = this.call('bbmalloc', 4);
+    const outputMsgpackPtr = this.call('bbmalloc', 4);
+
+    const inputPtr = this.call('bbmalloc', inputBuffer.length);
+    this.writeMemory(inputPtr, inputBuffer);
+    this.call(cbind, inputPtr, inputBuffer.length, outputMsgpackPtr, outputSizePtr);
+
+    const readPtr32 = (ptr32: number) => {
+      const dataView = new DataView(this.getMemorySlice(ptr32, ptr32 + 4).buffer);
+      return dataView.getUint32(0, true);
+    };
+
+    const encodedResult = this.getMemorySlice(
+      readPtr32(outputMsgpackPtr),
+      readPtr32(outputMsgpackPtr) + readPtr32(outputSizePtr),
+    );
+    this.call('bbfree', inputPtr);
+    this.call('bbfree', outputSizePtr);
+    this.call('bbfree', outputMsgpackPtr);
+    return encodedResult;
+  }
 }
 
 /**

package/src/cbind/README.md

@@ -0,0 +1 @@
+Derive bindings from the reported scheme of msgpack from bb. Currently redundant with bindgen, until that is supplanted.

package/src/cbind/generate.ts

@@ -0,0 +1,89 @@
+/**
+ * Generate TypeScript bindings from msgpack schema
+ */
+
+import { writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import {
+  createSharedTypesCompiler,
+  createSyncApiCompiler,
+  createAsyncApiCompiler,
+  createNativeApiCompiler,
+  type SchemaCompiler,
+} from './schema_compiler.js';
+
+const execAsync = promisify(exec);
+
+interface GeneratorConfig {
+  name: string;
+  outputFile: string;
+  createCompiler: () => SchemaCompiler;
+}
+
+const GENERATORS: GeneratorConfig[] = [
+  {
+    name: 'Shared types',
+    outputFile: 'generated/api_types.ts',
+    createCompiler: createSharedTypesCompiler,
+  },
+  {
+    name: 'Sync API',
+    outputFile: 'generated/sync.ts',
+    createCompiler: createSyncApiCompiler,
+  },
+  {
+    name: 'Async API',
+    outputFile: 'generated/async.ts',
+    createCompiler: createAsyncApiCompiler,
+  },
+  {
+    name: 'Native API',
+    outputFile: 'generated/native.ts',
+    createCompiler: createNativeApiCompiler,
+  },
+];
+
+// @ts-ignore
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function generate() {
+  const bbBuildPath = process.env.BB_BINARY_PATH || join(__dirname, '../../../cpp/build/bin/bb');
+
+  // Get schema from bb
+  console.log('Fetching msgpack schema from bb...');
+  const { stdout } = await execAsync(`${bbBuildPath} msgpack schema`);
+  const schema = JSON.parse(stdout.trim());
+
+  if (!schema.commands || !schema.responses) {
+    throw new Error('Invalid schema: missing commands or responses');
+  }
+
+  console.log('Generating TypeScript bindings...\n');
+
+  // Ensure output directory exists
+  const outputDir = join(__dirname, 'generated');
+  mkdirSync(outputDir, { recursive: true });
+
+  // Generate each output file
+  for (const config of GENERATORS) {
+    const compiler = config.createCompiler();
+    compiler.processApiSchema(schema.commands, schema.responses);
+
+    const outputPath = join(__dirname, config.outputFile);
+    const content = compiler.compile();
+    writeFileSync(outputPath, content);
+
+    console.log(`✓ ${config.name}: ${outputPath}`);
+  }
+
+  console.log('\nGeneration complete!');
+}
+
+// Run the generator
+generate().catch(error => {
+  console.error('Generation failed:', error);
+  process.exit(1);
+});