@aztec/bb.js 0.0.1-alpha.0

package/src/barretenberg_wasm/node/index.ts

@@ -0,0 +1,46 @@
+import { Worker } from 'worker_threads';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readFile } from 'fs/promises';
+import os from 'os';
+import { type BarretenbergWasm, type BarretenbergWasmWorker } from '../barretenberg_wasm.js';
+import { wrap } from 'comlink';
+import { nodeEndpoint } from './node_endpoint.js';
+import { writeSync } from 'fs';
+
+export async function fetchCode(name: string) {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return await readFile(__dirname + '/../../' + name);
+}
+
+export function createWorker() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return new Worker(__dirname + `/worker.js`);
+}
+
+export function getRemoteBarretenbergWasm(worker: Worker): BarretenbergWasmWorker {
+  return wrap<BarretenbergWasm>(nodeEndpoint(worker)) as BarretenbergWasmWorker;
+}
+
+export function getNumCpu() {
+  return os.cpus().length;
+}
+
+/**
+ * In node, the message passing is different to the browser. When using 'debug' in the browser, we seemingly always
+ * get our logs, but in node it looks like it's dependent on the chain of workers from child to main thread be
+ * unblocked. If one of our threads aborts, we can't see it as the parent is blocked waiting on threads to join.
+ * To work around this in node, threads will by default write directly to stdout.
+ */
+export function threadLogger(): ((msg: string) => void) | undefined {
+  return (msg: string) => {
+    writeSync(1, msg + '\n');
+  };
+}
+
+export function killSelf(): never {
+  // Extordinarily hard process termination. Due to how parent threads block on child threads etc, even process.exit
+  // doesn't seem to be able to abort the process. The following does.
+  process.kill(process.pid);
+  throw new Error();
+}

package/src/barretenberg_wasm/node/node_endpoint.ts

@@ -0,0 +1,28 @@
+import { NodeEndpoint } from 'comlink/dist/esm/node-adapter.js';
+
+export function nodeEndpoint(nep: NodeEndpoint) {
+  const listeners = new WeakMap();
+  return {
+    postMessage: nep.postMessage.bind(nep),
+    addEventListener: (_: any, eh: any) => {
+      const l = (data: any) => {
+        if ('handleEvent' in eh) {
+          eh.handleEvent({ data });
+        } else {
+          eh({ data });
+        }
+      };
+      nep.on('message', l);
+      listeners.set(eh, l);
+    },
+    removeEventListener: (_: any, eh: any) => {
+      const l = listeners.get(eh);
+      if (!l) {
+        return;
+      }
+      nep.off('message', l);
+      listeners.delete(eh);
+    },
+    start: nep.start && nep.start.bind(nep),
+  };
+}

package/src/barretenberg_wasm/node/worker.ts

@@ -0,0 +1,10 @@
+import { parentPort } from 'worker_threads';
+import { expose } from 'comlink';
+import { BarretenbergWasm } from '../index.js';
+import { nodeEndpoint } from './node_endpoint.js';
+
+if (!parentPort) {
+  throw new Error('No parentPort');
+}
+
+expose(new BarretenbergWasm(), nodeEndpoint(parentPort));

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 [, , exports = '../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(exports, lang));

package/src/bindgen/mappings.ts

@@ -0,0 +1,66 @@
+/* eslint-disable camelcase */
+const typeMap: { [key: string]: string } = {
+  in_ptr: 'Ptr',
+  out_ptr: 'Ptr',
+  'barretenberg::fr::in_buf': 'Fr',
+  'barretenberg::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,91 @@
+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 { BarretenbergBinder, BarretenbergBinderSync } from '../barretenberg_binder/index.js';
+import { BufferDeserializer, NumberDeserializer, VectorDeserializer, BoolDeserializer, StringDeserializer } from '../serialize/index.js';
+import { Fr, Fq, Point, Buffer32, Buffer128, Ptr } from '../types/index.js';
+
+export class BarretenbergApi {
+  constructor(public binder: BarretenbergBinder) {}
+
+  async destroy() {
+    await this.binder.wasm.destroy();
+  }
+`;
+
+  for (const { functionName, inArgs, outArgs } of functionDeclarations) {
+    try {
+      const parameters = inArgs.map(({ name, type }) => `${toCamelCase(name)}: ${mapType(type)}`).join(', ');
+      const inArgsVar = `[${inArgs.map(arg => toCamelCase(arg.name)).join(', ')}]`;
+      const outTypesVar = `[${outArgs.map(arg => mapDeserializer(arg.type)).join(', ')}]`;
+      const wasmCall = `const result = await this.binder.callWasmExport('${functionName}', ${inArgsVar}, ${outTypesVar});`;
+
+      const n = outArgs.length;
+      const returnStmt = n === 0 ? 'return;' : n === 1 ? 'return result[0];' : 'return result 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}> {
+    ${wasmCall}
+    ${returnStmt}
+  }
+`;
+    } catch (err: any) {
+      throw new Error(`Function ${functionName}: ${err.message}`);
+    }
+  }
+
+  output += `}
+
+export class BarretenbergApiSync {
+  constructor(public binder: BarretenbergBinderSync) {}
+
+  async destroy() {
+    await this.binder.wasm.destroy();
+  }
+`;
+
+  for (const { functionName, inArgs, outArgs } of functionDeclarations) {
+    try {
+      const parameters = inArgs.map(({ name, type }) => `${toCamelCase(name)}: ${mapType(type)}`).join(', ');
+      const inArgsVar = `[${inArgs.map(arg => toCamelCase(arg.name)).join(', ')}]`;
+      const outTypesVar = `[${outArgs.map(arg => mapDeserializer(arg.type)).join(', ')}]`;
+      const wasmCall = `const result = this.binder.callWasmExport('${functionName}', ${inArgsVar}, ${outTypesVar});`;
+
+      const n = outArgs.length;
+      const returnStmt = n === 0 ? 'return;' : n === 1 ? 'return result[0];' : 'return result 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} {
+    ${wasmCall}
+    ${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,60 @@
+import { concatenateUint8Arrays, numToUInt32BE } from '../../serialize/index.js';
+import { NetCrs } 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;
+  }
+}

package/src/crs/browser/index.ts

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

package/src/crs/index.ts

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

package/src/crs/net_crs.ts

@@ -0,0 +1,69 @@
+/**
+ * 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() {
+    const g1Start = 28;
+    const g1End = g1Start + this.numPoints * 64 - 1;
+
+    const response = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/monomial/transcript00.dat', {
+      headers: {
+        Range: `bytes=${g1Start}-${g1End}`,
+      },
+      cache: 'force-cache',
+    });
+
+    return (this.data = new Uint8Array(await response.arrayBuffer()));
+  }
+
+  /**
+   * Download the G2 points data.
+   */
+  async downloadG2Data() {
+    const g2Start = 28 + 5040000 * 64;
+    const g2End = g2Start + 128 - 1;
+
+    const response2 = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/sealed/transcript00.dat', {
+      headers: {
+        Range: `bytes=${g2Start}-${g2End}`,
+      },
+      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;
+  }
+}

package/src/crs/node/file_crs.ts

@@ -0,0 +1,60 @@
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * The path to our SRS object, assuming that we are in barretenberg/ts folder.
+ */
+export const SRS_DEV_PATH = dirname(fileURLToPath(import.meta.url)) + '/../../../cpp/srs_db/ignition/monomial';
+
+/**
+ * Downloader for CRS from a local file (for Node).
+ */
+export class FileCrs {
+  private data!: Uint8Array;
+  private g2Data!: Uint8Array;
+
+  constructor(
+    /**
+     * The number of circuit gates.
+     */
+    public readonly numPoints: number,
+    private path = SRS_DEV_PATH
+  ) {}
+
+  static defaultExists() {
+    return existsSync(SRS_DEV_PATH);
+  }
+
+  /**
+   * Read the data file.
+   */
+  async init() {
+    // We need this.numPoints number of g1 points.
+    // numPoints should be circuitSize + 1.
+    const g1Start = 28;
+    const g1End = g1Start + this.numPoints * 64;
+
+    const data = await readFile(this.path + '/transcript00.dat');
+    this.data = data.subarray(g1Start, g1End);
+
+    this.g2Data = await readFile(this.path + '/g2.dat');
+  }
+
+  /**
+   * 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;
+  }
+}

package/src/crs/node/index.ts

@@ -0,0 +1,48 @@
+import { concatenateUint8Arrays, numToUInt32BE } from '../../serialize/serialize.js';
+import { NetCrs } from '../net_crs.js';
+import { FileCrs } from './file_crs.js';
+
+/**
+ * Generic CRS finder utility class.
+ */
+export class Crs {
+  private crs: FileCrs | NetCrs;
+
+  constructor(
+    /**
+     * The number of circuit gates.
+     */
+    public readonly numPoints: number,
+  ) {
+    this.crs = FileCrs.defaultExists() ? new FileCrs(numPoints) : new NetCrs(numPoints);
+  }
+
+  static async new(numPoints: number) {
+    const crs = new Crs(numPoints);
+    await crs.init();
+    return crs;
+  }
+
+  /**
+   * Read CRS from our chosen source.
+   */
+  async init() {
+    await this.crs.init();
+  }
+
+  /**
+   * G1 points data for prover key.
+   * @returns The points data.
+   */
+  getG1Data(): Uint8Array {
+    return this.crs.getG1Data();
+  }
+
+  /**
+   * G2 points data for verification key.
+   * @returns The points data.
+   */
+  getG2Data(): Uint8Array {
+    return this.crs.getG2Data();
+  }
+}

package/src/examples/simple.rawtest.ts

@@ -0,0 +1,32 @@
+import { Crs } from '../crs/index.js';
+import createDebug from 'debug';
+import { newBarretenbergApiAsync } from '../factory/index.js';
+import { RawBuffer } from '../types/index.js';
+
+createDebug.enable('*');
+const debug = createDebug('simple_test');
+
+async function main() {
+  const CIRCUIT_SIZE = 2 ** 19;
+
+  debug('starting test...');
+  const api = await newBarretenbergApiAsync();
+
+  // Important to init slab allocator as first thing, to ensure maximum memory efficiency.
+  await api.commonInitSlabAllocator(CIRCUIT_SIZE);
+
+  // Plus 1 needed!
+  const crs = await Crs.new(CIRCUIT_SIZE + 1);
+  await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+
+  for (let i = 0; i < 10; ++i) {
+    debug(`iteration ${i} starting...`);
+    await api.examplesSimpleCreateAndVerifyProof();
+  }
+
+  await api.destroy();
+
+  debug('test complete.');
+}
+
+void main();

package/src/examples/simple.test.ts

@@ -0,0 +1,27 @@
+import { Crs } from '../index.js';
+import { BarretenbergApiAsync, newBarretenbergApiAsync } from '../factory/index.js';
+import { RawBuffer } from '../types/index.js';
+
+describe('simple', () => {
+  let api: BarretenbergApiAsync;
+
+  beforeAll(async () => {
+    api = await newBarretenbergApiAsync();
+
+    // Important to init slab allocator as first thing, to ensure maximum memory efficiency.
+    const CIRCUIT_SIZE = 2 ** 19;
+    await api.commonInitSlabAllocator(CIRCUIT_SIZE);
+
+    const crs = await Crs.new(2 ** 19 + 1);
+    await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+  }, 20000);
+
+  afterAll(async () => {
+    await api.destroy();
+  });
+
+  it('should construct 512k gate proof', async () => {
+    const valid = await api.examplesSimpleCreateAndVerifyProof();
+    expect(valid).toBe(true);
+  }, 60000);
+});