@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-fake-ceab37513c

package/src/barretenberg_wasm/barretenberg_wasm.ts

@@ -1,246 +0,0 @@
-import { type Worker } from 'worker_threads';
-import { EventEmitter } from 'events';
-import createDebug from 'debug';
-import { Remote, proxy } from 'comlink';
-import { randomBytes } from '../random/index.js';
-// Webpack config swaps this import with ./browser/index.js
-// You can toggle between these two imports to sanity check the type-safety.
-import { fetchCode, getNumCpu, createWorker, getRemoteBarretenbergWasm, threadLogger, killSelf } from './node/index.js';
-// import { fetchCode, getNumCpu, createWorker, randomBytes } from './browser/index.js';
-
-const debug = createDebug('bb.js:wasm');
-
-EventEmitter.defaultMaxListeners = 30;
-
-export class BarretenbergWasm {
-  static MAX_THREADS = 32;
-  private memStore: { [key: string]: Uint8Array } = {};
-  private memory!: WebAssembly.Memory;
-  private instance!: WebAssembly.Instance;
-  private workers: Worker[] = [];
-  private remoteWasms: BarretenbergWasmWorker[] = [];
-  private nextWorker = 0;
-  private nextThreadId = 1;
-  private isThread = false;
-  private logger: (msg: string) => void = debug;
-
-  public static async new() {
-    const barretenberg = new BarretenbergWasm();
-    await barretenberg.init(1);
-    return barretenberg;
-  }
-
-  /**
-   * Construct and initialise 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 newWorker(threads?: number) {
-    const worker = createWorker();
-    const wasm = getRemoteBarretenbergWasm(worker);
-    await wasm.init(threads, proxy(debug));
-    return { worker, wasm };
-  }
-
-  public getNumThreads() {
-    return this.workers.length + 1;
-  }
-
-  /**
-   * Init as main thread. Spawn child threads.
-   */
-  public async init(
-    threads = Math.min(getNumCpu(), BarretenbergWasm.MAX_THREADS),
-    logger: (msg: string) => void = debug,
-    initial = 25,
-    maximum = 2 ** 16,
-  ) {
-    this.logger = logger;
-
-    const initialMb = (initial * 2 ** 16) / (1024 * 1024);
-    const maxMb = (maximum * 2 ** 16) / (1024 * 1024);
-    this.logger(
-      `initial mem: ${initial} pages, ${initialMb}MiB. ` +
-        `max mem: ${maximum} pages, ${maxMb}MiB. ` +
-        `threads: ${threads}`,
-    );
-
-    this.memory = new WebAssembly.Memory({ initial, maximum, shared: threads > 1 });
-
-    // Annoyingly the wasm declares if it's memory is shared or not. So now we need two wasms if we want to be
-    // able to fallback on "non shared memory" situations.
-    const code = await fetchCode(threads > 1 ? 'barretenberg-threads.wasm' : 'barretenberg.wasm');
-    const { instance, module } = await WebAssembly.instantiate(code, this.getImportObj(this.memory));
-
-    this.instance = instance;
-
-    // Init all global/static data.
-    this.call('_initialize');
-
-    // Create worker threads. Create 1 less than requested, as main thread counts as a thread.
-    this.logger('creating worker threads...');
-    this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createWorker));
-    this.remoteWasms = await Promise.all(this.workers.map(getRemoteBarretenbergWasm));
-    await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory)));
-    this.logger('init complete.');
-  }
-
-  /**
-   * Init as worker thread.
-   */
-  public async initThread(module: WebAssembly.Module, memory: WebAssembly.Memory) {
-    this.isThread = true;
-    this.logger = threadLogger() || this.logger;
-    this.memory = memory;
-    this.instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
-  }
-
-  /**
-   * Called on main thread. Signals child threads to gracefully exit.
-   */
-  public async destroy() {
-    await Promise.all(this.workers.map(w => w.terminate()));
-  }
-
-  private getImportObj(memory: WebAssembly.Memory) {
-    /* eslint-disable camelcase */
-    const importObj = {
-      // We need to implement a part of the wasi api:
-      // https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
-      // We literally only need to support random_get, everything else is noop implementated in barretenberg.wasm.
-      wasi_snapshot_preview1: {
-        random_get: (out: any, length: number) => {
-          out = out >>> 0;
-          const randomData = randomBytes(length);
-          const mem = this.getMemory();
-          mem.set(randomData, out);
-        },
-        clock_time_get: (a1: number, a2: number, out: number) => {
-          out = out >>> 0;
-          const ts = BigInt(new Date().getTime()) * 1000000n;
-          const view = new DataView(this.getMemory().buffer);
-          view.setBigUint64(out, ts, true);
-        },
-        proc_exit: () => {
-          this.logger('HUNG: proc_exit was called. This is caused by unstable experimental wasi pthreads. Try again.');
-          this.logger(new Error().stack!);
-          killSelf();
-        },
-      },
-      wasi: {
-        'thread-spawn': (arg: number) => {
-          arg = arg >>> 0;
-          const id = this.nextThreadId++;
-          const worker = this.nextWorker++ % this.remoteWasms.length;
-          // this.logger(`spawning thread ${id} on worker ${worker} with arg ${arg >>> 0}`);
-          this.remoteWasms[worker].call('wasi_thread_start', id, arg).catch(this.logger);
-          // this.remoteWasms[worker].postMessage({ msg: 'thread', data: { id, arg } });
-          return id;
-        },
-      },
-
-      // These are functions implementations for imports we've defined are needed.
-      // The native C++ build defines these in a module called "env". We must implement TypeScript versions here.
-      env: {
-        env_hardware_concurrency: () => {
-          // If there are no workers (we're already running as a worker, or the main thread requested no workers)
-          // then we return 1, which should cause any algos using threading to just not create a thread.
-          return this.remoteWasms.length + 1;
-        },
-        /**
-         * The 'info' call we use for logging in C++, calls this under the hood.
-         * The native code will just print to std:err (to avoid std::cout which is used for IPC).
-         * Here we just emit the log line for the client to decide what to do with.
-         */
-        logstr: (addr: number) => {
-          const str = this.stringFromAddress(addr);
-          const m = this.getMemory();
-          const str2 = `${str} (mem: ${(m.length / (1024 * 1024)).toFixed(2)}MiB)`;
-          this.logger(str2);
-          if (str2.startsWith('WARNING:')) {
-            this.logger(new Error().stack!);
-          }
-        },
-
-        get_data: (keyAddr: number, outBufAddr: number) => {
-          const key = this.stringFromAddress(keyAddr);
-          outBufAddr = outBufAddr >>> 0;
-          const data = this.memStore[key];
-          if (!data) {
-            this.logger(`get_data miss ${key}`);
-            return;
-          }
-          // this.logger(`get_data hit ${key} size: ${data.length} dest: ${outBufAddr}`);
-          // this.logger(Buffer.from(data.slice(0, 64)).toString('hex'));
-          this.writeMemory(outBufAddr, data);
-        },
-
-        set_data: (keyAddr: number, dataAddr: number, dataLength: number) => {
-          const key = this.stringFromAddress(keyAddr);
-          dataAddr = dataAddr >>> 0;
-          this.memStore[key] = this.getMemorySlice(dataAddr, dataAddr + dataLength).slice();
-          // this.logger(`set_data: ${key} length: ${dataLength}`);
-        },
-
-        memory,
-      },
-    };
-    /* eslint-enable camelcase */
-
-    return importObj;
-  }
-
-  public exports(): any {
-    return this.instance.exports;
-  }
-
-  /**
-   * When returning values from the WASM, use >>> operator to convert signed representation to unsigned representation.
-   */
-  public call(name: string, ...args: any) {
-    if (!this.exports()[name]) {
-      throw new Error(`WASM function ${name} not found.`);
-    }
-    try {
-      return this.exports()[name](...args) >>> 0;
-    } catch (err: any) {
-      const message = `WASM function ${name} aborted, error: ${err}`;
-      this.logger(message);
-      this.logger(err.stack);
-      if (this.isThread) {
-        killSelf();
-      } else {
-        throw err;
-      }
-    }
-  }
-
-  public memSize() {
-    return this.getMemory().length;
-  }
-
-  public getMemorySlice(start: number, end?: number) {
-    return this.getMemory().subarray(start, end);
-  }
-
-  public writeMemory(offset: number, arr: Uint8Array) {
-    const mem = this.getMemory();
-    mem.set(arr, offset);
-  }
-
-  // PRIVATE METHODS
-
-  private getMemory() {
-    return new Uint8Array(this.memory.buffer);
-  }
-
-  private stringFromAddress(addr: number) {
-    addr = addr >>> 0;
-    const m = this.getMemory();
-    let i = addr;
-    for (; m[i] !== 0; ++i);
-    const textDecoder = new TextDecoder('ascii');
-    return textDecoder.decode(m.slice(addr, i));
-  }
-}
-
-export type BarretenbergWasmWorker = Remote<BarretenbergWasm>;

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/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/crs/node/ignition_files_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 IgnitionFilesCrs {
-  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);
-  }, 90000);
-});

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);
-}