@aztec/bb.js 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/cbind/schema_compiler.ts

@@ -34,7 +34,7 @@ export interface FunctionMetadata {
 
 // Compiler configuration
 export interface CompilerConfig {
-  mode: 'types' | 'sync' | 'async' | 'native';
+  mode: 'types' | 'sync' | 'async';
   imports?: string[];
   wasmImport?: string;
 }
@@ -72,17 +72,28 @@ export class SchemaCompiler {
     this.processSchema(responsesSchema);
 
     // Extract function metadata from named unions
-    if (!Array.isArray(commandsSchema) || commandsSchema[0] !== 'named_union' ||
-        !Array.isArray(responsesSchema) || responsesSchema[0] !== 'named_union') {
+    if (
+      !Array.isArray(commandsSchema) ||
+      commandsSchema[0] !== 'named_union' ||
+      !Array.isArray(responsesSchema) ||
+      responsesSchema[0] !== 'named_union'
+    ) {
       throw new Error('Expected named_union schema format');
     }
 
     const commands = commandsSchema[1] as Array<[string, Schema]>;
     const responses = responsesSchema[1] as Array<[string, Schema]>;
 
+    // Filter out ErrorResponse - it's a special error variant, not a command response
+    const normalResponses = responses.filter(([name]) => name !== 'ErrorResponse');
+
+    if (commands.length !== normalResponses.length) {
+      throw new Error(`Command count (${commands.length}) does not match response count (${normalResponses.length})`);
+    }
+
     for (let i = 0; i < commands.length; i++) {
       const [commandName] = commands[i];
-      const [responseName] = responses[i];
+      const [responseName] = normalResponses[i];
 
       this.functionMetadata.push({
         name: camelCase(commandName),
@@ -115,10 +126,7 @@ export class SchemaCompiler {
    * Generate the complete output
    */
   compile(): string {
-    const parts: string[] = [
-      '// AUTOGENERATED FILE - DO NOT EDIT',
-      '',
-    ];
+    const parts: string[] = ['// AUTOGENERATED FILE - DO NOT EDIT', ''];
 
     // Generate imports
     parts.push(...this.generateImports());
@@ -131,55 +139,51 @@ export class SchemaCompiler {
         .sort((a, b) => a.typeName.localeCompare(b.typeName));
 
       // Group declarations
-      const typeAliases = sortedTypes.filter(t =>
-        t.declaration?.startsWith('export type') && !t.declaration?.includes('interface')
+      const typeAliases = sortedTypes.filter(
+        t => t.declaration?.startsWith('export type') && !t.declaration?.includes('interface'),
       );
-      const publicInterfaces = sortedTypes.filter(t =>
-        t.declaration?.includes('export interface')
-      );
-      const privateInterfaces = sortedTypes.filter(t =>
-        t.declaration?.includes('interface Msgpack')
-      );
-
-    // Add type aliases if needed
-    if (typeAliases.length > 0) {
-      parts.push('// Type aliases');
-      for (const type of typeAliases) {
-        parts.push(type.declaration!);
+      const publicInterfaces = sortedTypes.filter(t => t.declaration?.includes('export interface'));
+      const privateInterfaces = sortedTypes.filter(t => t.declaration?.includes('interface Msgpack'));
+
+      // Add type aliases if needed
+      if (typeAliases.length > 0) {
+        parts.push('// Type aliases');
+        for (const type of typeAliases) {
+          parts.push(type.declaration!);
+        }
+        parts.push('');
       }
-      parts.push('');
-    }
 
-    // Add tuple helper if needed
-    if (this.needsTupleHelper()) {
-      parts.push(
-        '// Tuple type for fixed-size arrays',
-        'type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;',
-        'type _TupleOf<T, N extends number, R extends unknown[]> = R[\'length\'] extends N ? R : _TupleOf<T, N, [T, ...R]>;',
-        '',
-        '// Helper functions',
-        'function mapTuple<T, S, N extends number>(tuple: Tuple<T, N>, fn: (item: T) => S): Tuple<S, N> {',
-        '  return tuple.map(fn) as Tuple<S, N>;',
-        '}',
-        ''
-      );
-    }
+      // Add tuple helper if needed
+      if (this.needsTupleHelper()) {
+        parts.push(
+          '// Tuple type for fixed-size arrays',
+          'type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;',
+          "type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;",
+          '',
+          '// Helper functions',
+          'function mapTuple<T, S, N extends number>(tuple: Tuple<T, N>, fn: (item: T) => S): Tuple<S, N> {',
+          '  return tuple.map(fn) as Tuple<S, N>;',
+          '}',
+          '',
+        );
+      }
 
-    // Add public interfaces
-    if (publicInterfaces.length > 0) {
-      parts.push('// Public interfaces (exported)');
-      for (const type of publicInterfaces) {
-        parts.push(type.declaration!, '');
+      // Add public interfaces
+      if (publicInterfaces.length > 0) {
+        parts.push('// Public interfaces (exported)');
+        for (const type of publicInterfaces) {
+          parts.push(type.declaration!, '');
+        }
       }
-    }
 
-    // Add private interfaces
-    if (privateInterfaces.length > 0) {
-      parts.push('// Private Msgpack interfaces (not exported)');
-      for (const type of privateInterfaces) {
-        parts.push(type.declaration!, '');
+      // Add private interfaces
+      if (privateInterfaces.length > 0) {
+        parts.push('// Private Msgpack interfaces (not exported)');
+        for (const type of privateInterfaces) {
+          parts.push(type.declaration!, '');
+        }
       }
-    }
 
       // Add conversion functions (only for api_types.ts)
       const conversions = sortedTypes.filter(t => t.toMethod || t.fromMethod);
@@ -218,9 +222,7 @@ export class SchemaCompiler {
   }
 
   private needsTupleHelper(): boolean {
-    return Array.from(this.typeCache.values()).some(t =>
-      t.typeName.includes('Tuple<')
-    );
+    return Array.from(this.typeCache.values()).some(t => t.typeName.includes('Tuple<'));
   }
 
   private trackTypeUsage(typeName: string): void {
@@ -296,10 +298,15 @@ export class SchemaCompiler {
     switch (type) {
       case 'array': {
         const [subtype, size] = args[0];
+        // Special case: byte arrays should be Uint8Array
+        if (subtype === 'unsigned char') {
+          return { typeName: 'Uint8Array' };
+        }
+        // For other types, use T[] - idiomatic TypeScript for fixed-length homogeneous arrays
         const subtypeInfo = this.processSchema(subtype);
         return {
-          typeName: `Tuple<${subtypeInfo.typeName}, ${size}>`,
-          msgpackTypeName: `Tuple<${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}, ${size}>`,
+          typeName: `${subtypeInfo.typeName}[]`,
+          msgpackTypeName: `${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}[]`,
         };
       }
 
@@ -392,12 +399,20 @@ export class SchemaCompiler {
       case 'unsigned int':
       case 'unsigned short':
       case 'unsigned long':
+      case 'unsigned char':
       case 'double':
         return { typeName: 'number' };
       case 'string':
         return { typeName: 'string' };
       case 'bin32':
         return { typeName: 'Uint8Array' };
+      case 'field2':
+        // field2 is an extension field type (fq2) represented as a tuple of two Uint8Arrays
+        return {
+          typeName: 'Field2',
+          msgpackTypeName: '[Uint8Array, Uint8Array]',
+          declaration: 'export type Field2 = [Uint8Array, Uint8Array];',
+        };
       default:
         return { typeName: pascalCase(schema) };
     }
@@ -477,15 +492,19 @@ export class SchemaCompiler {
       return `function to${name}(o: Msgpack${name}): ${name} {\n  return {};\n}`;
     }
 
-    const checks = fields.map(([key]) =>
-      `  if (o.${key} === undefined) { throw new Error("Expected ${key} in ${name} deserialization"); }`
-    ).join('\n');
+    const checks = fields
+      .map(
+        ([key]) => `  if (o.${key} === undefined) { throw new Error("Expected ${key} in ${name} deserialization"); }`,
+      )
+      .join('\n');
 
-    const conversions = fields.map(([key, value]) => {
-      const typeInfo = this.processSchema(value);
-      const converter = this.generateConverter(typeInfo, `o.${key}`, 'to');
-      return `    ${camelCase(key)}: ${converter},`;
-    }).join('\n');
+    const conversions = fields
+      .map(([key, value]) => {
+        const typeInfo = this.processSchema(value);
+        const converter = this.generateConverter(typeInfo, `o.${key}`, 'to');
+        return `    ${camelCase(key)}: ${converter},`;
+      })
+      .join('\n');
 
     return `function to${name}(o: Msgpack${name}): ${name} {
 ${checks};
@@ -502,15 +521,20 @@ ${conversions}
       return `function from${name}(o: ${name}): Msgpack${name} {\n  return {};\n}`;
     }
 
-    const checks = fields.map(([key]) =>
-      `  if (o.${camelCase(key)} === undefined) { throw new Error("Expected ${camelCase(key)} in ${name} serialization"); }`
-    ).join('\n');
+    const checks = fields
+      .map(
+        ([key]) =>
+          `  if (o.${camelCase(key)} === undefined) { throw new Error("Expected ${camelCase(key)} in ${name} serialization"); }`,
+      )
+      .join('\n');
 
-    const conversions = fields.map(([key, value]) => {
-      const typeInfo = this.processSchema(value);
-      const converter = this.generateConverter(typeInfo, `o.${camelCase(key)}`, 'from');
-      return `  ${key}: ${converter},`;
-    }).join('\n');
+    const conversions = fields
+      .map(([key, value]) => {
+        const typeInfo = this.processSchema(value);
+        const converter = this.generateConverter(typeInfo, `o.${camelCase(key)}`, 'from');
+        return `  ${key}: ${converter},`;
+      })
+      .join('\n');
 
     return `function from${name}(o: ${name}): Msgpack${name} {
 ${checks};
@@ -531,8 +555,8 @@ ${conversions}
       }
     }
 
-    // Handle custom types
-    if (typeInfo.declaration) {
+    // Handle custom types that have conversion methods (not just type aliases)
+    if (typeInfo.toMethod || typeInfo.fromMethod) {
       return `${direction}${typeInfo.typeName}(${value})`;
     }
 
@@ -579,9 +603,9 @@ ${conversions}
   }
 
   private generateBbApiBaseInterface(): string {
-    const methods = this.functionMetadata.map(m =>
-      `  ${m.name}(command: ${m.commandType}): Promise<${m.responseType}>;`
-    ).join('\n');
+    const methods = this.functionMetadata
+      .map(m => `  ${m.name}(command: ${m.commandType}): Promise<${m.responseType}>;`)
+      .join('\n');
 
     return `export interface BbApiBase {
 ${methods}
@@ -593,71 +617,82 @@ ${methods}
     const className = this.getApiClassName();
     const methods = this.functionMetadata.map(m => this.generateApiMethod(m)).join('\n\n');
 
-    if (this.config.mode === 'native') {
-      return this.generateNativeApiClass(methods);
-    }
-
     // For sync API, don't implement BbApiBase since methods are synchronous
     const implementsClause = this.config.mode === 'sync' ? '' : ' implements BbApiBase';
 
-    const msgpackCallHelper = `${this.config.mode === 'async' ? 'async ' : ''}function msgpackCall(wasm: ${this.getWasmType()}, cbind: string, input: any[]) {` +
-    `  const inputBuffer = new Encoder({ useRecords: false }).pack(input);` +
-    `  const encodedResult = ${this.config.mode === 'async' ? 'await ' : ''}wasm.cbindCall(cbind, inputBuffer);` +
-    `  return new Decoder({ useRecords: false }).unpack(encodedResult);` +
-    `}\n`;
+    // For tracing all calls to bb.
+    // const msgpackCallHelper =
+    //   `${this.config.mode === 'async' ? 'async ' : ''}function msgpackCall(backend: ${this.getBackendType()}, input: any[]) {\n` +
+    //   `  const commandName = input[0]?.[0] || 'unknown';\n` +
+    //   `  process.stderr.write(\`[BB MSGPACK ${this.config.mode === 'async' ? 'ASYNC' : 'SYNC'}] \${commandName}\\n\`);\n` +
+    //   `  const inputBuffer = new Encoder({ useRecords: false }).pack(input);\n` +
+    //   `  const encodedResult = ${this.config.mode === 'async' ? 'await ' : ''}backend.call(inputBuffer);\n` +
+    //   `  const result = new Decoder({ useRecords: false }).unpack(encodedResult);\n` +
+    //   `  process.stderr.write(\`[BB MSGPACK ${this.config.mode === 'async' ? 'ASYNC' : 'SYNC'}] \${commandName} => completed\\n\`);\n` +
+    //   `  return result;\n` +
+    //   `}\n`;
+    const msgpackCallHelper =
+      `${this.config.mode === 'async' ? 'async ' : ''}function msgpackCall(backend: ${this.getBackendType()}, input: any[]) {` +
+      `  const inputBuffer = new Encoder({ useRecords: false }).pack(input);` +
+      `  const encodedResult = ${this.config.mode === 'async' ? 'await ' : ''}backend.call(inputBuffer);` +
+      `  return new Decoder({ useRecords: false }).unpack(encodedResult);` +
+      `}\n`;
+    const destroyMethod =
+      this.config.mode === 'sync'
+        ? `  destroy(): void {
+    if (this.backend.destroy) this.backend.destroy();
+  }`
+        : `  destroy(): Promise<void> {
+    return this.backend.destroy ? this.backend.destroy() : Promise.resolve();
+  }`;
+
     return (
       msgpackCallHelper +
       `export class ${className}${implementsClause} {
-  constructor(protected wasm: ${this.getWasmType()}) {}
+  constructor(protected backend: ${this.getBackendType()}) {}
 
 ${methods}
 
-  destroy(): Promise<void> {
-    return this.wasm.destroy();
-  }
+${destroyMethod}
 }`
     );
   }
 
   private getApiClassName(): string {
     switch (this.config.mode) {
-      case 'sync': return 'SyncApi';
-      case 'async': return 'AsyncApi';
-      case 'native': return 'NativeApi';
-      default: throw new Error(`Invalid mode: ${this.config.mode}`);
+      case 'sync':
+        return 'SyncApi';
+      case 'async':
+        return 'AsyncApi';
+      default:
+        throw new Error(`Invalid mode: ${this.config.mode}`);
     }
   }
 
-  private getWasmType(): string {
+  private getBackendType(): string {
     switch (this.config.mode) {
-      case 'sync': return 'BarretenbergWasmMain';
-      case 'async': return 'BarretenbergWasmMainWorker';
-      default: return '';
+      case 'sync':
+        return 'IMsgpackBackendSync';
+      case 'async':
+        return 'IMsgpackBackendAsync';
+      default:
+        return '';
     }
   }
 
   private generateApiMethod(metadata: FunctionMetadata): string {
     const { name, commandType, responseType } = metadata;
 
-    if (this.config.mode === 'native') {
-      return `  ${name}(command: ${commandType}): Promise<${responseType}> {
-    const msgpackCommand = from${commandType}(command);
-    return this.sendCommand(['${metadata.commandType}', msgpackCommand]).then(([variantName, result]: [string, any]) => {
-      if (variantName !== '${responseType}') {
-        throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
-      }
-      return to${responseType}(result);
-    });
-  }`;
-    }
-
     // For async mode, queue immediately and return promise
     if (this.config.mode === 'async') {
       return `  ${name}(command: ${commandType}): Promise<${responseType}> {
     const msgpackCommand = from${commandType}(command);
-    return msgpackCall(this.wasm, 'bbapi', [["${capitalize(name)}", msgpackCommand]]).then(([variantName, result]: [string, any]) => {
+    return msgpackCall(this.backend, [["${capitalize(name)}", msgpackCommand]]).then(([variantName, result]: [string, any]) => {
+      if (variantName === 'ErrorResponse') {
+        throw new BBApiException(result.message || 'Unknown error from barretenberg');
+      }
       if (variantName !== '${responseType}') {
-        throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+        throw new BBApiException(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
       }
       return to${responseType}(result);
     });
@@ -667,131 +702,16 @@ ${methods}
     // For sync mode, keep the synchronous behavior
     return `  ${name}(command: ${commandType}): ${responseType} {
     const msgpackCommand = from${commandType}(command);
-    const [variantName, result] = msgpackCall(this.wasm, 'bbapi', [["${capitalize(name)}", msgpackCommand]]);
+    const [variantName, result] = msgpackCall(this.backend, [["${capitalize(name)}", msgpackCommand]]);
+    if (variantName === 'ErrorResponse') {
+      throw new BBApiException(result.message || 'Unknown error from barretenberg');
+    }
     if (variantName !== '${responseType}') {
-      throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+      throw new BBApiException(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
     }
     return to${responseType}(result);
   }`;
   }
-
-  private generateNativeApiClass(methods: string): string {
-    return `interface NativeApiRequest {
-  resolve: (value: any) => void;
-  reject: (error: any) => void;
-}
-
-class StreamBuffer {
-  private buffer = Buffer.alloc(0);
-  private expectedLength: number | null = null;
-
-  addData(data: Buffer): Buffer[] {
-    // Create buffer to grow as needed
-    const newBuffer = Buffer.allocUnsafe(this.buffer.length + data.length);
-    this.buffer.copy(newBuffer, 0);
-    data.copy(newBuffer, this.buffer.length);
-    this.buffer = newBuffer;
-
-    const messages: Buffer[] = [];
-
-    while (true) {
-      if (this.expectedLength === null) {
-        if (this.buffer.length < 4) break;
-        this.expectedLength = this.buffer.readUInt32LE(0);
-        this.buffer = this.buffer.subarray(4);
-      }
-
-      if (this.buffer.length < this.expectedLength) break;
-
-      // Extract complete message
-      const messageBuffer = this.buffer.subarray(0, this.expectedLength);
-      messages.push(messageBuffer);
-      this.buffer = this.buffer.subarray(this.expectedLength);
-      this.expectedLength = null;
-    }
-
-    return messages;
-  }
-}
-
-export class NativeApi implements BbApiBase {
-  private decoder = new Decoder({ useRecords: false });
-  private encoder = new Encoder({ useRecords: false });
-  private pendingRequests: NativeApiRequest[] = [];
-
-  private constructor(private proc: ChildProcess) {}
-
-  static async new(bbPath = 'bb', logger = console.log): Promise<NativeApi> {
-    const proc = spawn(bbPath, ['msgpack', 'run'], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    if (!proc.stdout || !proc.stdin) {
-      throw new Error('Failed to initialize bb process');
-    }
-
-    const api = new NativeApi(proc);
-    const streamBuffer = new StreamBuffer();
-
-    proc.stdout.on('data', (data: Buffer) => {
-      const messages = streamBuffer.addData(data);
-
-      for (const messageBuffer of messages) {
-        const pendingRequest = api.pendingRequests.shift();
-        if (!pendingRequest) {
-          throw new Error('Received response without a pending request');
-        }
-
-        try {
-          const decoded = api.decoder.decode(messageBuffer);
-          if (!Array.isArray(decoded) || decoded.length !== 2) {
-            throw new Error(\`Invalid response format: \${JSON.stringify(decoded)}\`);
-          }
-          const [variantName, result] = decoded;
-          pendingRequest.resolve([variantName, result]);
-        } catch (error) {
-          pendingRequest.reject(error);
-          break;
-        }
-      }
-    });
-
-    proc.stderr.on('data', (data: Buffer) => {
-      logger(data.toString().trim());
-    });
-
-    proc.on('error', err => {
-      throw new Error(err.message);
-    });
-    return api;
-  }
-
-  private sendCommand(command: any): Promise<any> {
-    return new Promise((resolve, reject) => {
-      this.pendingRequests.push({ resolve, reject });
-      const encoded = this.encoder.encode(command);
-
-      // Write length prefix (4 bytes, little-endian)
-      const lengthBuffer = Buffer.allocUnsafe(4);
-      lengthBuffer.writeUInt32LE(encoded.length, 0);
-
-      // Write length prefix followed by the encoded data
-      this.proc.stdin!.write(lengthBuffer);
-      this.proc.stdin!.write(encoded);
-    });
-  }
-
-  async close(): Promise<void> {
-    this.proc.kill();
-  }
-
-  destroy(): Promise<void> {
-    return this.close();
-  }
-
-${methods}
-}`;
-  }
 }
 
 // Factory methods for creating configured compilers
@@ -806,8 +726,9 @@ export function createSyncApiCompiler(): SchemaCompiler {
   return new SchemaCompiler({
     mode: 'sync',
     imports: [
-      `import { BarretenbergWasmMain } from "../../barretenberg_wasm/barretenberg_wasm_main/index.js";`,
+      `import { IMsgpackBackendSync } from '../../bb_backends/interface.js';`,
       `import { Decoder, Encoder } from 'msgpackr';`,
+      `import { BBApiException } from '../../bbapi_exception.js';`,
     ],
   });
 }
@@ -816,18 +737,9 @@ export function createAsyncApiCompiler(): SchemaCompiler {
   return new SchemaCompiler({
     mode: 'async',
     imports: [
-      `import { BarretenbergWasmMainWorker } from "../../barretenberg_wasm/barretenberg_wasm_main/index.js";`,
-      `import { Decoder, Encoder } from 'msgpackr';`
-    ],
-  });
-}
-
-export function createNativeApiCompiler(): SchemaCompiler {
-  return new SchemaCompiler({
-    mode: 'native',
-    imports: [
-      `import { spawn, ChildProcess } from 'child_process';`,
-      `import { Decoder, Encoder } from 'msgpackr';`
+      `import { IMsgpackBackendAsync } from '../../bb_backends/interface.js';`,
+      `import { Decoder, Encoder } from 'msgpackr';`,
+      `import { BBApiException } from '../../bbapi_exception.js';`,
     ],
   });
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 export { Crs, GrumpkinCrs } from './crs/index.js';
 export {
   type BackendOptions,
+  BackendType,
   Barretenberg,
   BarretenbergSync,
   UltraHonkVerifierBackend,
@@ -9,5 +10,32 @@ export {
 } from './barretenberg/index.js';
 
 export { randomBytes } from './random/index.js';
-export { RawBuffer, Fr } from './types/index.js';
 export { splitHonkProof, reconstructHonkProof, deflattenFields, type ProofData } from './proof/index.js';
+export { BBApiException } from './bbapi_exception.js';
+
+// Export Point types for use in foundation and other packages
+export type {
+  Bn254G1Point,
+  Bn254G2Point,
+  GrumpkinPoint,
+  Secp256k1Point,
+  Secp256r1Point,
+  Field2,
+} from './cbind/generated/api_types.js';
+
+// Export curve constants for use in foundation
+export {
+  BN254_FQ_MODULUS,
+  BN254_FR_MODULUS,
+  BN254_G1_GENERATOR,
+  BN254_G2_GENERATOR,
+  GRUMPKIN_FR_MODULUS,
+  GRUMPKIN_FQ_MODULUS,
+  GRUMPKIN_G1_GENERATOR,
+  SECP256K1_FR_MODULUS,
+  SECP256K1_FQ_MODULUS,
+  SECP256K1_G1_GENERATOR,
+  SECP256R1_FR_MODULUS,
+  SECP256R1_FQ_MODULUS,
+  SECP256R1_G1_GENERATOR,
+} from './cbind/generated/curve_constants.js';

package/src/serialize/index.ts

@@ -1,3 +1 @@
-export * from './buffer_reader.js';
-export * from './output_type.js';
 export * from './serialize.js';