@aztec/bb.js 0.0.1-commit.d3ec352c → 0.0.1-commit.e310a4c8

package/src/cbind/schema_compiler.ts

@@ -1,745 +0,0 @@
-/**
- * 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';`,
-    ],
-  });
-}