@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.5daedc8

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