@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.5476d83

package/src/cbind/schema_compiler.ts

@@ -0,0 +1,745 @@
+/**
+ * Unified schema compiler with integrated strategies
+ */
+
+// Core type definitions
+export type Schema =
+  | string
+  | ObjectSchema
+  | ['tuple', Schema[]]
+  | ['map', [Schema, Schema]]
+  | ['optional', [Schema]]
+  | ['vector', [Schema]]
+  | ['variant', Schema[]]
+  | ['named_union', Array<[string, Schema]>]
+  | ['shared_ptr', [Schema]]
+  | ['array', [Schema, number]]
+  | ['alias', [string, string]];
+
+export type ObjectSchema = { [key: string]: Schema };
+
+export interface TypeInfo {
+  typeName: string;
+  msgpackTypeName?: string;
+  declaration?: string;
+  toMethod?: string;
+  fromMethod?: string;
+}
+
+export interface FunctionMetadata {
+  name: string;
+  commandType: string;
+  responseType: string;
+}
+
+// Compiler configuration
+export interface CompilerConfig {
+  mode: 'types' | 'sync' | 'async';
+  imports?: string[];
+  wasmImport?: string;
+}
+
+// Helper functions
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.substring(1);
+}
+
+function camelCase(s: string): string {
+  return s
+    .split('_')
+    .map((part, index) => (index === 0 ? part.charAt(0).toLowerCase() + part.substring(1) : capitalize(part)))
+    .join('');
+}
+
+function pascalCase(s: string): string {
+  return s.split('_').map(capitalize).join('');
+}
+
+export class SchemaCompiler {
+  private typeCache = new Map<string, TypeInfo>();
+  private functionMetadata: FunctionMetadata[] = [];
+  // WORKTODO(bbapi): AI slop fixup - redundant with typeCache, remove
+  private referencedTypes = new Set<string>();
+
+  constructor(private config: CompilerConfig) {}
+
+  /**
+   * Process API schema and extract function metadata
+   */
+  processApiSchema(commandsSchema: Schema, responsesSchema: Schema): void {
+    // Process types
+    this.processSchema(commandsSchema);
+    this.processSchema(responsesSchema);
+
+    // Extract function metadata from named unions
+    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] = normalResponses[i];
+
+      this.functionMetadata.push({
+        name: camelCase(commandName),
+        commandType: pascalCase(commandName),
+        responseType: pascalCase(responseName),
+      });
+    }
+  }
+
+  /**
+   * Process a schema and populate type cache
+   */
+  processSchema(schema: Schema): TypeInfo {
+    const key = this.getSchemaKey(schema);
+    if (this.typeCache.has(key)) {
+      const ret = this.typeCache.get(key)!;
+      if (ret.typeName === 'unknown') {
+        throw new Error(`Recursive schema detected at ${key}, please check your schema for circular references.`);
+      }
+      return ret;
+    }
+
+    this.typeCache.set(key, { typeName: 'unknown', msgpackTypeName: '' });
+    const typeInfo = this.generateTypeInfo(schema);
+    this.typeCache.set(key, typeInfo);
+    return typeInfo;
+  }
+
+  /**
+   * Generate the complete output
+   */
+  compile(): string {
+    const parts: string[] = ['// AUTOGENERATED FILE - DO NOT EDIT', ''];
+
+    // Generate imports
+    parts.push(...this.generateImports());
+    parts.push('');
+
+    // Generate type declarations only for 'types' mode
+    if (this.config.mode === 'types') {
+      const sortedTypes = Array.from(this.typeCache.values())
+        .filter(t => t.declaration)
+        .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 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('');
+      }
+
+      // 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 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);
+      if (conversions.length > 0) {
+        parts.push('// Conversion functions (exported)');
+        for (const type of conversions) {
+          if (type.toMethod) {
+            parts.push('export ' + type.toMethod, '');
+          }
+          if (type.fromMethod) {
+            parts.push('export ' + type.fromMethod, '');
+          }
+        }
+      }
+
+      // Add BbApiBase interface
+      if (this.functionMetadata.length > 0) {
+        parts.push('', '// Base API interface');
+        parts.push(this.generateBbApiBaseInterface());
+      }
+    }
+
+    // Add API class for non-types modes
+    if (this.config.mode !== 'types' && this.functionMetadata.length > 0) {
+      parts.push(this.generateApiClass());
+    }
+
+    return parts.join('\n') + '\n';
+  }
+
+  private getSchemaKey(schema: Schema): string {
+    if (typeof schema === 'string') return schema;
+    if (Array.isArray(schema)) return JSON.stringify(schema);
+    if (typeof schema === 'object') return (schema as any).__typename || JSON.stringify(schema);
+    return String(schema);
+  }
+
+  private needsTupleHelper(): boolean {
+    return Array.from(this.typeCache.values()).some(t => t.typeName.includes('Tuple<'));
+  }
+
+  private trackTypeUsage(typeName: string): void {
+    // Only track for API modes
+    if (this.config.mode === 'types') return;
+
+    // Extract base types from complex types
+    const baseTypes = this.extractBaseTypes(typeName);
+
+    for (const type of baseTypes) {
+      // Skip built-in types
+      if (['string', 'number', 'boolean', 'Uint8Array'].includes(type)) {
+        continue;
+      }
+
+      this.referencedTypes.add(type);
+    }
+  }
+
+  private extractBaseTypes(typeName: string): string[] {
+    const types: string[] = [];
+
+    // Handle arrays
+    const arrayMatch = typeName.match(/^(.+)\[\]$/);
+    if (arrayMatch) {
+      types.push(...this.extractBaseTypes(arrayMatch[1]));
+      return types;
+    }
+
+    // Handle Tuple
+    const tupleMatch = typeName.match(/^Tuple<(.+),\s*\d+>$/);
+    if (tupleMatch) {
+      types.push(...this.extractBaseTypes(tupleMatch[1]));
+      return types;
+    }
+
+    // Handle Record
+    const recordMatch = typeName.match(/^Record<(.+),\s*(.+)>$/);
+    if (recordMatch) {
+      types.push(...this.extractBaseTypes(recordMatch[1]));
+      types.push(...this.extractBaseTypes(recordMatch[2]));
+      return types;
+    }
+
+    // Handle union types
+    if (typeName.includes(' | ')) {
+      const parts = typeName.split(' | ');
+      for (const part of parts) {
+        types.push(...this.extractBaseTypes(part.trim()));
+      }
+      return types;
+    }
+
+    // Base case - simple type
+    types.push(typeName);
+    return types;
+  }
+
+  private generateTypeInfo(schema: Schema): TypeInfo {
+    if (Array.isArray(schema)) {
+      return this.processArraySchema(schema);
+    } else if (typeof schema === 'string') {
+      return this.processPrimitiveSchema(schema);
+    } else if (typeof schema === 'object') {
+      return this.processObjectSchema(schema);
+    }
+    throw new Error(`Unsupported schema type: ${schema}`);
+  }
+
+  private processArraySchema(schema: any[]): TypeInfo {
+    const [type, ...args] = schema;
+
+    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: `${subtypeInfo.typeName}[]`,
+          msgpackTypeName: `${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}[]`,
+        };
+      }
+
+      case 'variant': {
+        const variants = args[0] as Schema[];
+        const variantInfos = variants.map(v => this.processSchema(v));
+        const typeName = variantInfos.map(v => v.typeName).join(' | ');
+        const msgpackUnion = variantInfos.map(v => v.msgpackTypeName || v.typeName).join(' | ');
+        return {
+          typeName,
+          msgpackTypeName: `[number, ${msgpackUnion}]`,
+        };
+      }
+
+      case 'named_union': {
+        const namedTypes = args[0] as Array<[string, Schema]>;
+        const tupleTypes: string[] = [];
+
+        for (const [name, schemaOrName] of namedTypes) {
+          let typeInfo = this.processSchema(schemaOrName);
+          // Track usage of the type
+          this.trackTypeUsage(typeInfo.typeName);
+          tupleTypes.push(`["${name}", ${typeInfo.typeName}]`);
+        }
+
+        return {
+          typeName: tupleTypes.join(' | '),
+          msgpackTypeName: tupleTypes.join(' | '),
+        };
+      }
+
+      case 'vector': {
+        const [subtype] = args[0];
+        if (subtype === 'unsigned char') {
+          return { typeName: 'Uint8Array' };
+        }
+        const subtypeInfo = this.processSchema(subtype);
+        return {
+          typeName: `${subtypeInfo.typeName}[]`,
+          msgpackTypeName: `${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}[]`,
+        };
+      }
+
+      case 'alias': {
+        const [rawTypeName, msgpackName] = args[0];
+        const typeName = pascalCase(rawTypeName);
+        let targetType: string;
+
+        if (msgpackName.startsWith('bin')) {
+          targetType = 'Uint8Array';
+        } else if (['int', 'unsigned int', 'unsigned short'].includes(msgpackName)) {
+          targetType = 'number';
+        } else {
+          throw new Error(`Unsupported alias type: ${msgpackName}`);
+        }
+
+        // Create a proper type alias declaration
+        return {
+          typeName,
+          msgpackTypeName: targetType,
+          declaration: `export type ${typeName} = ${targetType};`,
+        };
+      }
+
+      case 'shared_ptr': {
+        const [subtype] = args[0];
+        return this.processSchema(subtype);
+      }
+
+      case 'map': {
+        const [keyType, valueType] = args[0];
+        const keyInfo = this.processSchema(keyType);
+        const valueInfo = this.processSchema(valueType);
+        return {
+          typeName: `Record<${keyInfo.typeName}, ${valueInfo.typeName}>`,
+          msgpackTypeName: `Record<${keyInfo.msgpackTypeName || keyInfo.typeName}, ${valueInfo.msgpackTypeName || valueInfo.typeName}>`,
+        };
+      }
+
+      default:
+        throw new Error(`Unsupported array schema type: ${type}`);
+    }
+  }
+
+  private processPrimitiveSchema(schema: string): TypeInfo {
+    switch (schema) {
+      case 'bool':
+        return { typeName: 'boolean' };
+      case 'int':
+      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) };
+    }
+  }
+
+  private processObjectSchema(schema: ObjectSchema): TypeInfo {
+    const typeName = pascalCase(schema.__typename as string);
+    const msgpackTypeName = 'Msgpack' + typeName;
+
+    const declaration = this.generateInterfaces(typeName, schema);
+    const toMethod = this.generateToMethod(typeName, schema);
+    const fromMethod = this.generateFromMethod(typeName, schema);
+
+    return {
+      typeName,
+      msgpackTypeName,
+      declaration,
+      toMethod,
+      fromMethod,
+    };
+  }
+
+  private getOrCreateEmptyType(typeName: string): TypeInfo {
+    const key = `empty_${typeName}`;
+    if (this.typeCache.has(key)) {
+      return this.typeCache.get(key)!;
+    }
+
+    const typeInfo: TypeInfo = {
+      typeName,
+      msgpackTypeName: 'Msgpack' + typeName,
+      declaration: `export interface ${typeName} {}\n\ninterface Msgpack${typeName} {}`,
+      toMethod: `function to${typeName}(o: Msgpack${typeName}): ${typeName} {\n  return {};\n}`,
+      fromMethod: `function from${typeName}(o: ${typeName}): Msgpack${typeName} {\n  return {};\n}`,
+    };
+
+    this.typeCache.set(key, typeInfo);
+    return typeInfo;
+  }
+
+  private generateInterfaces(name: string, schema: ObjectSchema): string {
+    const publicInterface = this.generatePublicInterface(name, schema);
+    const msgpackInterface = this.generateMsgpackInterface(name, schema);
+    return publicInterface + '\n\n' + msgpackInterface;
+  }
+
+  private generatePublicInterface(name: string, schema: ObjectSchema): string {
+    let result = `export interface ${name} {\n`;
+    for (const [key, value] of Object.entries(schema)) {
+      if (key === '__typename') continue;
+      const typeInfo = this.processSchema(value);
+
+      // Track type usage
+      this.trackTypeUsage(typeInfo.typeName);
+
+      result += `  ${camelCase(key)}: ${typeInfo.typeName};\n`;
+    }
+    result += '}';
+    return result;
+  }
+
+  private generateMsgpackInterface(name: string, schema: ObjectSchema): string {
+    let result = `interface Msgpack${name} {\n`;
+    for (const [key, value] of Object.entries(schema)) {
+      if (key === '__typename') continue;
+      const typeInfo = this.processSchema(value);
+      result += `  ${key}: ${typeInfo.msgpackTypeName || typeInfo.typeName};\n`;
+    }
+    result += '}';
+    return result;
+  }
+
+  private generateToMethod(name: string, schema: ObjectSchema): string {
+    const fields = Object.entries(schema).filter(([key]) => key !== '__typename');
+
+    if (fields.length === 0) {
+      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 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};
+  return {
+${conversions}
+  };
+}`;
+  }
+
+  private generateFromMethod(name: string, schema: ObjectSchema): string {
+    const fields = Object.entries(schema).filter(([key]) => key !== '__typename');
+
+    if (fields.length === 0) {
+      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 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};
+  return {
+${conversions}
+  };
+}`;
+  }
+
+  private generateConverter(typeInfo: TypeInfo, value: string, direction: 'to' | 'from'): string {
+    // Handle arrays/tuples
+    if (typeInfo.typeName.includes('[]') || typeInfo.typeName.includes('Tuple<')) {
+      const elementType = typeInfo.typeName.match(/^(.+)\[\]$/) || typeInfo.typeName.match(/^Tuple<(.+),/);
+      if (elementType) {
+        const isTuple = typeInfo.typeName.includes('Tuple<');
+        const mapFn = isTuple ? 'mapTuple' : 'map';
+        return `${value}.${mapFn}((v: any) => v)`; // Simplified for now
+      }
+    }
+
+    // Handle custom types that have conversion methods (not just type aliases)
+    if (typeInfo.toMethod || typeInfo.fromMethod) {
+      return `${direction}${typeInfo.typeName}(${value})`;
+    }
+
+    return value;
+  }
+
+  private generateImports(): string[] {
+    const imports: string[] = [];
+
+    // Base imports
+    if (this.config.imports) {
+      imports.push(...this.config.imports);
+    }
+
+    // For API modes, import from api_types
+    if (this.config.mode !== 'types') {
+      const neededImports = new Set<string>();
+
+      // Add types and conversion functions from function metadata
+      for (const metadata of this.functionMetadata) {
+        neededImports.add(metadata.commandType);
+        neededImports.add(metadata.responseType);
+        neededImports.add(`from${metadata.commandType}`);
+        neededImports.add(`to${metadata.responseType}`);
+      }
+
+      // Add referenced types
+      for (const type of this.referencedTypes) {
+        neededImports.add(type);
+      }
+
+      // Add BbApiBase interface
+      neededImports.add('BbApiBase');
+
+      if (neededImports.size > 0) {
+        const sortedImports = Array.from(neededImports).sort();
+        // Remove duplicates
+        const uniqueImports = sortedImports.filter((item, index) => sortedImports.indexOf(item) === index);
+        imports.push(`import { ${uniqueImports.join(', ')} } from './api_types.js';`);
+      }
+    }
+
+    return imports;
+  }
+
+  private generateBbApiBaseInterface(): string {
+    const methods = this.functionMetadata
+      .map(m => `  ${m.name}(command: ${m.commandType}): Promise<${m.responseType}>;`)
+      .join('\n');
+
+    return `export interface BbApiBase {
+${methods}
+  destroy(): Promise<void>;
+}`;
+  }
+
+  private generateApiClass(): string {
+    const className = this.getApiClassName();
+    const methods = this.functionMetadata.map(m => this.generateApiMethod(m)).join('\n\n');
+
+    // For sync API, don't implement BbApiBase since methods are synchronous
+    const implementsClause = this.config.mode === 'sync' ? '' : ' implements BbApiBase';
+
+    // 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 backend: ${this.getBackendType()}) {}
+
+${methods}
+
+${destroyMethod}
+}`
+    );
+  }
+
+  private getApiClassName(): string {
+    switch (this.config.mode) {
+      case 'sync':
+        return 'SyncApi';
+      case 'async':
+        return 'AsyncApi';
+      default:
+        throw new Error(`Invalid mode: ${this.config.mode}`);
+    }
+  }
+
+  private getBackendType(): string {
+    switch (this.config.mode) {
+      case 'sync':
+        return 'IMsgpackBackendSync';
+      case 'async':
+        return 'IMsgpackBackendAsync';
+      default:
+        return '';
+    }
+  }
+
+  private generateApiMethod(metadata: FunctionMetadata): string {
+    const { name, commandType, responseType } = metadata;
+
+    // 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.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 BBApiException(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+      }
+      return to${responseType}(result);
+    });
+  }`;
+    }
+
+    // For sync mode, keep the synchronous behavior
+    return `  ${name}(command: ${commandType}): ${responseType} {
+    const msgpackCommand = from${commandType}(command);
+    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 BBApiException(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+    }
+    return to${responseType}(result);
+  }`;
+  }
+}
+
+// Factory methods for creating configured compilers
+export function createSharedTypesCompiler(): SchemaCompiler {
+  return new SchemaCompiler({
+    mode: 'types',
+    imports: [],
+  });
+}
+
+export function createSyncApiCompiler(): SchemaCompiler {
+  return new SchemaCompiler({
+    mode: 'sync',
+    imports: [
+      `import { IMsgpackBackendSync } from '../../bb_backends/interface.js';`,
+      `import { Decoder, Encoder } from 'msgpackr';`,
+      `import { BBApiException } from '../../bbapi_exception.js';`,
+    ],
+  });
+}
+
+export function createAsyncApiCompiler(): SchemaCompiler {
+  return new SchemaCompiler({
+    mode: 'async',
+    imports: [
+      `import { IMsgpackBackendAsync } from '../../bb_backends/interface.js';`,
+      `import { Decoder, Encoder } from 'msgpackr';`,
+      `import { BBApiException } from '../../bbapi_exception.js';`,
+    ],
+  });
+}