@aztec/bb.js 0.0.1-alpha.6 → 0.0.1-commit.21caa21

package/src/barretenberg_wasm/browser/index.ts

@@ -1,32 +0,0 @@
-import { wrap } from 'comlink';
-import { BarretenbergWasmWorker, type BarretenbergWasm } from '../barretenberg_wasm.js';
-import debug from 'debug';
-
-export async function fetchCode(name: string) {
-  const res = await fetch('/' + name);
-  return await res.arrayBuffer();
-}
-
-export function createWorker() {
-  const worker = new Worker('barretenberg_wasm.js');
-  const debugStr = debug.disable();
-  debug.enable(debugStr);
-  worker.postMessage({ debug: debugStr });
-  return worker;
-}
-
-export function getRemoteBarretenbergWasm(worker: Worker): BarretenbergWasmWorker {
-  return wrap<BarretenbergWasm>(worker);
-}
-
-export function getNumCpu() {
-  return navigator.hardwareConcurrency;
-}
-
-export function threadLogger(): ((msg: string) => void) | undefined {
-  return undefined;
-}
-
-export function killSelf() {
-  self.close();
-}

package/src/barretenberg_wasm/browser/worker.ts

@@ -1,13 +0,0 @@
-import { expose } from 'comlink';
-import { BarretenbergWasm } from '../index.js';
-import debug from 'debug';
-
-self.onmessage = function (e) {
-  if (e.data.debug) {
-    debug.enable(e.data.debug);
-  }
-};
-
-expose(new BarretenbergWasm());
-
-self.postMessage({ ready: true });

package/src/barretenberg_wasm/node/index.ts

@@ -1,46 +0,0 @@
-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/worker.ts

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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

package/src/bindgen/index.ts

@@ -1,17 +0,0 @@
-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

@@ -1,66 +0,0 @@
-/* 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

@@ -1,52 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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/node/file_crs.ts

@@ -1,60 +0,0 @@
-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/examples/simple.rawtest.ts

@@ -1,37 +0,0 @@
-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()));
-
-  const iterations = 10;
-  let totalTime = 0;
-  for (let i = 0; i < iterations; ++i) {
-    const start = new Date().getTime();
-    debug(`iteration ${i} starting...`);
-    await api.examplesSimpleCreateAndVerifyProof();
-    totalTime += new Date().getTime() - start;
-  }
-
-  await api.destroy();
-
-  debug(`avg iteration time: ${totalTime / iterations}ms`);
-  debug('test complete.');
-}
-
-void main();

package/src/examples/simple.test.ts

@@ -1,27 +0,0 @@
-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);
-});

package/src/factory/index.ts

@@ -1,36 +0,0 @@
-import { BarretenbergApi, BarretenbergApiSync } from '../barretenberg_api/index.js';
-import { BarretenbergBinder, BarretenbergBinderSync } from '../barretenberg_binder/index.js';
-import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/index.js';
-
-/**
- * Returns a single threaded, synchronous, barretenberg api.
- * Can be used on the main thread to perform small light-weight requests like hashing etc.
- */
-export async function newBarretenbergApiSync() {
-  return new BarretenbergApiSync(new BarretenbergBinderSync(await BarretenbergWasm.new()));
-}
-
-export class BarretenbergApiAsync extends BarretenbergApi {
-  constructor(private worker: any, private wasm: BarretenbergWasmWorker) {
-    super(new BarretenbergBinder(wasm));
-  }
-
-  async getNumThreads() {
-    return await this.wasm.getNumThreads();
-  }
-
-  async destroy() {
-    await this.wasm.destroy();
-    await this.worker.terminate();
-  }
-}
-
-/**
- * Returns a multi threaded, asynchronous, barretenberg api.
- * It runs in a worker, and so can be used within the browser to execute long running, multi-threaded requests
- * like proof construction etc.
- */
-export async function newBarretenbergApiAsync(threads?: number) {
-  const { wasm, worker } = await BarretenbergWasm.newWorker(threads);
-  return new BarretenbergApiAsync(worker, wasm);
-}