@aztec/bb.js 0.0.0-devnet

package/src/proof/index.ts

@@ -0,0 +1,120 @@
+/**
+ * @description
+ * The representation of a proof
+ * */
+export type ProofData = {
+  /** @description Public inputs of a proof */
+  publicInputs: string[];
+  /** @description An byte array representing the proof */
+  proof: Uint8Array;
+};
+
+// Buffers are prepended with their size. The size takes 4 bytes.
+const serializedBufferSize = 4;
+const fieldByteSize = 32;
+const publicInputOffset = 3;
+const publicInputsOffsetBytes = publicInputOffset * fieldByteSize;
+
+export function splitHonkProof(proofWithPublicInputs: Uint8Array): { publicInputs: Uint8Array; proof: Uint8Array } {
+  const proofAsStrings = deflattenFields(proofWithPublicInputs.slice(4));
+
+  const numPublicInputs = Number(proofAsStrings[1]);
+
+  // Account for the serialized buffer size at start
+  const publicInputsOffset = publicInputsOffsetBytes + serializedBufferSize;
+  // Get the part before and after the public inputs
+  const proofStart = proofWithPublicInputs.slice(0, publicInputsOffset);
+  const publicInputsSplitIndex = numPublicInputs * fieldByteSize;
+  const proofEnd = proofWithPublicInputs.slice(publicInputsOffset + publicInputsSplitIndex);
+  // Construct the proof without the public inputs
+  const proof = new Uint8Array([...proofStart, ...proofEnd]);
+
+  // Fetch the number of public inputs out of the proof string
+  const publicInputs = proofWithPublicInputs.slice(publicInputsOffset, publicInputsOffset + publicInputsSplitIndex);
+
+  return {
+    proof,
+    publicInputs,
+  };
+}
+
+export function reconstructHonkProof(publicInputs: Uint8Array, proof: Uint8Array): Uint8Array {
+  const proofStart = proof.slice(0, publicInputsOffsetBytes + serializedBufferSize);
+  const proofEnd = proof.slice(publicInputsOffsetBytes + serializedBufferSize);
+
+  // Concatenate publicInputs and proof
+  const proofWithPublicInputs = Uint8Array.from([...proofStart, ...publicInputs, ...proofEnd]);
+
+  return proofWithPublicInputs;
+}
+
+export function reconstructUltraPlonkProof(proofData: ProofData): Uint8Array {
+  // Flatten publicInputs
+  const publicInputsConcatenated = flattenFieldsAsArray(proofData.publicInputs);
+
+  // Concatenate publicInputs and proof
+  const proofWithPublicInputs = Uint8Array.from([...publicInputsConcatenated, ...proofData.proof]);
+
+  return proofWithPublicInputs;
+}
+
+export function deflattenFields(flattenedFields: Uint8Array): string[] {
+  const publicInputSize = 32;
+  const chunkedFlattenedPublicInputs: Uint8Array[] = [];
+
+  for (let i = 0; i < flattenedFields.length; i += publicInputSize) {
+    const publicInput = flattenedFields.slice(i, i + publicInputSize);
+    chunkedFlattenedPublicInputs.push(publicInput);
+  }
+
+  return chunkedFlattenedPublicInputs.map(uint8ArrayToHex);
+}
+
+export function flattenFieldsAsArray(fields: string[]): Uint8Array {
+  const flattenedPublicInputs = fields.map(hexToUint8Array);
+  return flattenUint8Arrays(flattenedPublicInputs);
+}
+
+function flattenUint8Arrays(arrays: Uint8Array[]): Uint8Array {
+  const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);
+  const result = new Uint8Array(totalLength);
+
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+
+  return result;
+}
+
+function uint8ArrayToHex(buffer: Uint8Array): string {
+  const hex: string[] = [];
+
+  buffer.forEach(function (i) {
+    let h = i.toString(16);
+    if (h.length % 2) {
+      h = '0' + h;
+    }
+    hex.push(h);
+  });
+
+  return '0x' + hex.join('');
+}
+
+function hexToUint8Array(hex: string): Uint8Array {
+  const sanitisedHex = BigInt(hex).toString(16).padStart(64, '0');
+
+  const len = sanitisedHex.length / 2;
+  const u8 = new Uint8Array(len);
+
+  let i = 0;
+  let j = 0;
+  while (i < len) {
+    u8[i] = parseInt(sanitisedHex.slice(j, j + 2), 16);
+    i += 1;
+    j += 2;
+  }
+
+  return u8;
+}

package/src/random/browser/index.ts

@@ -0,0 +1,32 @@
+export const randomBytes = (len: number) => {
+  const getWebCrypto = () => {
+    if (typeof window !== 'undefined' && window.crypto) return window.crypto;
+    if (typeof globalThis !== 'undefined' && globalThis.crypto) return globalThis.crypto;
+    return undefined;
+  };
+
+  const crypto = getWebCrypto();
+  if (!crypto) {
+    throw new Error('randomBytes UnsupportedEnvironment');
+  }
+
+  const buf = new Uint8Array(len);
+
+  // limit of Crypto.getRandomValues()
+  // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
+  const MAX_BYTES = 65536;
+
+  if (len > MAX_BYTES) {
+    // this is the max bytes crypto.getRandomValues
+    // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
+    for (let generated = 0; generated < len; generated += MAX_BYTES) {
+      // buffer.slice automatically checks if the end is past the end of
+      // the buffer so we don't have to here
+      crypto.getRandomValues(buf.subarray(generated, generated + MAX_BYTES));
+    }
+  } else {
+    crypto.getRandomValues(buf);
+  }
+
+  return buf;
+};

package/src/random/index.ts

@@ -0,0 +1 @@
+export * from './node/index.js';

package/src/random/node/index.ts

@@ -0,0 +1,5 @@
+import { randomBytes as cryptoRandomBytes } from 'crypto';
+
+export function randomBytes(len: number) {
+  return new Uint8Array(cryptoRandomBytes(len));
+}

package/src/serialize/buffer_reader.ts

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

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

package/src/serialize/output_type.ts

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

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

package/src/types/fields.ts

@@ -0,0 +1,115 @@
+import { randomBytes } from '../random/index.js';
+import { toBigIntBE, toBufferBE } from '../bigint-array/index.js';
+import { BufferReader, uint8ArrayToHexString } from '../serialize/index.js';
+
+// TODO(#4189): Replace with implementation in yarn-project/foundation/src/fields/fields.ts
+/**
+ * Fr field class.
+ * @dev This class is used to represent elements of BN254 scalar field or elements in the base field of Grumpkin.
+ * (Grumpkin's scalar field corresponds to BN254's base field and vice versa.)
+ */
+export class Fr {
+  static ZERO = new Fr(0n);
+  static MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
+  static MAX_VALUE = this.MODULUS - 1n;
+  static SIZE_IN_BYTES = 32;
+  value: Uint8Array;
+
+  constructor(value: Uint8Array | bigint) {
+    // We convert buffer value to bigint to be able to check it fits within modulus
+    const valueBigInt = typeof value === 'bigint' ? value : toBigIntBE(value);
+
+    if (valueBigInt > Fr.MAX_VALUE) {
+      throw new Error(`Value 0x${valueBigInt.toString(16)} is greater or equal to field modulus.`);
+    }
+
+    this.value = typeof value === 'bigint' ? toBufferBE(value) : value;
+  }
+
+  static random() {
+    const r = toBigIntBE(randomBytes(64)) % Fr.MODULUS;
+    return new this(r);
+  }
+
+  static fromBuffer(buffer: Uint8Array | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(reader.readBytes(this.SIZE_IN_BYTES));
+  }
+
+  static fromBufferReduce(buffer: Uint8Array | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
+  }
+
+  static fromString(str: string) {
+    return this.fromBuffer(Buffer.from(str.replace(/^0x/i, ''), 'hex'));
+  }
+
+  toBuffer() {
+    return this.value;
+  }
+
+  toString() {
+    return '0x' + uint8ArrayToHexString(this.toBuffer());
+  }
+
+  equals(rhs: Fr) {
+    return this.value.every((v, i) => v === rhs.value[i]);
+  }
+
+  isZero() {
+    return this.value.every(v => v === 0);
+  }
+}
+
+/**
+ * Fq field class.
+ * @dev This class is used to represent elements of BN254 base field or elements in the scalar field of Grumpkin.
+ * (Grumpkin's scalar field corresponds to BN254's base field and vice versa.)
+ */
+export class Fq {
+  static MODULUS = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47n;
+  static MAX_VALUE = this.MODULUS - 1n;
+  static SIZE_IN_BYTES = 32;
+
+  constructor(public readonly value: bigint) {
+    if (value > Fq.MAX_VALUE) {
+      throw new Error(`Fq out of range ${value}.`);
+    }
+  }
+
+  static random() {
+    const r = toBigIntBE(randomBytes(64)) % Fq.MODULUS;
+    return new this(r);
+  }
+
+  static fromBuffer(buffer: Uint8Array | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)));
+  }
+
+  static fromBufferReduce(buffer: Uint8Array | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
+  }
+
+  static fromString(str: string) {
+    return this.fromBuffer(Buffer.from(str.replace(/^0x/i, ''), 'hex'));
+  }
+
+  toBuffer() {
+    return toBufferBE(this.value, Fq.SIZE_IN_BYTES);
+  }
+
+  toString() {
+    return '0x' + this.value.toString(16);
+  }
+
+  equals(rhs: Fq) {
+    return this.value === rhs.value;
+  }
+
+  isZero() {
+    return this.value === 0n;
+  }
+}

package/src/types/fixed_size_buffer.ts

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

@@ -0,0 +1,5 @@
+export * from './ptr.js';
+export * from './fields.js';
+export * from './point.js';
+export * from './fixed_size_buffer.js';
+export * from './raw_buffer.js';

package/src/types/point.ts

@@ -0,0 +1,35 @@
+import { Fr } from './index.js';
+import { BufferReader } from '../serialize/buffer_reader.js';
+
+export class Point {
+  static SIZE_IN_BYTES = 64;
+  static EMPTY = new Point(Fr.ZERO, Fr.ZERO);
+
+  constructor(public readonly x: Fr, public readonly y: Fr) {}
+
+  static random() {
+    // TODO: This is not a point on the curve!
+    return new Point(Fr.random(), Fr.random());
+  }
+
+  static fromBuffer(buffer: Uint8Array | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+  }
+
+  static fromString(address: string) {
+    return Point.fromBuffer(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
+  }
+
+  toBuffer() {
+    return Buffer.concat([this.x.toBuffer(), this.y.toBuffer()]);
+  }
+
+  toString() {
+    return '0x' + this.toBuffer().toString('hex');
+  }
+
+  equals(rhs: Point) {
+    return this.x.equals(rhs.x) && this.y.equals(rhs.y);
+  }
+}

package/src/types/ptr.ts

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