@aztec/bb.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2

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,8 +72,12 @@ 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');
     }
 
@@ -115,10 +119,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 +132,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 +215,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 +291,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,6 +392,7 @@ export class SchemaCompiler {
       case 'unsigned int':
       case 'unsigned short':
       case 'unsigned long':
+      case 'unsigned char':
       case 'double':
         return { typeName: 'number' };
       case 'string':
@@ -477,15 +478,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 +507,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 +541,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 +589,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,69 +603,77 @@ ${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 !== '${responseType}') {
         throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
       }
@@ -667,131 +685,13 @@ ${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 !== '${responseType}') {
       throw new Error(\`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,7 +706,7 @@ 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';`,
     ],
   });
@@ -816,18 +716,8 @@ 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';`,
     ],
   });
 }

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,5 @@ export {
 } from './barretenberg/index.js';
 
 export { randomBytes } from './random/index.js';
-export { RawBuffer, Fr } from './types/index.js';
+export { Fr } from './types/index.js';
 export { splitHonkProof, reconstructHonkProof, deflattenFields, type ProofData } from './proof/index.js';

package/src/serialize/index.ts

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

package/src/serialize/serialize.ts

@@ -1,5 +1,3 @@
-import { RawBuffer } from '../types/raw_buffer.js';
-
 // For serializing bool.
 export function boolToBuffer(b: boolean) {
   const buf = new Uint8Array(1);
@@ -7,13 +5,6 @@ export function boolToBuffer(b: boolean) {
   return buf;
 }
 
-// For serializing numbers to 32 bit little-endian form.
-export function numToUInt32LE(n: number, bufferSize = 4) {
-  const buf = new Uint8Array(bufferSize);
-  new DataView(buf.buffer).setUint32(buf.byteLength - 4, n, true);
-  return buf;
-}
-
 // For serializing numbers to 32 bit big-endian form.
 export function numToUInt32BE(n: number, bufferSize = 4) {
   const buf = new Uint8Array(bufferSize);
@@ -28,13 +19,6 @@ export function numToInt32BE(n: number, bufferSize = 4) {
   return buf;
 }
 
-// For serializing numbers to 8 bit form.
-export function numToUInt8(n: number) {
-  const buf = new Uint8Array(1);
-  buf[0] = n;
-  return buf;
-}
-
 export function concatenateUint8Arrays(arrayOfUint8Arrays: Uint8Array[]) {
   const totalLength = arrayOfUint8Arrays.reduce((prev, curr) => prev + curr.length, 0);
   const result = new Uint8Array(totalLength);
@@ -46,10 +30,6 @@ export function concatenateUint8Arrays(arrayOfUint8Arrays: Uint8Array[]) {
   return result;
 }
 
-export function uint8ArrayToHexString(uint8Array: Uint8Array) {
-  return uint8Array.reduce((accumulator, byte) => accumulator + byte.toString(16).padStart(2, '0'), '');
-}
-
 // For serializing a buffer as a vector.
 export function serializeBufferToVector(buf: Uint8Array) {
   return concatenateUint8Arrays([numToInt32BE(buf.length), buf]);
@@ -63,71 +43,11 @@ export function serializeBigInt(n: bigint, width = 32) {
   return buf;
 }
 
-export function deserializeBigInt(buf: Uint8Array, offset = 0, width = 32) {
-  let result = 0n;
-  for (let i = 0; i < width; i++) {
-    result = (result << BigInt(8)) | BigInt(buf[offset + i]);
-  }
-  return { elem: result, adv: width };
-}
-
-export function serializeDate(date: Date) {
-  return serializeBigInt(BigInt(date.getTime()), 8);
-}
-
-export function deserializeBufferFromVector(vector: Uint8Array, offset = 0) {
-  const length = new DataView(vector.buffer, vector.byteOffset + offset, 4).getUint32(0, false);
-  const adv = 4 + length;
-  const elem = vector.slice(offset + 4, offset + adv);
-  return { elem, adv };
-}
-
-export function deserializeBool(buf: Uint8Array, offset = 0) {
-  const adv = 1;
-  const elem = buf[offset] !== 0;
-  return { elem, adv };
-}
-
-export function deserializeUInt32(buf: Uint8Array, offset = 0) {
-  const adv = 4;
-  const elem = new DataView(buf.buffer, buf.byteOffset + offset, adv).getUint32(0, false);
-  return { elem, adv };
-}
-
-export function deserializeInt32(buf: Uint8Array, offset = 0) {
-  const adv = 4;
-  const elem = new DataView(buf.buffer, buf.byteOffset + offset, adv).getInt32(0, false);
-  return { elem, adv };
-}
-
-export function deserializeField(buf: Uint8Array, offset = 0) {
-  const adv = 32;
-  const elem = buf.slice(offset, offset + adv);
-  return { elem, adv };
-}
-
 // For serializing an array of fixed length elements.
 export function serializeBufferArrayToVector(arr: Uint8Array[]) {
   return concatenateUint8Arrays([numToUInt32BE(arr.length), ...arr.flat()]);
 }
 
-export function deserializeArrayFromVector<T>(
-  deserialize: (buf: Uint8Array, offset: number) => { elem: T; adv: number },
-  vector: Uint8Array,
-  offset = 0,
-) {
-  let pos = offset;
-  const size = new DataView(vector.buffer, vector.byteOffset + pos, 4).getUint32(0, false);
-  pos += 4;
-  const arr = new Array<T>(size);
-  for (let i = 0; i < size; ++i) {
-    const { elem, adv } = deserialize(vector, pos);
-    pos += adv;
-    arr[i] = elem;
-  }
-  return { elem: arr, adv: pos - offset };
-}
-
 /** A type that can be written to a buffer. */
 export type Bufferable = boolean | Uint8Array | number | string | { toBuffer: () => Uint8Array } | Bufferable[];
 
@@ -139,8 +59,6 @@ export type Bufferable = boolean | Uint8Array | number | string | { toBuffer: ()
 export function serializeBufferable(obj: Bufferable): Uint8Array {
   if (Array.isArray(obj)) {
     return serializeBufferArrayToVector(obj.map(serializeBufferable));
-  } else if (obj instanceof RawBuffer) {
-    return obj;
   } else if (obj instanceof Uint8Array) {
     return serializeBufferToVector(obj);
   } else if (typeof obj === 'boolean') {

package/src/types/fields.ts

@@ -5,7 +5,7 @@ import {
   bigIntToBufferBE,
   bigIntToUint8ArrayBE,
 } from '../bigint-array/index.js';
-import { BufferReader, uint8ArrayToHexString } from '../serialize/index.js';
+import { BufferReader } from '../serialize/index.js';
 
 // TODO(#4189): Replace with implementation in yarn-project/foundation/src/fields/fields.ts
 /**
@@ -61,7 +61,7 @@ export class Fr {
   }
 
   toString() {
-    return '0x' + uint8ArrayToHexString(this.toBuffer());
+    return '0x' + this.toBuffer().reduce((accumulator, byte) => accumulator + byte.toString(16).padStart(2, '0'), '');
   }
 
   equals(rhs: Fr) {