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

package/src/main.ts

@@ -1,324 +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 getBytecode(jsonPath: string) {
-  const json = readFileSync(jsonPath, 'utf-8');
-  const parsed = JSON.parse(json);
-  const buffer = Buffer.from(parsed.bytecode, 'base64');
-  const decompressed = gunzipSync(buffer);
-  return decompressed;
-}
-
-function getWitness(witnessPath: string) {
-  const data = readFileSync(witnessPath);
-  return Buffer.concat([numToUInt32BE(data.length / 32), data]);
-}
-
-async function getCircuitSize(jsonPath: string, api: BarretenbergApiAsync) {
-  const bytecode = getBytecode(jsonPath);
-  const [exact, total, subgroup] = await api.acirGetCircuitSizes(new RawBuffer(bytecode));
-  return { exact, total, subgroup };
-}
-
-async function init(jsonPath: string, sizeHint?: number) {
-  const api = await newBarretenbergApiAsync();
-
-  const subgroupSize = await (async () => {
-    if (sizeHint) {
-      // Round to subgroup size.
-      return Math.pow(2, Math.ceil(Math.log2(sizeHint)));
-    }
-
-    // First compute circuit size.
-    debug(`computing circuit size (use size hint to skip)...`);
-    const circuitSizes = await getCircuitSize(jsonPath, api);
-    debug(`circuit size: ${circuitSizes.total}`);
-
-    if (circuitSizes.subgroup > MAX_CIRCUIT_SIZE) {
-      throw new Error(`Circuit size of ${circuitSizes.subgroup} exceeds max supported of ${MAX_CIRCUIT_SIZE}`);
-    }
-
-    return circuitSizes.subgroup;
-  })();
-
-  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, sizeHint?: number) {
-  const { api, acirComposer } = await init(jsonPath, sizeHint);
-  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,
-  sizeHint?: number,
-) {
-  const { api, acirComposer } = await init(jsonPath, sizeHint);
-  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 {
-    const circuitSizes = await getCircuitSize(jsonPath, api);
-    console.log(`${circuitSizes.exact}`);
-  } finally {
-    await api.destroy();
-  }
-}
-
-export async function verify(jsonPath: string, 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, sizeHint?: number) {
-  const { api, acirComposer } = await init(jsonPath, sizeHint);
-  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();
-  }
-}
-
-// nargo use bb.js: backend -> bb.js
-// backend prove --data-dir data --witness /foo/bar/witness.tr --json /foo/bar/main.json
-// backend verify ...
-// backend get_total_num_gates --data-dir data --json /foo/bar/main.json
-// backend get_sol_contract --data-dir data --json /foo/bar/main.json --output
-// backend get_features
-// OPTIONAL stateful backend:
-// backend start
-// backend stop
-
-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)
-  .option('-s, --size-hint <gates>', 'provide a circuit size hint to skip calculation phase')
-  .action(async ({ jsonPath, witnessPath, recursive, sizeHint }) => {
-    handleGlobalOptions();
-    const result = await proveAndVerify(jsonPath, witnessPath, recursive, sizeHint);
-    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')
-  .option('-s, --size-hint <gates>', 'provide a circuit size hint to skip calculation phase')
-  .action(async ({ jsonPath, witnessPath, recursive, outputPath, sizeHint }) => {
-    handleGlobalOptions();
-    await prove(jsonPath, witnessPath, recursive, outputPath, sizeHint);
-  });
-
-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.')
-  .option('-j, --json-path <path>', 'Specify the JSON path', './target/main.json')
-  .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 ({ jsonPath, proofPath, recursive, vk }) => {
-    handleGlobalOptions();
-    await verify(jsonPath, proofPath, recursive, vk);
-  });
-
-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')
-  .option('-s, --size-hint <gates>', 'provide a circuit size hint to skip calculation phase')
-  .action(async ({ jsonPath, outputPath, sizeHint }) => {
-    handleGlobalOptions();
-    await writeVk(jsonPath, outputPath, sizeHint);
-  });
-
-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/index.ts

@@ -1,3 +0,0 @@
-export * from './buffer_reader.js';
-export * from './output_type.js';
-export * from './serialize.js';

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/serialize/serialize.ts

@@ -1,157 +0,0 @@
-import { RawBuffer } from '../types/raw_buffer.js';
-
-// For serializing bool.
-export function boolToBuffer(b: boolean) {
-  const buf = new Uint8Array(1);
-  buf[0] = b ? 1 : 0;
-  return buf;
-}
-
-// For serializing numbers to 32 bit little-endian form.
-export function numToUInt32LE(n: number, bufferSize = 4) {
-  const buf = new Uint8Array(bufferSize);
-  new DataView(buf.buffer).setUint32(buf.byteLength - 4, n, true);
-  return buf;
-}
-
-// For serializing numbers to 32 bit big-endian form.
-export function numToUInt32BE(n: number, bufferSize = 4) {
-  const buf = new Uint8Array(bufferSize);
-  new DataView(buf.buffer).setUint32(buf.byteLength - 4, n, false);
-  return buf;
-}
-
-// For serializing signed numbers to 32 bit big-endian form.
-export function numToInt32BE(n: number, bufferSize = 4) {
-  const buf = new Uint8Array(bufferSize);
-  new DataView(buf.buffer).setInt32(buf.byteLength - 4, n, false);
-  return buf;
-}
-
-// For serializing numbers to 8 bit form.
-export function numToUInt8(n: number) {
-  const buf = new Uint8Array(1);
-  buf[0] = n;
-  return buf;
-}
-
-export function concatenateUint8Arrays(arrayOfUint8Arrays: Uint8Array[]) {
-  const totalLength = arrayOfUint8Arrays.reduce((prev, curr) => prev + curr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let length = 0;
-  for (const array of arrayOfUint8Arrays) {
-    result.set(array, length);
-    length += array.length;
-  }
-  return result;
-}
-
-export function uint8ArrayToHexString(uint8Array: Uint8Array) {
-  return uint8Array.reduce((accumulator, byte) => accumulator + byte.toString(16).padStart(2, '0'), '');
-}
-
-// For serializing a buffer as a vector.
-export function serializeBufferToVector(buf: Uint8Array) {
-  return concatenateUint8Arrays([numToInt32BE(buf.length), buf]);
-}
-
-export function serializeBigInt(n: bigint, width = 32) {
-  const buf = new Uint8Array(width);
-  for (let i = 0; i < width; i++) {
-    buf[width - i - 1] = Number((n >> BigInt(i * 8)) & 0xffn);
-  }
-  return buf;
-}
-
-export function deserializeBigInt(buf: Uint8Array, offset = 0, width = 32) {
-  let result = 0n;
-  for (let i = 0; i < width; i++) {
-    result = (result << BigInt(8)) | BigInt(buf[offset + i]);
-  }
-  return { elem: result, adv: width };
-}
-
-export function serializeDate(date: Date) {
-  return serializeBigInt(BigInt(date.getTime()), 8);
-}
-
-export function deserializeBufferFromVector(vector: Uint8Array, offset = 0) {
-  const length = new DataView(vector.buffer, vector.byteOffset + offset, 4).getUint32(0, false);
-  const adv = 4 + length;
-  const elem = vector.slice(offset + 4, offset + adv);
-  return { elem, adv };
-}
-
-export function deserializeBool(buf: Uint8Array, offset = 0) {
-  const adv = 1;
-  const elem = buf[offset] !== 0;
-  return { elem, adv };
-}
-
-export function deserializeUInt32(buf: Uint8Array, offset = 0) {
-  const adv = 4;
-  const elem = new DataView(buf.buffer, buf.byteOffset + offset, adv).getUint32(0, false);
-  return { elem, adv };
-}
-
-export function deserializeInt32(buf: Uint8Array, offset = 0) {
-  const adv = 4;
-  const elem = new DataView(buf.buffer, buf.byteOffset + offset, adv).getInt32(0, false);
-  return { elem, adv };
-}
-
-export function deserializeField(buf: Uint8Array, offset = 0) {
-  const adv = 32;
-  const elem = buf.slice(offset, offset + adv);
-  return { elem, adv };
-}
-
-// For serializing an array of fixed length elements.
-export function serializeBufferArrayToVector(arr: Uint8Array[]) {
-  return concatenateUint8Arrays([numToUInt32BE(arr.length), ...arr.flat()]);
-}
-
-export function deserializeArrayFromVector<T>(
-  deserialize: (buf: Uint8Array, offset: number) => { elem: T; adv: number },
-  vector: Uint8Array,
-  offset = 0,
-) {
-  let pos = offset;
-  const size = new DataView(vector.buffer, vector.byteOffset + pos, 4).getUint32(0, false);
-  pos += 4;
-  const arr = new Array<T>(size);
-  for (let i = 0; i < size; ++i) {
-    const { elem, adv } = deserialize(vector, pos);
-    pos += adv;
-    arr[i] = elem;
-  }
-  return { elem: arr, adv: pos - offset };
-}
-
-/** A type that can be written to a buffer. */
-export type Bufferable = boolean | Uint8Array | number | string | { toBuffer: () => Uint8Array } | Bufferable[];
-
-/**
- * Serializes a list of objects contiguously for calling into wasm.
- * @param objs - Objects to serialize.
- * @returns A buffer list with the concatenation of all fields.
- */
-export function serializeBufferable(obj: Bufferable): Uint8Array {
-  if (Array.isArray(obj)) {
-    return serializeBufferArrayToVector(obj.map(serializeBufferable));
-  } else if (obj instanceof RawBuffer) {
-    return obj;
-  } else if (obj instanceof Uint8Array) {
-    return serializeBufferToVector(obj);
-  } else if (typeof obj === 'boolean') {
-    return boolToBuffer(obj);
-  } else if (typeof obj === 'number') {
-    return numToUInt32BE(obj);
-  } else if (typeof obj === 'bigint') {
-    return serializeBigInt(obj);
-  } else if (typeof obj === 'string') {
-    return serializeBufferToVector(new TextEncoder().encode(obj));
-  } else {
-    return obj.toBuffer();
-  }
-}