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

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

package/src/main.ts

@@ -1,311 +0,0 @@
-#!/usr/bin/env -S node --no-warnings
-import { Crs, BarretenbergApiAsync, newBarretenbergApiAsync, RawBuffer } from './index.js';
-import createDebug from 'debug';
-import { readFileSync, writeFileSync } from 'fs';
-import { gunzipSync } from 'zlib';
-import { numToUInt32BE } from './serialize/serialize.js';
-import { Command } from 'commander';
-
-createDebug.log = console.error.bind(console);
-const debug = createDebug('bb.js');
-
-// Maximum we support.
-const MAX_CIRCUIT_SIZE = 2 ** 19;
-
-function getJsonData(jsonPath: string) {
-  const json = readFileSync(jsonPath, 'utf-8');
-  const parsed = JSON.parse(json);
-  return parsed;
-}
-
-function getBytecode(jsonPath: string) {
-  const parsed = getJsonData(jsonPath);
-  const buffer = Buffer.from(parsed.bytecode, 'base64');
-  const decompressed = gunzipSync(buffer);
-  return decompressed;
-}
-
-async function getGates(jsonPath: string, api: BarretenbergApiAsync) {
-  const parsed = getJsonData(jsonPath);
-  if (parsed.gates) {
-    return +parsed.gates;
-  }
-  const { total } = await computeCircuitSize(jsonPath, api);
-  const jsonData = getJsonData(jsonPath);
-  jsonData.gates = total;
-  writeFileSync(jsonPath, JSON.stringify(jsonData));
-  return total;
-}
-
-function getWitness(witnessPath: string) {
-  const data = readFileSync(witnessPath);
-  return Buffer.concat([numToUInt32BE(data.length / 32), data]);
-}
-
-async function computeCircuitSize(jsonPath: string, api: BarretenbergApiAsync) {
-  debug(`computing circuit size...`);
-  const bytecode = getBytecode(jsonPath);
-  const [exact, total, subgroup] = await api.acirGetCircuitSizes(new RawBuffer(bytecode));
-  return { exact, total, subgroup };
-}
-
-async function init(jsonPath: string) {
-  const api = await newBarretenbergApiAsync();
-
-  const circuitSize = await getGates(jsonPath, api);
-  const subgroupSize = Math.pow(2, Math.ceil(Math.log2(circuitSize)));
-  if (subgroupSize > MAX_CIRCUIT_SIZE) {
-    throw new Error(`Circuit size of ${subgroupSize} exceeds max supported of ${MAX_CIRCUIT_SIZE}`);
-  }
-
-  debug(`circuit size: ${circuitSize}`);
-  debug(`subgroup size: ${subgroupSize}`);
-  debug('loading crs...');
-  // Plus 1 needed! (Move +1 into Crs?)
-  const crs = await Crs.new(subgroupSize + 1);
-
-  // Important to init slab allocator as first thing, to ensure maximum memory efficiency.
-  await api.commonInitSlabAllocator(subgroupSize);
-
-  // Load CRS into wasm global CRS state.
-  // TODO: Make RawBuffer be default behaviour, and have a specific Vector type for when wanting length prefixed.
-  await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
-
-  const acirComposer = await api.acirNewAcirComposer(subgroupSize);
-  return { api, acirComposer, circuitSize: subgroupSize };
-}
-
-async function initLite() {
-  const api = await newBarretenbergApiAsync(1);
-
-  // Plus 1 needed! (Move +1 into Crs?)
-  const crs = await Crs.new(1);
-
-  // Load CRS into wasm global CRS state.
-  await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
-
-  const acirComposer = await api.acirNewAcirComposer(0);
-  return { api, acirComposer };
-}
-
-export async function proveAndVerify(jsonPath: string, witnessPath: string, isRecursive: boolean) {
-  const { api, acirComposer } = await init(jsonPath);
-  try {
-    debug(`creating proof...`);
-    const bytecode = getBytecode(jsonPath);
-    const witness = getWitness(witnessPath);
-    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), isRecursive);
-
-    debug(`verifying...`);
-    const verified = await api.acirVerifyProof(acirComposer, proof, isRecursive);
-    console.log(`verified: ${verified}`);
-    return verified;
-  } finally {
-    await api.destroy();
-  }
-}
-
-export async function prove(jsonPath: string, witnessPath: string, isRecursive: boolean, outputPath: string) {
-  const { api, acirComposer } = await init(jsonPath);
-  try {
-    debug(`creating proof...`);
-    const bytecode = getBytecode(jsonPath);
-    const witness = getWitness(witnessPath);
-    const proof = await api.acirCreateProof(acirComposer, new RawBuffer(bytecode), new RawBuffer(witness), isRecursive);
-    debug(`done.`);
-
-    writeFileSync(outputPath, proof);
-    console.log(`proof written to: ${outputPath}`);
-  } finally {
-    await api.destroy();
-  }
-}
-
-export async function gateCount(jsonPath: string) {
-  const api = await newBarretenbergApiAsync(1);
-  try {
-    console.log(`gates: ${await getGates(jsonPath, api)}`);
-  } finally {
-    await api.destroy();
-  }
-}
-
-export async function verify(proofPath: string, isRecursive: boolean, vkPath: string) {
-  const { api, acirComposer } = await initLite();
-  try {
-    await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
-    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath), isRecursive);
-    console.log(`verified: ${verified}`);
-    return verified;
-  } finally {
-    await api.destroy();
-  }
-}
-
-export async function contract(outputPath: string, vkPath: string) {
-  const { api, acirComposer } = await initLite();
-  try {
-    await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
-    const contract = await api.acirGetSolidityVerifier(acirComposer);
-    if (outputPath === '-') {
-      console.log(contract);
-    } else {
-      writeFileSync(outputPath, contract);
-      console.log(`contract written to: ${outputPath}`);
-    }
-  } finally {
-    await api.destroy();
-  }
-}
-
-export async function writeVk(jsonPath: string, outputPath: string) {
-  const { api, acirComposer } = await init(jsonPath);
-  try {
-    debug('initing proving key...');
-    const bytecode = getBytecode(jsonPath);
-    await api.acirInitProvingKey(acirComposer, new RawBuffer(bytecode));
-
-    debug('initing verification key...');
-    const vk = await api.acirGetVerificationKey(acirComposer);
-    if (outputPath === '-') {
-      process.stdout.write(vk);
-    } else {
-      writeFileSync(outputPath, vk);
-      console.log(`vk written to: ${outputPath}`);
-    }
-  } finally {
-    await api.destroy();
-  }
-}
-
-export async function proofAsFields(proofPath: string, numInnerPublicInputs: number, outputPath: string) {
-  const { api, acirComposer } = await initLite();
-
-  try {
-    debug('serializing proof byte array into field elements');
-    const proofAsFields = await api.acirSerializeProofIntoFields(
-      acirComposer,
-      readFileSync(proofPath),
-      numInnerPublicInputs,
-    );
-
-    writeFileSync(outputPath, JSON.stringify(proofAsFields.map(f => f.toString())));
-    debug('done.');
-  } finally {
-    await api.destroy();
-  }
-}
-
-export async function vkAsFields(vkPath: string, vkeyOutputPath: string) {
-  const { api, acirComposer } = await initLite();
-
-  try {
-    debug('serializing vk byte array into field elements');
-    await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
-    const [vkAsFields, vkHash] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
-    const output = [vkHash, ...vkAsFields].map(f => f.toString());
-    writeFileSync(vkeyOutputPath, JSON.stringify(output));
-    debug('done.');
-  } finally {
-    await api.destroy();
-  }
-}
-
-const program = new Command();
-
-program.option('-v, --verbose', 'enable verbose logging', false);
-
-function handleGlobalOptions() {
-  if (program.opts().verbose) {
-    createDebug.enable('bb.js*');
-  }
-}
-
-program
-  .command('prove_and_verify')
-  .description('Generate a proof and verify it. Process exits with success or failure code.')
-  .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
-  .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
-  .option('-r, --recursive', 'prove and verify using recursive prover and verifier', false)
-  .action(async ({ jsonPath, witnessPath, recursive }) => {
-    handleGlobalOptions();
-    const result = await proveAndVerify(jsonPath, witnessPath, recursive);
-    process.exit(result ? 0 : 1);
-  });
-
-program
-  .command('prove')
-  .description('Generate a proof and write it to a file.')
-  .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
-  .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.tr')
-  .option('-r, --recursive', 'prove using recursive prover', false)
-  .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
-  .action(async ({ jsonPath, witnessPath, recursive, outputPath }) => {
-    handleGlobalOptions();
-    await prove(jsonPath, witnessPath, recursive, outputPath);
-  });
-
-program
-  .command('gates')
-  .description('Print gate count to standard output.')
-  .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
-  .action(async ({ jsonPath }) => {
-    handleGlobalOptions();
-    await gateCount(jsonPath);
-  });
-
-program
-  .command('verify')
-  .description('Verify a proof. Process exists with success or failure code.')
-  .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
-  .option('-r, --recursive', 'prove using recursive prover', false)
-  .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
-  .action(async ({ proofPath, recursive, vk }) => {
-    handleGlobalOptions();
-    const result = await verify(proofPath, recursive, vk);
-    process.exit(result ? 0 : 1);
-  });
-
-program
-  .command('contract')
-  .description('Output solidity verification key contract.')
-  .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
-  .option('-o, --output-path <path>', 'Specify the path to write the contract', '-')
-  .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
-  .action(async ({ outputPath, vk }) => {
-    handleGlobalOptions();
-    await contract(outputPath, vk);
-  });
-
-program
-  .command('write_vk')
-  .description('Output verification key.')
-  .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
-  .requiredOption('-o, --output-path <path>', 'Specify the path to write the key')
-  .action(async ({ jsonPath, outputPath }) => {
-    handleGlobalOptions();
-    await writeVk(jsonPath, outputPath);
-  });
-
-program
-  .command('proof_as_fields')
-  .description('Return the proof as fields elements')
-  .requiredOption('-p, --proof-path <path>', 'Specify the proof path')
-  .requiredOption('-n, --num-public-inputs <number>', 'Specify the number of public inputs')
-  .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
-  .action(async ({ proofPath, numPublicInputs, outputPath }) => {
-    handleGlobalOptions();
-    await proofAsFields(proofPath, numPublicInputs, outputPath);
-  });
-
-program
-  .command('vk_as_fields')
-  .description('Return the verifiation key represented as fields elements. Also return the verification key hash.')
-  .requiredOption('-i, --input-path <path>', 'Specifies the vk path (output from write_vk)')
-  .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the verification key fields and key hash')
-  .action(async ({ inputPath, outputPath }) => {
-    handleGlobalOptions();
-    await vkAsFields(inputPath, outputPath);
-  });
-
-program.name('bb.js').parse(process.argv);

package/src/serialize/buffer_reader.ts

@@ -1,82 +0,0 @@
-export class BufferReader {
-  private index: number;
-  constructor(private buffer: Uint8Array, offset = 0) {
-    this.index = offset;
-  }
-
-  public static asReader(bufferOrReader: Uint8Array | BufferReader) {
-    return bufferOrReader instanceof BufferReader ? bufferOrReader : new BufferReader(bufferOrReader);
-  }
-
-  public readNumber(): number {
-    const dataView = new DataView(this.buffer.buffer, this.buffer.byteOffset + this.index, 4);
-    this.index += 4;
-    return dataView.getUint32(0, false);
-  }
-
-  public readBoolean(): boolean {
-    this.index += 1;
-    return Boolean(this.buffer.at(this.index - 1));
-  }
-
-  public readBytes(n: number): Uint8Array {
-    this.index += n;
-    return this.buffer.slice(this.index - n, this.index);
-  }
-
-  public readNumberVector(): number[] {
-    return this.readVector({
-      fromBuffer: (reader: BufferReader) => reader.readNumber(),
-    });
-  }
-
-  public readVector<T>(itemDeserializer: { fromBuffer: (reader: BufferReader) => T }): T[] {
-    const size = this.readNumber();
-    const result = new Array<T>(size);
-    for (let i = 0; i < size; i++) {
-      result[i] = itemDeserializer.fromBuffer(this);
-    }
-    return result;
-  }
-
-  public readArray<T>(
-    size: number,
-    itemDeserializer: {
-      fromBuffer: (reader: BufferReader) => T;
-    },
-  ): T[] {
-    const result = new Array<T>(size);
-    for (let i = 0; i < size; i++) {
-      result[i] = itemDeserializer.fromBuffer(this);
-    }
-    return result;
-  }
-
-  public readObject<T>(deserializer: { fromBuffer: (reader: BufferReader) => T }): T {
-    return deserializer.fromBuffer(this);
-  }
-
-  public peekBytes(n?: number) {
-    return this.buffer.subarray(this.index, n ? this.index + n : undefined);
-  }
-
-  public readString(): string {
-    return new TextDecoder().decode(this.readBuffer());
-  }
-
-  public readBuffer(): Uint8Array {
-    const size = this.readNumber();
-    return this.readBytes(size);
-  }
-
-  public readMap<T>(deserializer: { fromBuffer: (reader: BufferReader) => T }): { [key: string]: T } {
-    const numEntries = this.readNumber();
-    const map: { [key: string]: T } = {};
-    for (let i = 0; i < numEntries; i++) {
-      const key = this.readString();
-      const value = this.readObject<T>(deserializer);
-      map[key] = value;
-    }
-    return map;
-  }
-}

package/src/serialize/output_type.ts

@@ -1,53 +0,0 @@
-import { BufferReader } from './buffer_reader.js';
-
-export interface OutputType<T = any> {
-  SIZE_IN_BYTES?: number;
-  fromBuffer: (b: Uint8Array | BufferReader) => T;
-}
-
-export function BoolDeserializer(): OutputType {
-  return {
-    SIZE_IN_BYTES: 1,
-    fromBuffer: (buf: Uint8Array | BufferReader) => {
-      const reader = BufferReader.asReader(buf);
-      return reader.readBoolean();
-    },
-  };
-}
-
-export function NumberDeserializer(): OutputType {
-  return {
-    SIZE_IN_BYTES: 4,
-    fromBuffer: (buf: Uint8Array | BufferReader) => {
-      const reader = BufferReader.asReader(buf);
-      return reader.readNumber();
-    },
-  };
-}
-
-export function VectorDeserializer<T>(t: OutputType<T>): OutputType {
-  return {
-    fromBuffer: (buf: Uint8Array | BufferReader) => {
-      const reader = BufferReader.asReader(buf);
-      return reader.readVector(t);
-    },
-  };
-}
-
-export function BufferDeserializer(): OutputType {
-  return {
-    fromBuffer: (buf: Uint8Array | BufferReader) => {
-      const reader = BufferReader.asReader(buf);
-      return reader.readBuffer();
-    },
-  };
-}
-
-export function StringDeserializer(): OutputType {
-  return {
-    fromBuffer: (buf: Uint8Array | BufferReader) => {
-      const reader = BufferReader.asReader(buf);
-      return reader.readString();
-    },
-  };
-}

package/src/types/fixed_size_buffer.ts

@@ -1,59 +0,0 @@
-import { randomBytes } from '../random/index.js';
-import { BufferReader } from '../serialize/index.js';
-
-export class Buffer32 {
-  static SIZE_IN_BYTES = 32;
-
-  constructor(public readonly buffer: Uint8Array) {}
-
-  static fromBuffer(buffer: Uint8Array | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new Buffer32(reader.readBytes(this.SIZE_IN_BYTES));
-  }
-
-  static random() {
-    return new Buffer32(randomBytes(this.SIZE_IN_BYTES));
-  }
-
-  toBuffer() {
-    return this.buffer;
-  }
-}
-
-export class Buffer64 {
-  static SIZE_IN_BYTES = 64;
-
-  constructor(public readonly buffer: Uint8Array) {}
-
-  static fromBuffer(buffer: Uint8Array | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new Buffer64(reader.readBytes(this.SIZE_IN_BYTES));
-  }
-
-  static random() {
-    return new Buffer64(randomBytes(this.SIZE_IN_BYTES));
-  }
-
-  toBuffer() {
-    return this.buffer;
-  }
-}
-
-export class Buffer128 {
-  static SIZE_IN_BYTES = 128;
-
-  constructor(public readonly buffer: Uint8Array) {}
-
-  static fromBuffer(buffer: Uint8Array | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new Buffer128(reader.readBytes(this.SIZE_IN_BYTES));
-  }
-
-  static random() {
-    return new Buffer128(randomBytes(this.SIZE_IN_BYTES));
-  }
-
-  toBuffer() {
-    return this.buffer;
-  }
-}

package/src/types/ptr.ts

@@ -1,20 +0,0 @@
-import { BufferReader } from '../serialize/index.js';
-
-/**
- * Holds an opaque pointer into WASM memory.
- * Currently only 4 bytes, but could grow to 8 bytes with wasm64.
- */
-export class Ptr {
-  static SIZE_IN_BYTES = 4;
-
-  constructor(public readonly value: Uint8Array) {}
-
-  static fromBuffer(buffer: Uint8Array | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new this(reader.readBytes(this.SIZE_IN_BYTES));
-  }
-
-  toBuffer() {
-    return this.value;
-  }
-}

package/src/types/raw_buffer.ts

@@ -1,3 +0,0 @@
-// Used when the data is to be sent exactly as is. i.e. no length prefix will be added.
-// This is useful for sending structured data that can be parsed-as-you-go, as opposed to just an array of bytes.
-export class RawBuffer extends Uint8Array {}