@aztec/bb.js 0.0.0-devnet

package/src/barretenberg_wasm/index.test.ts

@@ -0,0 +1,45 @@
+import { type Worker } from 'worker_threads';
+import { BarretenbergWasm, BarretenbergWasmWorker } from './index.js';
+
+describe('barretenberg wasm', () => {
+  let worker!: Worker;
+  let wasm!: BarretenbergWasmWorker;
+
+  beforeAll(async () => {
+    ({ wasm, worker } = await BarretenbergWasm.new(2));
+  }, 20000);
+
+  afterAll(async () => {
+    await wasm.destroy();
+    await worker.terminate();
+  });
+
+  it('should new malloc, transfer and slice mem', async () => {
+    const length = 1024;
+    const ptr = await wasm.call('bbmalloc', length);
+    const buf = Buffer.alloc(length, 128);
+    await wasm.writeMemory(ptr, buf);
+    const result = Buffer.from(await wasm.getMemorySlice(ptr, ptr + length));
+    await wasm.call('bbfree', ptr);
+    expect(result).toStrictEqual(buf);
+  });
+
+  it('test abort', async () => {
+    await expect(() => wasm.call('test_abort')).rejects.toThrow();
+  });
+
+  it('test c/c++ stdout/stderr', async () => {
+    // We're checking we don't crash, but you can manually confirm you see log lines handled by logstr.
+    await wasm.call('test_stdout_stderr');
+  });
+
+  it('should new malloc, transfer and slice mem', async () => {
+    const length = 1024;
+    const ptr = await wasm.call('bbmalloc', length);
+    const buf = Buffer.alloc(length, 128);
+    await wasm.writeMemory(ptr, buf);
+    const result = Buffer.from(await wasm.getMemorySlice(ptr, ptr + length));
+    await wasm.call('bbfree', ptr);
+    expect(result).toStrictEqual(buf);
+  });
+});

package/src/barretenberg_wasm/index.ts

@@ -0,0 +1,50 @@
+import { proxy } from 'comlink';
+import createDebug from 'debug';
+import { createMainWorker } from './barretenberg_wasm_main/factory/node/index.js';
+import { getRemoteBarretenbergWasm, getSharedMemoryAvailable } from './helpers/node/index.js';
+import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from './barretenberg_wasm_main/index.js';
+import { fetchCode } from './fetch_code/index.js';
+
+const debug = createDebug('bb.js:wasm');
+
+export async function fetchModuleAndThreads(desiredThreads = 32) {
+  const shared = getSharedMemoryAvailable();
+
+  const availableThreads = shared ? await getAvailableThreads() : 1;
+  // We limit the number of threads to 32 as we do not benefit from greater numbers.
+  const limitedThreads = Math.min(desiredThreads, availableThreads, 32);
+
+  const code = await fetchCode(shared);
+  const module = await WebAssembly.compile(code);
+  return { module, threads: limitedThreads };
+}
+
+async function getAvailableThreads(): Promise<number> {
+  if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
+    return navigator.hardwareConcurrency;
+  } else {
+    try {
+      const os = await import('os');
+      return os.cpus().length;
+    } catch (e) {
+      debug(`Could not detect environment. Falling back to one thread.: {e}`);
+      return 1;
+    }
+  }
+}
+
+export class BarretenbergWasm extends BarretenbergWasmMain {
+  /**
+   * Construct and initialize BarretenbergWasm within a Worker. Return both the worker and the wasm proxy.
+   * Used when running in the browser, because we can't block the main thread.
+   */
+  public static async new(desiredThreads?: number) {
+    const worker = createMainWorker();
+    const wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
+    const { module, threads } = await fetchModuleAndThreads(desiredThreads);
+    await wasm.init(module, threads, proxy(debug));
+    return { worker, wasm };
+  }
+}
+
+export type BarretenbergWasmWorker = BarretenbergWasmMainWorker;

package/src/benchmark/index.ts

@@ -0,0 +1,26 @@
+import * as fs from 'fs';
+export * from './timer.js';
+
+const bfd = (() => {
+  const bfdStr = process.env.BENCHMARK_FD;
+  const bfd = bfdStr ? parseInt(bfdStr) : -1;
+  if (bfd >= 0 && !fs.fstatSync(bfd)) {
+    throw new Error('fd is not open. Did you redirect in your shell?');
+  }
+  return bfd;
+})();
+
+export function writeBenchmark<T>(name: string, value: T, labels: Record<string, any> = {}) {
+  if (bfd === -1) {
+    return;
+  }
+  const data = {
+    timestamp: new Date().toISOString(),
+    name,
+    type: typeof value,
+    value,
+    ...labels,
+  };
+  const jsonl = JSON.stringify(data) + '\n';
+  fs.writeSync(bfd, jsonl);
+}

package/src/benchmark/timer.ts

@@ -0,0 +1,45 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */
+export class Timer {
+  private start: number;
+
+  constructor() {
+    this.start = performance.now();
+  }
+
+  public us() {
+    return this.ms() * 1000;
+  }
+
+  /**
+   * Returns the elapsed time in milliseconds since the Timer instance was created.
+   * Provides a simple and convenient way to measure the time duration between two events
+   * or monitor performance of specific code sections.
+   *
+   * @returns The elapsed time in milliseconds.
+   */
+  public ms() {
+    return performance.now() - this.start;
+  }
+
+  /**
+   * Returns the time elapsed since the Timer instance was created, in seconds.
+   * The value is calculated by subtracting the initial start time from the current time
+   * and dividing the result by 1000 to convert milliseconds to seconds.
+   *
+   * @returns The elapsed time in seconds.
+   */
+  public s() {
+    return this.ms() / 1000;
+  }
+}

package/src/bigint-array/index.ts

@@ -0,0 +1,21 @@
+export function toBigIntBE(bytes: Uint8Array) {
+  // A Buffer in node, *is* a Uint8Array. We can't refuse it's type.
+  // However the algo below only works on an actual Uint8Array, hence we make a new one to be safe.
+  bytes = new Uint8Array(bytes);
+  let bigint = BigInt(0);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < bytes.byteLength; i++) {
+    bigint = (bigint << BigInt(8)) + BigInt(view.getUint8(i));
+  }
+  return bigint;
+}
+
+export function toBufferBE(value: bigint, byteLength = 32) {
+  const bytes = new Uint8Array(byteLength);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < byteLength; i++) {
+    view.setUint8(byteLength - i - 1, Number(value & BigInt(0xff)));
+    value >>= BigInt(8);
+  }
+  return bytes;
+}

package/src/bindgen/function_declaration.ts

@@ -0,0 +1,11 @@
+export interface Arg {
+  name: string;
+  type: string;
+}
+
+export interface FunctionDeclaration {
+  functionName: string;
+  inArgs: Arg[];
+  outArgs: Arg[];
+  isAsync: boolean;
+}

package/src/bindgen/index.ts

@@ -0,0 +1,17 @@
+import { generateRustCode } from './rust.js';
+import { generateTypeScriptCode } from './typescript.js';
+
+const [, , exp = '../exports.json', lang = 'ts'] = process.argv;
+
+function generateCode(exports: string, lang: string) {
+  switch (lang) {
+    case 'ts':
+      return generateTypeScriptCode(exports);
+    case 'rust':
+      return generateRustCode(exports);
+    default:
+      throw new Error(`Unknown lang: ${lang}`);
+  }
+}
+
+console.log(generateCode(exp, lang));

package/src/bindgen/mappings.ts

@@ -0,0 +1,66 @@
+/* eslint-disable camelcase */
+const typeMap: { [key: string]: string } = {
+  in_ptr: 'Ptr',
+  out_ptr: 'Ptr',
+  'bb::fr::in_buf': 'Fr',
+  'bb::fr::vec_in_buf': 'Fr[]',
+  'fr::in_buf': 'Fr',
+  'fr::out_buf': 'Fr',
+  'fr::vec_in_buf': 'Fr[]',
+  'fr::vec_out_buf': 'Fr[]',
+  'fq::in_buf': 'Fq',
+  'fq::out_buf': 'Fq',
+  'fq::vec_in_buf': 'Fq[]',
+  'fq::vec_out_buf': 'Fq[]',
+  'const uint8_t *': 'Uint8Array',
+  'uint8_t **': 'Uint8Array',
+  in_str_buf: 'string',
+  out_str_buf: 'string',
+  in_buf32: 'Buffer32',
+  out_buf32: 'Buffer32',
+  'uint32_t *': 'number',
+  'const uint32_t *': 'number',
+  'affine_element::in_buf': 'Point',
+  'affine_element::out_buf': 'Point',
+  'const bool *': 'boolean',
+  'bool *': 'boolean',
+  'multisig::MultiSigPublicKey::vec_in_buf': 'Buffer128[]',
+  'multisig::MultiSigPublicKey::out_buf': 'Buffer128',
+  'multisig::RoundOnePublicOutput::vec_in_buf': 'Buffer128[]',
+  'multisig::RoundOnePublicOutput::out_buf': 'Buffer128',
+  'multisig::RoundOnePrivateOutput::in_buf': 'Buffer128',
+  'multisig::RoundOnePrivateOutput::out_buf': 'Buffer128',
+};
+
+const deserializerMap: { [key: string]: string } = {
+  out_ptr: 'Ptr',
+  'fr::out_buf': 'Fr',
+  'fr::vec_out_buf': 'VectorDeserializer(Fr)',
+  'fq::out_buf': 'Fq',
+  'fq::vec_out_buf': 'VectorDeserializer(Fq)',
+  'uint8_t **': 'BufferDeserializer()',
+  out_str_buf: 'StringDeserializer()',
+  out_buf32: 'Buffer32',
+  'uint32_t *': 'NumberDeserializer()',
+  'affine_element::out_buf': 'Point',
+  'bool *': 'BoolDeserializer()',
+  'multisig::MultiSigPublicKey::out_buf': 'Buffer128',
+  'multisig::RoundOnePublicOutput::out_buf': 'Buffer128',
+  'multisig::RoundOnePrivateOutput::out_buf': 'Buffer128',
+};
+
+export function mapType(type: string) {
+  if (typeMap[type]) {
+    return typeMap[type];
+  }
+  throw new Error(`Unknown type: ${type}`);
+}
+
+export const mapRustType = mapType;
+
+export function mapDeserializer(type: string) {
+  if (deserializerMap[type]) {
+    return deserializerMap[type];
+  }
+  throw new Error(`Unknown deserializer for type: ${type}`);
+}

package/src/bindgen/rust.ts

@@ -0,0 +1,52 @@
+import fs from 'fs';
+import { Arg, FunctionDeclaration } from './function_declaration.js';
+import { mapDeserializer, mapRustType } from './mappings.js';
+
+export function generateRustCode(filename: string) {
+  const fileContent = fs.readFileSync(filename, 'utf-8');
+  const functionDeclarations: FunctionDeclaration[] = JSON.parse(fileContent);
+
+  let output = `
+// WARNING: FILE CODE GENERATED BY BINDGEN UTILITY. DO NOT EDIT!
+use crate::call_wasm_export::call_wasm_export;
+use crate::serialize::{BufferDeserializer, NumberDeserializer, VectorDeserializer, BoolDeserializer};
+use crate::types::{Fr, Fq, Point, Buffer32, Buffer128};
+`;
+
+  for (const { functionName, inArgs, outArgs } of functionDeclarations) {
+    const parameters = inArgs.map(({ name, type }) => `${name}: ${mapRustType(type)}`).join(', ');
+    const inArgsVar = `let in_args = vec![${inArgs.map(arg => arg.name).join(', ')}];`;
+    const outTypesVar = `let out_types = vec![${outArgs.map(arg => mapDeserializer(arg.type)).join(', ')}];`;
+    const wasmCall = `let result = call_wasm_export(&"${functionName}", &in_args, &out_types)?;`;
+
+    const returnStmt = getReturnStmt(outArgs);
+    const returnType =
+      outArgs.length === 0
+        ? '-> Result<(), Box<dyn std::error::Error>>'
+        : `-> Result<(${outArgs.map(a => mapRustType(a.type)).join(', ')}), Box<dyn std::error::Error>>`;
+
+    const functionDecl = `
+pub fn ${functionName}(${parameters})${returnType} {
+    ${inArgsVar}
+    ${outTypesVar}
+    ${wasmCall}
+    ${returnStmt}
+}
+`;
+
+    output += functionDecl;
+  }
+
+  return output;
+}
+
+function getReturnStmt(outArgs: Arg[]) {
+  switch (outArgs.length) {
+    case 0:
+      return 'Ok(())';
+    case 1:
+      return `Ok(result[0].clone())`;
+    default:
+      return `Ok((${outArgs.map((_, idx) => `result[${idx}].clone()`).join(', ')}))`;
+  }
+}

package/src/bindgen/to_camel_case.ts

@@ -0,0 +1,10 @@
+export function toCamelCase(input: string): string {
+  const words = input.split('_');
+  const camelCasedWords = words.map((word, index) => {
+    if (index === 0) {
+      return word;
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  });
+  return camelCasedWords.join('');
+}

package/src/bindgen/typescript.ts

@@ -0,0 +1,116 @@
+import fs from 'fs';
+import { mapDeserializer, mapType } from './mappings.js';
+import { toCamelCase } from './to_camel_case.js';
+import { FunctionDeclaration } from './function_declaration.js';
+
+export function generateTypeScriptCode(filename: string) {
+  const fileContent = fs.readFileSync(filename, 'utf-8');
+  const functionDeclarations: FunctionDeclaration[] = JSON.parse(fileContent);
+
+  let output = `// WARNING: FILE CODE GENERATED BY BINDGEN UTILITY. DO NOT EDIT!
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { BarretenbergWasmWorker, BarretenbergWasm } from '../barretenberg_wasm/index.js';
+import { BufferDeserializer, NumberDeserializer, VectorDeserializer, BoolDeserializer, StringDeserializer, serializeBufferable, OutputType } from '../serialize/index.js';
+import { Fr, Fq, Point, Buffer32, Buffer128, Ptr } from '../types/index.js';
+
+`;
+
+  output += generateClass(functionDeclarations);
+  output += generateSyncClass(functionDeclarations);
+
+  return output;
+}
+
+function generateClass(functionDeclarations: FunctionDeclaration[]) {
+  let output = `
+export class BarretenbergApi {
+  constructor(protected wasm: BarretenbergWasmWorker) {}
+
+`;
+
+  for (const { functionName, inArgs, outArgs } of functionDeclarations) {
+    try {
+      const parameters = inArgs.map(({ name, type }) => `${toCamelCase(name)}: ${mapType(type)}`).join(', ');
+      const inArgsVar = `const inArgs = [${inArgs
+        .map(arg => toCamelCase(arg.name))
+        .join(', ')}].map(serializeBufferable);`;
+      const outTypesVar = `const outTypes: OutputType[] = [${outArgs
+        .map(arg => mapDeserializer(arg.type))
+        .join(', ')}];`;
+      const wasmCall = `const result = await this.wasm.callWasmExport('${functionName}', inArgs, outTypes.map(t=>t.SIZE_IN_BYTES));`;
+      const outVar = `const out = result.map((r, i) => outTypes[i].fromBuffer(r));`;
+
+      const n = outArgs.length;
+      const returnStmt = n === 0 ? 'return;' : n === 1 ? 'return out[0];' : 'return out as any;';
+      const returnType =
+        outArgs.length === 0
+          ? 'void'
+          : outArgs.length === 1
+          ? `${mapType(outArgs[0].type)}`
+          : `[${outArgs.map(a => mapType(a.type)).join(', ')}]`;
+
+      output += `
+  async ${toCamelCase(functionName)}(${parameters}): Promise<${returnType}> {
+    ${inArgsVar}
+    ${outTypesVar}
+    ${wasmCall}
+    ${outVar}
+    ${returnStmt}
+  }
+`;
+    } catch (err: any) {
+      throw new Error(`Function ${functionName}: ${err.message}`);
+    }
+  }
+
+  output += `}`;
+
+  return output;
+}
+
+function generateSyncClass(functionDeclarations: FunctionDeclaration[]) {
+  let output = `
+export class BarretenbergApiSync {
+  constructor(protected wasm: BarretenbergWasm) {}
+
+`;
+
+  for (const { functionName, inArgs, outArgs } of functionDeclarations) {
+    try {
+      const parameters = inArgs.map(({ name, type }) => `${toCamelCase(name)}: ${mapType(type)}`).join(', ');
+      const inArgsVar = `const inArgs = [${inArgs
+        .map(arg => toCamelCase(arg.name))
+        .join(', ')}].map(serializeBufferable);`;
+      const outTypesVar = `const outTypes: OutputType[] = [${outArgs
+        .map(arg => mapDeserializer(arg.type))
+        .join(', ')}];`;
+      const wasmCall = `const result = this.wasm.callWasmExport('${functionName}', inArgs, outTypes.map(t=>t.SIZE_IN_BYTES));`;
+      const outVar = `const out = result.map((r, i) => outTypes[i].fromBuffer(r));`;
+
+      const n = outArgs.length;
+      const returnStmt = n === 0 ? 'return;' : n === 1 ? 'return out[0];' : 'return out as any;';
+      const returnType =
+        outArgs.length === 0
+          ? 'void'
+          : outArgs.length === 1
+          ? `${mapType(outArgs[0].type)}`
+          : `[${outArgs.map(a => mapType(a.type)).join(', ')}]`;
+
+      output += `
+  ${toCamelCase(functionName)}(${parameters}): ${returnType} {
+    ${inArgsVar}
+    ${outTypesVar}
+    ${wasmCall}
+    ${outVar}
+    ${returnStmt}
+  }
+`;
+    } catch (err: any) {
+      throw new Error(`Function ${functionName}: ${err.message}`);
+    }
+  }
+
+  output += `}`;
+
+  return output;
+}

package/src/crs/browser/cached_net_crs.ts

@@ -0,0 +1,99 @@
+import { NetCrs, NetGrumpkinCrs } from '../net_crs.js';
+import { get, set } from 'idb-keyval';
+
+/**
+ * Downloader for CRS from the web or local.
+ */
+export class CachedNetCrs {
+  private g1Data!: Uint8Array;
+  private g2Data!: Uint8Array;
+
+  constructor(public readonly numPoints: number) {}
+
+  static async new(numPoints: number) {
+    const crs = new CachedNetCrs(numPoints);
+    await crs.init();
+    return crs;
+  }
+
+  /**
+   * Download the data.
+   */
+  async init() {
+    // Check if data is in IndexedDB
+    const g1Data = await get('g1Data');
+    const g2Data = await get('g2Data');
+    const netCrs = new NetCrs(this.numPoints);
+    const g1DataLength = this.numPoints * 64;
+
+    if (!g1Data || g1Data.length < g1DataLength) {
+      this.g1Data = await netCrs.downloadG1Data();
+      await set('g1Data', this.g1Data);
+    } else {
+      this.g1Data = g1Data;
+    }
+
+    if (!g2Data) {
+      this.g2Data = await netCrs.downloadG2Data();
+      await set('g2Data', this.g2Data);
+    } else {
+      this.g2Data = g2Data;
+    }
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return this.g1Data;
+  }
+
+  /**
+   * G2 points data for verification key.
+   * @returns The points data.
+   */
+  getG2Data(): Uint8Array {
+    return this.g2Data;
+  }
+}
+
+/**
+ * Downloader for CRS from the web or local.
+ */
+export class CachedNetGrumpkinCrs {
+  private g1Data!: Uint8Array;
+
+  constructor(public readonly numPoints: number) {}
+
+  static async new(numPoints: number) {
+    const crs = new CachedNetGrumpkinCrs(numPoints);
+    await crs.init();
+    return crs;
+  }
+
+  /**
+   * Download the data.
+   */
+  async init() {
+    // Check if data is in IndexedDB
+    const g1Data = await get('grumpkinG1Data');
+    const netGrumpkinCrs = new NetGrumpkinCrs(this.numPoints);
+    const g1DataLength = this.numPoints * 64;
+
+    if (!g1Data || g1Data.length < g1DataLength) {
+      this.g1Data = await netGrumpkinCrs.downloadG1Data();
+      await set('grumpkinG1Data', this.g1Data);
+    } else {
+      this.g1Data = g1Data;
+    }
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return this.g1Data;
+  }
+}

package/src/crs/browser/index.ts

@@ -0,0 +1 @@
+export { CachedNetCrs as Crs, CachedNetGrumpkinCrs as GrumpkinCrs } from './cached_net_crs.js';

package/src/crs/index.ts

@@ -0,0 +1 @@
+export { Crs, GrumpkinCrs } from './node/index.js';

package/src/crs/net_crs.ts

@@ -0,0 +1,115 @@
+/**
+ * Downloader for CRS from the web or local.
+ */
+export class NetCrs {
+  private data!: Uint8Array;
+  private g2Data!: Uint8Array;
+
+  constructor(
+    /**
+     * The number of circuit gates.
+     */
+    public readonly numPoints: number,
+  ) {}
+
+  /**
+   * Download the data.
+   */
+  async init() {
+    await this.downloadG1Data();
+    await this.downloadG2Data();
+  }
+
+  async downloadG1Data() {
+    // Skip the download if numPoints is 0 (would download the entire file due to bad range header otherwise)
+    if (this.numPoints === 0) {
+      return (this.data = new Uint8Array([]));
+    }
+
+    const g1End = this.numPoints * 64 - 1;
+
+    const response = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g1.dat', {
+      headers: {
+        Range: `bytes=0-${g1End}`,
+      },
+      cache: 'force-cache',
+    });
+
+    return (this.data = new Uint8Array(await response.arrayBuffer()));
+  }
+
+  /**
+   * Download the G2 points data.
+   */
+  async downloadG2Data() {
+    const response2 = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g2.dat', {
+      cache: 'force-cache',
+    });
+
+    return (this.g2Data = new Uint8Array(await response2.arrayBuffer()));
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return this.data;
+  }
+
+  /**
+   * G2 points data for verification key.
+   * @returns The points data.
+   */
+  getG2Data(): Uint8Array {
+    return this.g2Data;
+  }
+}
+
+/**
+ * Downloader for CRS from the web or local.
+ */
+export class NetGrumpkinCrs {
+  private data!: Uint8Array;
+
+  constructor(
+    /**
+     * The number of circuit gates.
+     */
+    public readonly numPoints: number,
+  ) {}
+
+  /**
+   * Download the data.
+   */
+  async init() {
+    await this.downloadG1Data();
+  }
+
+  async downloadG1Data() {
+    // Skip the download if numPoints is 0 (would download the entire file due to bad range header otherwise)
+    if (this.numPoints === 0) {
+      return (this.data = new Uint8Array([]));
+    }
+
+    const g1Start = 28;
+    const g1End = this.numPoints * 64 - 1;
+
+    const response = await fetch('https://aztec-ignition.s3.amazonaws.com/TEST%20GRUMPKIN/monomial/transcript00.dat', {
+      headers: {
+        Range: `bytes=${g1Start}-${g1End}`,
+      },
+      cache: 'force-cache',
+    });
+
+    return (this.data = new Uint8Array(await response.arrayBuffer()));
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return this.data;
+  }
+}