@aztec/bb.js 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/dest/browser/cbind/schema_visitor.js

@@ -0,0 +1,158 @@
+/**
+ * Schema Visitor - Minimal abstraction over raw msgpack schema
+ *
+ * Philosophy:
+ *   - Keep raw schema structure
+ *   - Resolve type references into a graph
+ *   - No normalization - languages handle their own conventions
+ *   - Output is "compiled schema" with resolved types
+ */
+/**
+ * SchemaVisitor - Walks raw msgpack schema and resolves references
+ */
+export class SchemaVisitor {
+    structs = new Map();
+    responses = new Map();
+    visit(commandsSchema, responsesSchema) {
+        // Reset state
+        this.structs.clear();
+        this.responses.clear();
+        const commands = [];
+        // Schema format: ["named_union", [[name, schema], ...]]
+        const commandPairs = commandsSchema[1];
+        const responsePairs = responsesSchema[1];
+        // First, visit all response types (including ErrorResponse)
+        for (const [respName, respSchema] of responsePairs) {
+            if (typeof respSchema !== 'string') {
+                const respStruct = this.visitStruct(respName, respSchema);
+                this.responses.set(respName, respStruct);
+            }
+        }
+        // Visit all commands and pair with responses
+        for (let i = 0; i < commandPairs.length; i++) {
+            const [cmdName, cmdSchema] = commandPairs[i];
+            // Find matching response (skip ErrorResponse which is always last)
+            const normalResponses = responsePairs.filter(([name]) => name !== 'ErrorResponse');
+            const [respName] = normalResponses[i];
+            // Discover command structure
+            const cmdStruct = this.visitStruct(cmdName, cmdSchema);
+            this.structs.set(cmdName, cmdStruct);
+            // Create command mapping
+            commands.push({
+                name: cmdName,
+                fields: cmdStruct.fields,
+                responseType: respName,
+            });
+        }
+        return {
+            structs: this.structs,
+            commands,
+            responses: this.responses,
+        };
+    }
+    visitStruct(name, schema) {
+        const fields = [];
+        // Schema is an object with __typename and fields
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === '__typename')
+                continue;
+            fields.push({
+                name: key,
+                type: this.visitType(value),
+            });
+        }
+        return { name, fields };
+    }
+    visitType(schema) {
+        // Primitive string type
+        if (typeof schema === 'string') {
+            return this.resolvePrimitive(schema);
+        }
+        // Array type descriptor: ['vector', [elementType]]
+        if (Array.isArray(schema)) {
+            const [kind, args] = schema;
+            switch (kind) {
+                case 'vector': {
+                    const [elemType] = args;
+                    // Special case: vector<unsigned char> = bytes
+                    if (elemType === 'unsigned char') {
+                        return { kind: 'primitive', primitive: 'bytes' };
+                    }
+                    return {
+                        kind: 'vector',
+                        element: this.visitType(elemType),
+                    };
+                }
+                case 'array': {
+                    const [elemType, size] = args;
+                    // Special case: array<unsigned char, N> = bytes
+                    if (elemType === 'unsigned char') {
+                        return { kind: 'primitive', primitive: 'bytes' };
+                    }
+                    return {
+                        kind: 'array',
+                        element: this.visitType(elemType),
+                        size,
+                    };
+                }
+                case 'optional': {
+                    const [elemType] = args;
+                    return {
+                        kind: 'optional',
+                        element: this.visitType(elemType),
+                    };
+                }
+                case 'shared_ptr': {
+                    // Dereference shared_ptr - just use inner type
+                    const [innerType] = args;
+                    return this.visitType(innerType);
+                }
+                case 'alias': {
+                    // Alias types (like uint256_t) are treated as bytes
+                    return { kind: 'primitive', primitive: 'bytes' };
+                }
+                default:
+                    throw new Error(`Unknown type kind: ${kind}`);
+            }
+        }
+        // Inline struct definition
+        if (typeof schema === 'object' && schema.__typename) {
+            const structName = schema.__typename;
+            // Check if already visited
+            if (!this.structs.has(structName)) {
+                const struct = this.visitStruct(structName, schema);
+                this.structs.set(structName, struct);
+            }
+            return {
+                kind: 'struct',
+                struct: this.structs.get(structName),
+            };
+        }
+        throw new Error(`Cannot resolve type: ${JSON.stringify(schema)}`);
+    }
+    resolvePrimitive(name) {
+        const primitiveMap = {
+            'bool': 'bool',
+            'int': 'u32',
+            'unsigned int': 'u32',
+            'unsigned short': 'u16',
+            'unsigned long': 'u64',
+            'unsigned char': 'u8',
+            'double': 'f64',
+            'string': 'string',
+            'bin32': 'bytes',
+            'field2': 'field2', // Extension field (Fq2) - pair of field elements
+        };
+        const primitive = primitiveMap[name];
+        if (primitive) {
+            return { kind: 'primitive', primitive };
+        }
+        // Unknown primitive - treat as struct reference
+        // This will be resolved later if it's a real struct
+        return {
+            kind: 'struct',
+            struct: { name, fields: [] }, // Placeholder
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/browser/cbind/typescript_codegen.d.ts

@@ -0,0 +1,30 @@
+/**
+ * TypeScript Code Generator - String template based
+ *
+ * Philosophy:
+ *   - String templates for file structure
+ *   - Simple type mapping
+ *   - Idiomatic TypeScript conventions
+ *   - No complex abstraction
+ */
+import type { CompiledSchema } from './schema_visitor.js';
+export declare class TypeScriptCodegen {
+    private mapType;
+    private mapMsgpackType;
+    private needsConversion;
+    private generateField;
+    private generateMsgpackField;
+    private generateInterface;
+    private generateMsgpackInterface;
+    private generateToFunction;
+    private generateFromFunction;
+    private generateToConverter;
+    private generateFromConverter;
+    generateTypes(schema: CompiledSchema): string;
+    private generateAsyncApiMethod;
+    private generateSyncApiMethod;
+    generateAsyncApi(schema: CompiledSchema): string;
+    generateSyncApi(schema: CompiledSchema): string;
+    private generateApiImports;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXNjcmlwdF9jb2RlZ2VuLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2JpbmQvdHlwZXNjcmlwdF9jb2RlZ2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBRUgsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFnQyxNQUFNLHFCQUFxQixDQUFDO0FBUXhGLHFCQUFhLGlCQUFpQjtJQUU1QixPQUFPLENBQUMsT0FBTztJQWlDZixPQUFPLENBQUMsY0FBYztJQWlDdEIsT0FBTyxDQUFDLGVBQWU7SUFldkIsT0FBTyxDQUFDLGFBQWE7SUFPckIsT0FBTyxDQUFDLG9CQUFvQjtJQU01QixPQUFPLENBQUMsaUJBQWlCO0lBVXpCLE9BQU8sQ0FBQyx3QkFBd0I7SUFVaEMsT0FBTyxDQUFDLGtCQUFrQjtJQThCMUIsT0FBTyxDQUFDLG9CQUFvQjtJQWlDNUIsT0FBTyxDQUFDLG1CQUFtQjtJQXdCM0IsT0FBTyxDQUFDLHFCQUFxQjtJQXdCN0IsYUFBYSxDQUFDLE1BQU0sRUFBRSxjQUFjLEdBQUcsTUFBTSxDQWlENUM7SUFHRCxPQUFPLENBQUMsc0JBQXNCO0lBbUI5QixPQUFPLENBQUMscUJBQXFCO0lBbUI3QixnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsY0FBYyxHQUFHLE1BQU0sQ0E2Qi9DO0lBR0QsZUFBZSxDQUFDLE1BQU0sRUFBRSxjQUFjLEdBQUcsTUFBTSxDQTZCOUM7SUFHRCxPQUFPLENBQUMsa0JBQWtCO0NBbUIzQiJ9

package/dest/browser/cbind/typescript_codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript_codegen.d.ts","sourceRoot":"","sources":["../../../src/cbind/typescript_codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAgC,MAAM,qBAAqB,CAAC;AAQxF,qBAAa,iBAAiB;IAE5B,OAAO,CAAC,OAAO;IAiCf,OAAO,CAAC,cAAc;IAiCtB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,wBAAwB;IAUhC,OAAO,CAAC,kBAAkB;IA8B1B,OAAO,CAAC,oBAAoB;IAiC5B,OAAO,CAAC,mBAAmB;IAwB3B,OAAO,CAAC,qBAAqB;IAwB7B,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAiD5C;IAGD,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,qBAAqB;IAmB7B,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B/C;IAGD,eAAe,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B9C;IAGD,OAAO,CAAC,kBAAkB;CAmB3B"}

package/dest/browser/cbind/typescript_codegen.js

@@ -0,0 +1,365 @@
+/**
+ * TypeScript Code Generator - String template based
+ *
+ * Philosophy:
+ *   - String templates for file structure
+ *   - Simple type mapping
+ *   - Idiomatic TypeScript conventions
+ *   - No complex abstraction
+ */
+import { toPascalCase } from './naming.js';
+function toCamelCase(name) {
+    const pascal = toPascalCase(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+export class TypeScriptCodegen {
+    // Type mapping: Schema type -> TypeScript type
+    mapType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                switch (type.primitive) {
+                    case 'bool': return 'boolean';
+                    case 'u8': return 'number';
+                    case 'u16': return 'number';
+                    case 'u32': return 'number';
+                    case 'u64': return 'number';
+                    case 'f64': return 'number';
+                    case 'string': return 'string';
+                    case 'bytes': return 'Uint8Array';
+                    case 'field2': return '[Uint8Array, Uint8Array]'; // Extension field (Fq2)
+                }
+                break;
+            case 'vector':
+                return `${this.mapType(type.element)}[]`;
+            case 'array':
+                return `${this.mapType(type.element)}[]`;
+            case 'optional':
+                return `${this.mapType(type.element)} | undefined`;
+            case 'struct':
+                return toPascalCase(type.struct.name);
+        }
+        return 'unknown';
+    }
+    // Type mapping for msgpack interfaces (uses Msgpack* prefix for structs)
+    mapMsgpackType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                switch (type.primitive) {
+                    case 'bool': return 'boolean';
+                    case 'u8': return 'number';
+                    case 'u16': return 'number';
+                    case 'u32': return 'number';
+                    case 'u64': return 'number';
+                    case 'f64': return 'number';
+                    case 'string': return 'string';
+                    case 'bytes': return 'Uint8Array';
+                    case 'field2': return '[Uint8Array, Uint8Array]';
+                }
+                break;
+            case 'vector':
+                return `${this.mapMsgpackType(type.element)}[]`;
+            case 'array':
+                return `${this.mapMsgpackType(type.element)}[]`;
+            case 'optional':
+                return `${this.mapMsgpackType(type.element)} | undefined`;
+            case 'struct':
+                return `Msgpack${toPascalCase(type.struct.name)}`;
+        }
+        return 'unknown';
+    }
+    // Check if type needs conversion (has nested structs)
+    needsConversion(type) {
+        switch (type.kind) {
+            case 'primitive':
+                return false;
+            case 'vector':
+            case 'array':
+            case 'optional':
+                return this.needsConversion(type.element);
+            case 'struct':
+                return true;
+        }
+        return false;
+    }
+    // Generate field
+    generateField(field) {
+        const tsName = toCamelCase(field.name);
+        const tsType = this.mapType(field.type);
+        return `  ${tsName}: ${tsType};`;
+    }
+    // Generate msgpack field (original names, uses Msgpack* types for structs)
+    generateMsgpackField(field) {
+        const tsType = this.mapMsgpackType(field.type);
+        return `  ${field.name}: ${tsType};`;
+    }
+    // Generate public interface
+    generateInterface(struct) {
+        const tsName = toPascalCase(struct.name);
+        const fields = struct.fields.map(f => this.generateField(f)).join('\n');
+        return `export interface ${tsName} {
+${fields}
+}`;
+    }
+    // Generate msgpack interface (internal)
+    generateMsgpackInterface(struct) {
+        const tsName = toPascalCase(struct.name);
+        const fields = struct.fields.map(f => this.generateMsgpackField(f)).join('\n');
+        return `interface Msgpack${tsName} {
+${fields}
+}`;
+    }
+    // Generate to* conversion function
+    generateToFunction(struct) {
+        const tsName = toPascalCase(struct.name);
+        if (struct.fields.length === 0) {
+            return `function to${tsName}(o: Msgpack${tsName}): ${tsName} {
+  return {};
+}`;
+        }
+        const checks = struct.fields
+            .map(f => `  if (o.${f.name} === undefined) { throw new Error("Expected ${f.name} in ${tsName} deserialization"); }`)
+            .join('\n');
+        const conversions = struct.fields
+            .map(f => {
+            const tsFieldName = toCamelCase(f.name);
+            const converter = this.generateToConverter(f.type, `o.${f.name}`);
+            return `    ${tsFieldName}: ${converter},`;
+        })
+            .join('\n');
+        return `function to${tsName}(o: Msgpack${tsName}): ${tsName} {
+${checks};
+  return {
+${conversions}
+  };
+}`;
+    }
+    // Generate from* conversion function
+    generateFromFunction(struct) {
+        const tsName = toPascalCase(struct.name);
+        if (struct.fields.length === 0) {
+            return `function from${tsName}(o: ${tsName}): Msgpack${tsName} {
+  return {};
+}`;
+        }
+        const checks = struct.fields
+            .map(f => {
+            const tsFieldName = toCamelCase(f.name);
+            return `  if (o.${tsFieldName} === undefined) { throw new Error("Expected ${tsFieldName} in ${tsName} serialization"); }`;
+        })
+            .join('\n');
+        const conversions = struct.fields
+            .map(f => {
+            const tsFieldName = toCamelCase(f.name);
+            const converter = this.generateFromConverter(f.type, `o.${tsFieldName}`);
+            return `  ${f.name}: ${converter},`;
+        })
+            .join('\n');
+        return `function from${tsName}(o: ${tsName}): Msgpack${tsName} {
+${checks};
+  return {
+${conversions}
+  };
+}`;
+    }
+    // Generate converter for to* function
+    generateToConverter(type, value) {
+        if (!this.needsConversion(type)) {
+            return value;
+        }
+        switch (type.kind) {
+            case 'vector':
+            case 'array':
+                if (this.needsConversion(type.element)) {
+                    return `${value}.map((v: any) => ${this.generateToConverter(type.element, 'v')})`;
+                }
+                return value;
+            case 'optional':
+                if (this.needsConversion(type.element)) {
+                    return `${value} !== undefined ? ${this.generateToConverter(type.element, value)} : undefined`;
+                }
+                return value;
+            case 'struct':
+                return `to${toPascalCase(type.struct.name)}(${value})`;
+        }
+        return value;
+    }
+    // Generate converter for from* function
+    generateFromConverter(type, value) {
+        if (!this.needsConversion(type)) {
+            return value;
+        }
+        switch (type.kind) {
+            case 'vector':
+            case 'array':
+                if (this.needsConversion(type.element)) {
+                    return `${value}.map((v: any) => ${this.generateFromConverter(type.element, 'v')})`;
+                }
+                return value;
+            case 'optional':
+                if (this.needsConversion(type.element)) {
+                    return `${value} !== undefined ? ${this.generateFromConverter(type.element, value)} : undefined`;
+                }
+                return value;
+            case 'struct':
+                return `from${toPascalCase(type.struct.name)}(${value})`;
+        }
+        return value;
+    }
+    // Generate types file (api_types.ts)
+    generateTypes(schema) {
+        const allStructs = [...schema.structs.values(), ...schema.responses.values()];
+        // Public interfaces
+        const publicInterfaces = allStructs
+            .map(s => this.generateInterface(s))
+            .join('\n\n');
+        // Msgpack interfaces
+        const msgpackInterfaces = allStructs
+            .map(s => this.generateMsgpackInterface(s))
+            .join('\n\n');
+        // Conversion functions
+        const toFunctions = allStructs
+            .map(s => 'export ' + this.generateToFunction(s))
+            .join('\n\n');
+        const fromFunctions = allStructs
+            .map(s => 'export ' + this.generateFromFunction(s))
+            .join('\n\n');
+        // BbApiBase interface
+        const apiMethods = schema.commands
+            .map(c => `  ${toCamelCase(c.name)}(command: ${toPascalCase(c.name)}): Promise<${toPascalCase(c.responseType)}>;`)
+            .join('\n');
+        return `// AUTOGENERATED FILE - DO NOT EDIT
+
+// Type aliases for primitive types
+export type Field2 = [Uint8Array, Uint8Array];
+
+// Public interfaces (exported)
+${publicInterfaces}
+
+// Private Msgpack interfaces (not exported)
+${msgpackInterfaces}
+
+// Conversion functions (exported)
+${toFunctions}
+
+${fromFunctions}
+
+// Base API interface
+export interface BbApiBase {
+${apiMethods}
+  destroy(): Promise<void>;
+}
+`;
+    }
+    // Generate API method
+    generateAsyncApiMethod(command) {
+        const methodName = toCamelCase(command.name);
+        const cmdType = toPascalCase(command.name);
+        const respType = toPascalCase(command.responseType);
+        return `  ${methodName}(command: ${cmdType}): Promise<${respType}> {
+    const msgpackCommand = from${cmdType}(command);
+    return msgpackCall(this.backend, [["${command.name}", msgpackCommand]]).then(([variantName, result]: [string, any]) => {
+      if (variantName === 'ErrorResponse') {
+        throw new BBApiException(result.message || 'Unknown error from barretenberg');
+      }
+      if (variantName !== '${command.responseType}') {
+        throw new BBApiException(\`Expected variant name '${command.responseType}' but got '\${variantName}'\`);
+      }
+      return to${respType}(result);
+    });
+  }`;
+    }
+    generateSyncApiMethod(command) {
+        const methodName = toCamelCase(command.name);
+        const cmdType = toPascalCase(command.name);
+        const respType = toPascalCase(command.responseType);
+        return `  ${methodName}(command: ${cmdType}): ${respType} {
+    const msgpackCommand = from${cmdType}(command);
+    const [variantName, result] = msgpackCall(this.backend, [["${command.name}", msgpackCommand]]);
+    if (variantName === 'ErrorResponse') {
+      throw new BBApiException(result.message || 'Unknown error from barretenberg');
+    }
+    if (variantName !== '${command.responseType}') {
+      throw new BBApiException(\`Expected variant name '${command.responseType}' but got '\${variantName}'\`);
+    }
+    return to${respType}(result);
+  }`;
+    }
+    // Generate async API file
+    generateAsyncApi(schema) {
+        const imports = this.generateApiImports(schema);
+        const methods = schema.commands
+            .map(c => this.generateAsyncApiMethod(c))
+            .join('\n\n');
+        return `// AUTOGENERATED FILE - DO NOT EDIT
+
+import { IMsgpackBackendAsync } from '../../bb_backends/interface.js';
+import { Decoder, Encoder } from 'msgpackr';
+import { BBApiException } from '../../bbapi_exception.js';
+${imports}
+
+async function msgpackCall(backend: IMsgpackBackendAsync, input: any[]) {
+  const inputBuffer = new Encoder({ useRecords: false }).pack(input);
+  const encodedResult = await backend.call(inputBuffer);
+  return new Decoder({ useRecords: false }).unpack(encodedResult);
+}
+
+export class AsyncApi implements BbApiBase {
+  constructor(protected backend: IMsgpackBackendAsync) {}
+
+${methods}
+
+  destroy(): Promise<void> {
+    return this.backend.destroy ? this.backend.destroy() : Promise.resolve();
+  }
+}
+`;
+    }
+    // Generate sync API file
+    generateSyncApi(schema) {
+        const imports = this.generateApiImports(schema);
+        const methods = schema.commands
+            .map(c => this.generateSyncApiMethod(c))
+            .join('\n\n');
+        return `// AUTOGENERATED FILE - DO NOT EDIT
+
+import { IMsgpackBackendSync } from '../../bb_backends/interface.js';
+import { Decoder, Encoder } from 'msgpackr';
+import { BBApiException } from '../../bbapi_exception.js';
+${imports}
+
+function msgpackCall(backend: IMsgpackBackendSync, input: any[]) {
+  const inputBuffer = new Encoder({ useRecords: false }).pack(input);
+  const encodedResult = backend.call(inputBuffer);
+  return new Decoder({ useRecords: false }).unpack(encodedResult);
+}
+
+export class SyncApi {
+  constructor(protected backend: IMsgpackBackendSync) {}
+
+${methods}
+
+  destroy(): void {
+    if (this.backend.destroy) this.backend.destroy();
+  }
+}
+`;
+    }
+    // Generate import statement for API files
+    generateApiImports(schema) {
+        const types = new Set();
+        // Add command types and their conversion functions
+        for (const cmd of schema.commands) {
+            const cmdType = toPascalCase(cmd.name);
+            const respType = toPascalCase(cmd.responseType);
+            types.add(cmdType);
+            types.add(respType);
+            types.add(`from${cmdType}`);
+            types.add(`to${respType}`);
+        }
+        // Add BbApiBase
+        types.add('BbApiBase');
+        const sortedTypes = Array.from(types).sort();
+        return `import { ${sortedTypes.join(', ')} } from './api_types.js';`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript_codegen.js","sourceRoot":"","sources":["../../../src/cbind/typescript_codegen.ts"],"names":[],"mappings":"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"}

package/dest/browser/index.d.ts

@@ -1,9 +1,9 @@
 export { Crs, GrumpkinCrs } from './crs/index.js';
-export { type BackendOptions, BackendType, Barretenberg, BarretenbergSync, UltraHonkVerifierBackend, UltraHonkBackend, AztecClientBackend, } from './barretenberg/index.js';
+export { type BackendOptions, BackendType, Barretenberg, BarretenbergSync, UltraHonkVerifierBackend, UltraHonkBackend, AztecClientBackend, fieldToString, fieldsToStrings, type UltraHonkBackendOptions, type VerifierTarget, } from './barretenberg/index.js';
 export { randomBytes } from './random/index.js';
 export { splitHonkProof, reconstructHonkProof, deflattenFields, type ProofData } from './proof/index.js';
 export { BBApiException } from './bbapi_exception.js';
 export type { Bn254G1Point, Bn254G2Point, GrumpkinPoint, Secp256k1Point, Secp256r1Point, Field2, } from './cbind/generated/api_types.js';
 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';
 export { findNapiBinary } from './bb_backends/node/platform.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsR0FBRyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2xELE9BQU8sRUFDTCxLQUFLLGNBQWMsRUFDbkIsV0FBVyxFQUNYLFlBQVksRUFDWixnQkFBZ0IsRUFDaEIsd0JBQXdCLEVBQ3hCLGdCQUFnQixFQUNoQixrQkFBa0IsR0FDbkIsTUFBTSx5QkFBeUIsQ0FBQztBQUVqQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDaEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxvQkFBb0IsRUFBRSxlQUFlLEVBQUUsS0FBSyxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN6RyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFHdEQsWUFBWSxFQUNWLFlBQVksRUFDWixZQUFZLEVBQ1osYUFBYSxFQUNiLGNBQWMsRUFDZCxjQUFjLEVBQ2QsTUFBTSxHQUNQLE1BQU0sZ0NBQWdDLENBQUM7QUFHeEMsT0FBTyxFQUNMLGdCQUFnQixFQUNoQixnQkFBZ0IsRUFDaEIsa0JBQWtCLEVBQ2xCLGtCQUFrQixFQUNsQixtQkFBbUIsRUFDbkIsbUJBQW1CLEVBQ25CLHFCQUFxQixFQUNyQixvQkFBb0IsRUFDcEIsb0JBQW9CLEVBQ3BCLHNCQUFzQixFQUN0QixvQkFBb0IsRUFDcEIsb0JBQW9CLEVBQ3BCLHNCQUFzQixHQUN2QixNQUFNLHNDQUFzQyxDQUFDO0FBRTlDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsR0FBRyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2xELE9BQU8sRUFDTCxLQUFLLGNBQWMsRUFDbkIsV0FBVyxFQUNYLFlBQVksRUFDWixnQkFBZ0IsRUFDaEIsd0JBQXdCLEVBQ3hCLGdCQUFnQixFQUNoQixrQkFBa0IsRUFDbEIsYUFBYSxFQUNiLGVBQWUsRUFDZixLQUFLLHVCQUF1QixFQUM1QixLQUFLLGNBQWMsR0FDcEIsTUFBTSx5QkFBeUIsQ0FBQztBQUVqQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDaEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxvQkFBb0IsRUFBRSxlQUFlLEVBQUUsS0FBSyxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN6RyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFHdEQsWUFBWSxFQUNWLFlBQVksRUFDWixZQUFZLEVBQ1osYUFBYSxFQUNiLGNBQWMsRUFDZCxjQUFjLEVBQ2QsTUFBTSxHQUNQLE1BQU0sZ0NBQWdDLENBQUM7QUFHeEMsT0FBTyxFQUNMLGdCQUFnQixFQUNoQixnQkFBZ0IsRUFDaEIsa0JBQWtCLEVBQ2xCLGtCQUFrQixFQUNsQixtQkFBbUIsRUFDbkIsbUJBQW1CLEVBQ25CLHFCQUFxQixFQUNyQixvQkFBb0IsRUFDcEIsb0JBQW9CLEVBQ3BCLHNCQUFzQixFQUN0QixvQkFBb0IsRUFDcEIsb0JBQW9CLEVBQ3BCLHNCQUFzQixHQUN2QixNQUFNLHNDQUFzQyxDQUFDO0FBRTlDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQyJ9

package/dest/browser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EACL,KAAK,cAAc,EACnB,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzG,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,cAAc,EACd,cAAc,EACd,MAAM,GACP,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EACL,KAAK,cAAc,EACnB,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EAClB,aAAa,EACb,eAAe,EACf,KAAK,uBAAuB,EAC5B,KAAK,cAAc,GACpB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzG,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,cAAc,EACd,cAAc,EACd,MAAM,GACP,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC"}

package/dest/browser/index.js

@@ -1,9 +1,9 @@
 export { Crs, GrumpkinCrs } from './crs/index.js';
-export { BackendType, Barretenberg, BarretenbergSync, UltraHonkVerifierBackend, UltraHonkBackend, AztecClientBackend, } from './barretenberg/index.js';
+export { BackendType, Barretenberg, BarretenbergSync, UltraHonkVerifierBackend, UltraHonkBackend, AztecClientBackend, fieldToString, fieldsToStrings, } from './barretenberg/index.js';
 export { randomBytes } from './random/index.js';
 export { splitHonkProof, reconstructHonkProof, deflattenFields } from './proof/index.js';
 export { BBApiException } from './bbapi_exception.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';
 export { findNapiBinary } from './bb_backends/browser/platform.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEdBQUcsRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNsRCxPQUFPLEVBRUwsV0FBVyxFQUNYLFlBQVksRUFDWixnQkFBZ0IsRUFDaEIsd0JBQXdCLEVBQ3hCLGdCQUFnQixFQUNoQixrQkFBa0IsR0FDbkIsTUFBTSx5QkFBeUIsQ0FBQztBQUVqQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDaEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxvQkFBb0IsRUFBRSxlQUFlLEVBQWtCLE1BQU0sa0JBQWtCLENBQUM7QUFDekcsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBWXRELCtDQUErQztBQUMvQyxPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLGdCQUFnQixFQUNoQixrQkFBa0IsRUFDbEIsa0JBQWtCLEVBQ2xCLG1CQUFtQixFQUNuQixtQkFBbUIsRUFDbkIscUJBQXFCLEVBQ3JCLG9CQUFvQixFQUNwQixvQkFBb0IsRUFDcEIsc0JBQXNCLEVBQ3RCLG9CQUFvQixFQUNwQixvQkFBb0IsRUFDcEIsc0JBQXNCLEdBQ3ZCLE1BQU0sc0NBQXNDLENBQUM7QUFFOUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGdDQUFnQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEdBQUcsRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNsRCxPQUFPLEVBRUwsV0FBVyxFQUNYLFlBQVksRUFDWixnQkFBZ0IsRUFDaEIsd0JBQXdCLEVBQ3hCLGdCQUFnQixFQUNoQixrQkFBa0IsRUFDbEIsYUFBYSxFQUNiLGVBQWUsR0FHaEIsTUFBTSx5QkFBeUIsQ0FBQztBQUVqQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDaEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxvQkFBb0IsRUFBRSxlQUFlLEVBQWtCLE1BQU0sa0JBQWtCLENBQUM7QUFDekcsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBWXRELCtDQUErQztBQUMvQyxPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLGdCQUFnQixFQUNoQixrQkFBa0IsRUFDbEIsa0JBQWtCLEVBQ2xCLG1CQUFtQixFQUNuQixtQkFBbUIsRUFDbkIscUJBQXFCLEVBQ3JCLG9CQUFvQixFQUNwQixvQkFBb0IsRUFDcEIsc0JBQXNCLEVBQ3RCLG9CQUFvQixFQUNwQixvQkFBb0IsRUFDcEIsc0JBQXNCLEdBQ3ZCLE1BQU0sc0NBQXNDLENBQUM7QUFFOUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGdDQUFnQyxDQUFDIn0=