@aztec/bb.js 0.0.0-devnet

package/src/barretenberg/__snapshots__/poseidon.test.ts.snap

@@ -0,0 +1,40 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`poseidon sync poseidonHash 1`] = `
+Fr {
+  "value": Uint8Array [
+    43,
+    202,
+    235,
+    109,
+    88,
+    187,
+    56,
+    186,
+    247,
+    83,
+    213,
+    140,
+    60,
+    150,
+    97,
+    143,
+    234,
+    130,
+    22,
+    51,
+    69,
+    41,
+    94,
+    180,
+    14,
+    136,
+    52,
+    78,
+    235,
+    12,
+    226,
+    161,
+  ],
+}
+`;

package/src/barretenberg/backend.ts

@@ -0,0 +1,362 @@
+import { BackendOptions, Barretenberg, CircuitOptions } from './index.js';
+import { RawBuffer } from '../types/raw_buffer.js';
+import { decompressSync as gunzip } from 'fflate';
+import {
+  deflattenFields,
+  flattenFieldsAsArray,
+  ProofData,
+  reconstructHonkProof,
+  reconstructUltraPlonkProof,
+} from '../proof/index.js';
+
+export class UltraPlonkBackend {
+  // These type assertions are used so that we don't
+  // have to initialize `api` and `acirComposer` in the constructor.
+  // These are initialized asynchronously in the `init` function,
+  // constructors cannot be asynchronous which is why we do this.
+
+  protected api!: Barretenberg;
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  protected acirComposer: any;
+
+  protected acirUncompressedBytecode: Uint8Array;
+
+  constructor(
+    acirBytecode: string,
+    protected backendOptions: BackendOptions = { threads: 1 },
+    protected circuitOptions: CircuitOptions = { recursive: false },
+  ) {
+    this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
+  }
+
+  /** @ignore */
+  async instantiate(): Promise<void> {
+    if (!this.api) {
+      const api = await Barretenberg.new(this.backendOptions);
+
+      const honkRecursion = false;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const [_total, subgroupSize] = await api.acirGetCircuitSizes(
+        this.acirUncompressedBytecode,
+        this.circuitOptions.recursive,
+        honkRecursion,
+      );
+
+      await api.initSRSForCircuitSize(subgroupSize);
+      this.acirComposer = await api.acirNewAcirComposer(subgroupSize);
+      await api.acirInitProvingKey(this.acirComposer, this.acirUncompressedBytecode, this.circuitOptions.recursive);
+      this.api = api;
+    }
+  }
+
+  /** @description Generates a proof */
+  async generateProof(compressedWitness: Uint8Array): Promise<ProofData> {
+    await this.instantiate();
+    const proofWithPublicInputs = await this.api.acirCreateProof(
+      this.acirComposer,
+      this.acirUncompressedBytecode,
+      this.circuitOptions.recursive,
+      gunzip(compressedWitness),
+    );
+
+    // This is the number of bytes in a UltraPlonk proof
+    // minus the public inputs.
+    const numBytesInProofWithoutPublicInputs = 2144;
+
+    const splitIndex = proofWithPublicInputs.length - numBytesInProofWithoutPublicInputs;
+
+    const publicInputsConcatenated = proofWithPublicInputs.slice(0, splitIndex);
+    const proof = proofWithPublicInputs.slice(splitIndex);
+    const publicInputs = deflattenFields(publicInputsConcatenated);
+
+    return { proof, publicInputs };
+  }
+
+  /**
+   * Generates artifacts that will be passed to a circuit that will verify this proof.
+   *
+   * Instead of passing the proof and verification key as a byte array, we pass them
+   * as fields which makes it cheaper to verify in a circuit.
+   *
+   * The proof that is passed here will have been created by passing the `recursive`
+   * parameter to a backend.
+   *
+   * The number of public inputs denotes how many public inputs are in the inner proof.
+   *
+   * @example
+   * ```typescript
+   * const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+   * ```
+   */
+  async generateRecursiveProofArtifacts(
+    proofData: ProofData,
+    numOfPublicInputs = 0,
+  ): Promise<{
+    proofAsFields: string[];
+    vkAsFields: string[];
+    vkHash: string;
+  }> {
+    await this.instantiate();
+
+    const proof = reconstructUltraPlonkProof(proofData);
+    const proofAsFields = (
+      await this.api.acirSerializeProofIntoFields(this.acirComposer, proof, numOfPublicInputs)
+    ).slice(numOfPublicInputs);
+
+    // TODO: perhaps we should put this in the init function. Need to benchmark
+    // TODO how long it takes.
+    await this.api.acirInitVerificationKey(this.acirComposer);
+
+    // Note: If you don't init verification key, `acirSerializeVerificationKeyIntoFields`` will just hang on serialization
+    const vk = await this.api.acirSerializeVerificationKeyIntoFields(this.acirComposer);
+
+    return {
+      proofAsFields: proofAsFields.map(p => p.toString()),
+      vkAsFields: vk[0].map(vk => vk.toString()),
+      vkHash: vk[1].toString(),
+    };
+  }
+
+  /** @description Verifies a proof */
+  async verifyProof(proofData: ProofData): Promise<boolean> {
+    await this.instantiate();
+    await this.api.acirInitVerificationKey(this.acirComposer);
+    const proof = reconstructUltraPlonkProof(proofData);
+    return await this.api.acirVerifyProof(this.acirComposer, proof);
+  }
+
+  /** @description Returns the verification key */
+  async getVerificationKey(): Promise<Uint8Array> {
+    await this.instantiate();
+    await this.api.acirInitVerificationKey(this.acirComposer);
+    return await this.api.acirGetVerificationKey(this.acirComposer);
+  }
+
+  /** @description Returns a solidity verifier */
+  async getSolidityVerifier(): Promise<string> {
+    await this.instantiate();
+    await this.api.acirInitVerificationKey(this.acirComposer);
+    return await this.api.acirGetSolidityVerifier(this.acirComposer);
+  }
+
+  async destroy(): Promise<void> {
+    if (!this.api) {
+      return;
+    }
+    await this.api.destroy();
+  }
+}
+
+// Buffers are prepended with their size. The size takes 4 bytes.
+const serializedBufferSize = 4;
+const fieldByteSize = 32;
+const publicInputOffset = 3;
+const publicInputsOffsetBytes = publicInputOffset * fieldByteSize;
+
+/**
+ * Options for the UltraHonkBackend.
+ */
+export type UltraHonkBackendOptions = {
+  /**Selecting this option will use the keccak hash function instead of poseidon
+   * when generating challenges in the proof.
+   * Use this when you want to verify the created proof on an EVM chain.
+   */
+  keccak: boolean;
+};
+
+export class UltraHonkBackend {
+  // These type assertions are used so that we don't
+  // have to initialize `api` in the constructor.
+  // These are initialized asynchronously in the `init` function,
+  // constructors cannot be asynchronous which is why we do this.
+
+  protected api!: Barretenberg;
+  protected acirUncompressedBytecode: Uint8Array;
+
+  constructor(
+    acirBytecode: string,
+    protected backendOptions: BackendOptions = { threads: 1 },
+    protected circuitOptions: CircuitOptions = { recursive: false },
+  ) {
+    this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
+  }
+  /** @ignore */
+  async instantiate(): Promise<void> {
+    if (!this.api) {
+      const api = await Barretenberg.new(this.backendOptions);
+      const honkRecursion = true;
+      await api.acirInitSRS(this.acirUncompressedBytecode, this.circuitOptions.recursive, honkRecursion);
+
+      // We don't init a proving key here in the Honk API
+      // await api.acirInitProvingKey(this.acirComposer, this.acirUncompressedBytecode);
+      this.api = api;
+    }
+  }
+
+  async generateProof(compressedWitness: Uint8Array, options?: UltraHonkBackendOptions): Promise<ProofData> {
+    await this.instantiate();
+
+    const proveUltraHonk = options?.keccak
+      ? this.api.acirProveUltraKeccakHonk.bind(this.api)
+      : this.api.acirProveUltraHonk.bind(this.api);
+
+    const proofWithPublicInputs = await proveUltraHonk(
+      this.acirUncompressedBytecode,
+      this.circuitOptions.recursive,
+      gunzip(compressedWitness),
+    );
+
+    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 publicInputsConcatenated = proofWithPublicInputs.slice(
+      publicInputsOffset,
+      publicInputsOffset + publicInputsSplitIndex,
+    );
+    const publicInputs = deflattenFields(publicInputsConcatenated);
+
+    return { proof, publicInputs };
+  }
+
+  async verifyProof(proofData: ProofData, options?: UltraHonkBackendOptions): Promise<boolean> {
+    await this.instantiate();
+
+    const proof = reconstructHonkProof(flattenFieldsAsArray(proofData.publicInputs), proofData.proof);
+
+    const writeVkUltraHonk = options?.keccak
+      ? this.api.acirWriteVkUltraKeccakHonk.bind(this.api)
+      : this.api.acirWriteVkUltraHonk.bind(this.api);
+    const verifyUltraHonk = options?.keccak
+      ? this.api.acirVerifyUltraKeccakHonk.bind(this.api)
+      : this.api.acirVerifyUltraHonk.bind(this.api);
+
+    const vkBuf = await writeVkUltraHonk(this.acirUncompressedBytecode, this.circuitOptions.recursive);
+    return await verifyUltraHonk(proof, new RawBuffer(vkBuf));
+  }
+
+  async getVerificationKey(): Promise<Uint8Array> {
+    await this.instantiate();
+    return await this.api.acirWriteVkUltraHonk(this.acirUncompressedBytecode, this.circuitOptions.recursive);
+  }
+
+  /** @description Returns a solidity verifier */
+  async getSolidityVerifier(vk?: Uint8Array): Promise<string> {
+    await this.instantiate();
+    const vkBuf =
+      vk ?? (await this.api.acirWriteVkUltraHonk(this.acirUncompressedBytecode, this.circuitOptions.recursive));
+    return await this.api.acirHonkSolidityVerifier(this.acirUncompressedBytecode, new RawBuffer(vkBuf));
+  }
+
+  // TODO(https://github.com/noir-lang/noir/issues/5661): Update this to handle Honk recursive aggregation in the browser once it is ready in the backend itself
+  async generateRecursiveProofArtifacts(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _proof: Uint8Array,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _numOfPublicInputs: number,
+  ): Promise<{ proofAsFields: string[]; vkAsFields: string[]; vkHash: string }> {
+    await this.instantiate();
+    // TODO(https://github.com/noir-lang/noir/issues/5661): This needs to be updated to handle recursive aggregation.
+    // There is still a proofAsFields method but we could consider getting rid of it as the proof itself
+    // is a list of field elements.
+    // UltraHonk also does not have public inputs directly prepended to the proof and they are still instead
+    // inserted at an offset.
+    // const proof = reconstructProofWithPublicInputs(proofData);
+    // const proofAsFields = (await this.api.acirProofAsFieldsUltraHonk(proof)).slice(numOfPublicInputs);
+
+    // TODO: perhaps we should put this in the init function. Need to benchmark
+    // TODO how long it takes.
+    const vkBuf = await this.api.acirWriteVkUltraHonk(this.acirUncompressedBytecode, this.circuitOptions.recursive);
+    const vk = await this.api.acirVkAsFieldsUltraHonk(vkBuf);
+
+    return {
+      // TODO(https://github.com/noir-lang/noir/issues/5661)
+      proofAsFields: [],
+      vkAsFields: vk.map(vk => vk.toString()),
+      // We use an empty string for the vk hash here as it is unneeded as part of the recursive artifacts
+      // The user can be expected to hash the vk inside their circuit to check whether the vk is the circuit
+      // they expect
+      vkHash: '',
+    };
+  }
+
+  async destroy(): Promise<void> {
+    if (!this.api) {
+      return;
+    }
+    await this.api.destroy();
+  }
+}
+
+export class AztecClientBackend {
+  // These type assertions are used so that we don't
+  // have to initialize `api` in the constructor.
+  // These are initialized asynchronously in the `init` function,
+  // constructors cannot be asynchronous which is why we do this.
+
+  protected api!: Barretenberg;
+
+  constructor(protected acirMsgpack: Uint8Array[], protected options: BackendOptions = { threads: 1 }) {}
+
+  /** @ignore */
+  async instantiate(): Promise<void> {
+    if (!this.api) {
+      const api = await Barretenberg.new(this.options);
+      await api.initSRSClientIVC();
+      this.api = api;
+    }
+  }
+
+  async prove(witnessMsgpack: Uint8Array[]): Promise<[Uint8Array, Uint8Array]> {
+    await this.instantiate();
+    return this.api.acirProveAztecClient(this.acirMsgpack, witnessMsgpack);
+  }
+
+  async verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean> {
+    await this.instantiate();
+    return this.api.acirVerifyAztecClient(proof, vk);
+  }
+
+  async proveAndVerify(witnessMsgpack: Uint8Array[]): Promise<boolean> {
+    await this.instantiate();
+    return this.api.acirProveAndVerifyAztecClient(this.acirMsgpack, witnessMsgpack);
+  }
+
+  async destroy(): Promise<void> {
+    if (!this.api) {
+      return;
+    }
+    await this.api.destroy();
+  }
+}
+
+// Converts bytecode from a base64 string to a Uint8Array
+function acirToUint8Array(base64EncodedBytecode: string): Uint8Array {
+  const compressedByteCode = base64Decode(base64EncodedBytecode);
+  return gunzip(compressedByteCode);
+}
+
+// Since this is a simple function, we can use feature detection to
+// see if we are in the nodeJs environment or the browser environment.
+function base64Decode(input: string): Uint8Array {
+  if (typeof Buffer !== 'undefined') {
+    // Node.js environment
+    const b = Buffer.from(input, 'base64');
+    return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+  } else if (typeof atob === 'function') {
+    // Browser environment
+    return Uint8Array.from(atob(input), c => c.charCodeAt(0));
+  } else {
+    throw new Error('No implementation found for base64 decoding.');
+  }
+}

package/src/barretenberg/blake2s.test.ts

@@ -0,0 +1,70 @@
+import { Barretenberg, BarretenbergSync } from './index.js';
+import { Buffer32, Fr } from '../types/index.js';
+
+describe('blake2s async', () => {
+  let api: Barretenberg;
+
+  beforeAll(async () => {
+    api = await Barretenberg.new({ threads: 1 });
+  });
+
+  afterAll(async () => {
+    await api.destroy();
+  });
+
+  it('blake2s', async () => {
+    const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
+    const expected = Buffer32.fromBuffer(
+      new Uint8Array([
+        0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
+        0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+      ]),
+    );
+    const result = await api.blake2s(input);
+    expect(result).toEqual(expected);
+  });
+
+  it('blake2sToField', async () => {
+    const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
+    const expected = Fr.fromBufferReduce(
+      new Uint8Array([
+        0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
+        0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+      ]),
+    );
+    const result = await api.blake2sToField(input);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('blake2s sync', () => {
+  let api: BarretenbergSync;
+
+  beforeAll(async () => {
+    api = await BarretenbergSync.new();
+  });
+
+  it('blake2s', () => {
+    const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
+    const expected = Buffer32.fromBuffer(
+      new Uint8Array([
+        0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
+        0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+      ]),
+    );
+    const result = api.blake2s(input);
+    expect(result).toEqual(expected);
+  });
+
+  it('blake2sToField', () => {
+    const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
+    const expected = Fr.fromBufferReduce(
+      new Uint8Array([
+        0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
+        0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+      ]),
+    );
+    const result = api.blake2sToField(input);
+    expect(result).toEqual(expected);
+  });
+});

package/src/barretenberg/common.test.ts

@@ -0,0 +1,23 @@
+import { Barretenberg } from './index.js';
+
+describe('env', () => {
+  let api: Barretenberg;
+
+  beforeAll(async () => {
+    api = await Barretenberg.new({ threads: 3 });
+  }, 30000);
+
+  afterAll(async () => {
+    if (api) {
+      await api.destroy();
+    }
+  });
+
+  it('thread test', async () => {
+    // Main thread doesn't do anything in this test, so -1.
+    const threads = (await api.getNumThreads()) - 1;
+    const iterations = 100000;
+    const result = await api.testThreads(threads, iterations);
+    expect(result).toBe(iterations);
+  });
+});

package/src/barretenberg/index.ts

@@ -0,0 +1,130 @@
+import { proxy } from 'comlink';
+import { BarretenbergApi, BarretenbergApiSync } from '../barretenberg_api/index.js';
+import { createMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js';
+import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { getRemoteBarretenbergWasm } from '../barretenberg_wasm/helpers/index.js';
+import { BarretenbergWasmWorker, fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import createDebug from 'debug';
+import { Crs, GrumpkinCrs } from '../crs/index.js';
+import { RawBuffer } from '../types/raw_buffer.js';
+
+export { BarretenbergVerifier } from './verifier.js';
+export { UltraPlonkBackend, UltraHonkBackend, AztecClientBackend } from './backend.js';
+
+const debug = createDebug('bb.js:wasm');
+
+export type BackendOptions = {
+  /** @description Number of threads to run the backend worker on */
+  threads?: number;
+
+  /** @description Initial and Maximum memory to be alloted to the backend worker */
+  memory?: { initial?: number; maximum?: number };
+
+  /** @description Path to download CRS files */
+  crsPath?: string;
+};
+
+export type CircuitOptions = {
+  /** @description Whether to produce SNARK friendly proofs */
+  recursive: boolean;
+};
+
+/**
+ * The main class library consumers interact with.
+ * It extends the generated api, and provides a static constructor "new" to compose components.
+ */
+export class Barretenberg extends BarretenbergApi {
+  private options: BackendOptions;
+
+  private constructor(private worker: any, wasm: BarretenbergWasmWorker, options: BackendOptions) {
+    super(wasm);
+    this.options = options;
+  }
+
+  /**
+   * Constructs an instance of Barretenberg.
+   * Launches it within a worker. This is necessary as it blocks waiting on child threads to complete,
+   * and blocking the main thread in the browser is not allowed.
+   * It threads > 1 (defaults to hardware availability), child threads will be created on their own workers.
+   */
+  static async new(options: BackendOptions = {}) {
+    const worker = createMainWorker();
+    const wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
+    const { module, threads } = await fetchModuleAndThreads(options.threads);
+    await wasm.init(module, threads, proxy(debug), options.memory?.initial, options.memory?.maximum);
+    return new Barretenberg(worker, wasm, options);
+  }
+
+  async getNumThreads() {
+    return await this.wasm.getNumThreads();
+  }
+
+  async initSRSForCircuitSize(circuitSize: number): Promise<void> {
+    const crs = await Crs.new(circuitSize + 1, this.options.crsPath);
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1129): Do slab allocator initialization?
+    // await this.commonInitSlabAllocator(circuitSize);
+    await this.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+  }
+
+  async initSRSClientIVC(): Promise<void> {
+    // crsPath can be undefined
+    const crs = await Crs.new(2 ** 20 + 1, this.options.crsPath);
+    const grumpkinCrs = await GrumpkinCrs.new(2 ** 15 + 1, this.options.crsPath);
+
+    // Load CRS into wasm global CRS state.
+    // TODO: Make RawBuffer be default behavior, and have a specific Vector type for when wanting length prefixed.
+    await this.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
+    await this.srsInitGrumpkinSrs(new RawBuffer(grumpkinCrs.getG1Data()), grumpkinCrs.numPoints);
+  }
+
+  async acirInitSRS(bytecode: Uint8Array, recursive: boolean, honkRecursion: boolean): Promise<void> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_total, subgroupSize] = await this.acirGetCircuitSizes(bytecode, recursive, honkRecursion);
+    return this.initSRSForCircuitSize(subgroupSize);
+  }
+
+  async destroy() {
+    await this.wasm.destroy();
+    await this.worker.terminate();
+  }
+}
+
+let barretenbergSyncSingleton: BarretenbergSync;
+let barretenbergSyncSingletonPromise: Promise<BarretenbergSync>;
+
+export class BarretenbergSync extends BarretenbergApiSync {
+  private constructor(wasm: BarretenbergWasmMain) {
+    super(wasm);
+  }
+
+  static async new() {
+    const wasm = new BarretenbergWasmMain();
+    const { module, threads } = await fetchModuleAndThreads(1);
+    await wasm.init(module, threads);
+    return new BarretenbergSync(wasm);
+  }
+
+  static initSingleton() {
+    if (!barretenbergSyncSingletonPromise) {
+      barretenbergSyncSingletonPromise = BarretenbergSync.new().then(s => (barretenbergSyncSingleton = s));
+    }
+    return barretenbergSyncSingletonPromise;
+  }
+
+  static getSingleton() {
+    if (!barretenbergSyncSingleton) {
+      throw new Error('First call BarretenbergSync.initSingleton() on @aztec/bb.js module.');
+    }
+    return barretenbergSyncSingleton;
+  }
+
+  getWasm() {
+    return this.wasm;
+  }
+}
+
+// If we're in ESM environment, use top level await. CJS users need to call it manually.
+// Need to ignore for cjs build.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+await BarretenbergSync.initSingleton(); // POSTPROCESS ESM ONLY

package/src/barretenberg/pedersen.test.ts

@@ -0,0 +1,62 @@
+import { BarretenbergSync } from './index.js';
+import { Timer } from '../benchmark/timer.js';
+import { Fr } from '../types/index.js';
+
+describe('pedersen sync', () => {
+  let api: BarretenbergSync;
+
+  beforeAll(async () => {
+    api = await BarretenbergSync.new();
+  });
+
+  it('pedersenHash', () => {
+    const result = api.pedersenHash([new Fr(4n), new Fr(8n)], 7);
+    expect(result).toMatchSnapshot();
+  });
+
+  it('pedersenHash perf test', () => {
+    const loops = 1000;
+    const fields = Array.from({ length: loops * 2 }).map(() => Fr.random());
+    const t = new Timer();
+    for (let i = 0; i < loops; ++i) {
+      api.pedersenHash([fields[i * 2], fields[i * 2 + 1]], 0);
+    }
+    const us = t.us() / loops;
+    console.log(`Executed ${loops} hashes at an average ${us}us / hash`);
+  });
+
+  it('pedersenHashes perf test', () => {
+    const loops = 10;
+    const numHashesPerLoop = 1024;
+    const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
+    const t = new Timer();
+    for (let i = 0; i < loops; ++i) {
+      api.pedersenHashes(fields, 0);
+    }
+    const us = t.us() / (numHashesPerLoop * loops);
+    console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
+  });
+
+  it('pedersenHashBuffer', () => {
+    const input = Buffer.alloc(123);
+    input.writeUint32BE(321, 0);
+    input.writeUint32BE(456, 119);
+    const r = api.pedersenHashBuffer(input, 0);
+    expect(r).toMatchSnapshot();
+  });
+
+  it('pedersenCommit', () => {
+    const result = api.pedersenCommit([new Fr(4n), new Fr(8n), new Fr(12n)], 0);
+    expect(result).toMatchSnapshot();
+  });
+
+  it.skip('pedersenCommit perf test', () => {
+    const loops = 1000;
+    const fields = Array.from({ length: loops * 2 }).map(() => Fr.random());
+    const t = new Timer();
+    for (let i = 0; i < loops; ++i) {
+      api.pedersenCommit([fields[i * 2], fields[i * 2 + 1]], 0);
+    }
+    console.log(t.us() / loops);
+  });
+});