@aztec/bb.js 1.2.1 → 2.0.0-nightly.20250814

package/src/barretenberg_api/index.ts

@@ -383,11 +383,11 @@ export class BarretenbergApi {
     return out as any;
   }
 
-  async acirProveUltraHonk(acirVec: Uint8Array, witnessVec: Uint8Array, vkBuf: Uint8Array): Promise<Uint8Array> {
+  async acirProveUltraZKHonk(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',
+      'acir_prove_ultra_zk_honk',
       inArgs,
       outTypes.map(t => t.SIZE_IN_BYTES),
     );
@@ -455,11 +455,11 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirVerifyUltraHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+  async acirVerifyUltraZKHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
     const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
     const result = await this.wasm.callWasmExport(
-      'acir_verify_ultra_honk',
+      'acir_verify_ultra_zk_honk',
       inArgs,
       outTypes.map(t => t.SIZE_IN_BYTES),
     );

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);
+});