@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.0208eb9

package/src/barretenberg/index.ts

@@ -0,0 +1,220 @@
+import { Crs, GrumpkinCrs } from '../crs/index.js';
+import { AsyncApi } from '../cbind/generated/async.js';
+import { SyncApi } from '../cbind/generated/sync.js';
+import { IMsgpackBackendSync, IMsgpackBackendAsync } from '../bb_backends/interface.js';
+import { BackendOptions, BackendType } from '../bb_backends/index.js';
+import { createAsyncBackend, createSyncBackend } from '../bb_backends/node/index.js';
+
+export {
+  UltraHonkBackend,
+  UltraHonkVerifierBackend,
+  AztecClientBackend,
+  fieldToString,
+  fieldsToStrings,
+  type UltraHonkBackendOptions,
+  type VerifierTarget,
+} from './backend.js';
+export * from '../bb_backends/index.js';
+
+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 AsyncApi {
+  private options: BackendOptions;
+
+  constructor(backend: IMsgpackBackendAsync, options: BackendOptions) {
+    super(backend);
+    this.options = options;
+  }
+
+  /**
+   * Constructs an instance of Barretenberg.
+   *
+   * If options.backend is set: uses that specific backend (throws if unavailable)
+   * If options.backend is unset: tries backends in order with fallback:
+   *   1. NativeUnixSocket (if bb binary available)
+   *   2. WasmWorker (in browser) or Wasm (in Node.js)
+   */
+  static async new(options: BackendOptions = {}) {
+    const logger = options.logger ?? (() => {});
+
+    if (options.backend) {
+      // Explicit backend required - no fallback
+      const backend = await createAsyncBackend(options.backend, options, logger);
+      if (options.backend === BackendType.Wasm || options.backend === BackendType.WasmWorker) {
+        await backend.initSRSChonk();
+      }
+      return backend;
+    }
+
+    if (typeof window === 'undefined') {
+      try {
+        return await createAsyncBackend(BackendType.NativeUnixSocket, options, logger);
+      } catch (err: any) {
+        logger(`Unix socket unavailable (${err.message}), falling back to WASM`);
+        const backend = await createAsyncBackend(BackendType.Wasm, options, logger);
+        await backend.initSRSChonk();
+        return backend;
+      }
+    } else {
+      logger(`In browser, using WASM over worker backend.`);
+      const backend = await createAsyncBackend(BackendType.WasmWorker, options, logger);
+      await backend.initSRSChonk();
+      return backend;
+    }
+  }
+
+  async initSRSChonk(srsSize = this.getDefaultSrsSize()): Promise<void> {
+    // crsPath can be undefined
+    const crs = await Crs.new(srsSize + 1, this.options.crsPath, this.options.logger);
+    const grumpkinCrs = await GrumpkinCrs.new(2 ** 16 + 1, this.options.crsPath, this.options.logger);
+
+    // 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({ pointsBuf: crs.getG1Data(), numPoints: crs.numPoints, g2Point: crs.getG2Data() });
+    await this.srsInitGrumpkinSrs({ pointsBuf: grumpkinCrs.getG1Data(), numPoints: grumpkinCrs.numPoints });
+  }
+
+  getDefaultSrsSize(): number {
+    // iOS browser is very aggressive with memory. Check if running in browser and on iOS
+    // We expect the mobile iOS browser to kill us >=1GB, so no real use in using a larger SRS.
+    if (typeof window !== 'undefined' && /iPad|iPhone/.test(navigator.userAgent)) {
+      return 2 ** 18;
+    }
+    return 2 ** 20;
+  }
+
+  async acirGetCircuitSizes(
+    bytecode: Uint8Array,
+    recursive: boolean,
+    honkRecursion: boolean,
+  ): Promise<[number, number]> {
+    const response = await this.circuitStats({
+      circuit: { name: '', bytecode, verificationKey: new Uint8Array() },
+      includeGatesPerOpcode: false,
+      settings: {
+        ipaAccumulation: false,
+        oracleHashType: honkRecursion ? 'poseidon2' : 'keccak',
+        disableZk: !recursive,
+        optimizedSolidityVerifier: false,
+      },
+    });
+    return [response.numGates, response.numGatesDyadic];
+  }
+
+  async destroy() {
+    return super.destroy();
+  }
+
+  /**
+   * Initialize the singleton instance of Barretenberg.
+   * @param options Backend configuration options
+   */
+  static async initSingleton(options: BackendOptions = {}) {
+    if (!barretenbergSingletonPromise) {
+      barretenbergSingletonPromise = Barretenberg.new(options);
+    }
+    try {
+      barretenbergSingleton = await barretenbergSingletonPromise;
+      return barretenbergSingleton;
+    } catch (error) {
+      // If initialization fails, clear the singleton so next call can retry
+      barretenbergSingleton = undefined!;
+      barretenbergSingletonPromise = undefined!;
+      throw error;
+    }
+  }
+
+  static async destroySingleton() {
+    if (barretenbergSingleton) {
+      await barretenbergSingleton.destroy();
+      barretenbergSingleton = undefined!;
+      barretenbergSingletonPromise = undefined!;
+    }
+  }
+
+  /**
+   * Get the singleton instance of Barretenberg.
+   * Must call initSingleton() first.
+   */
+  static getSingleton() {
+    if (!barretenbergSingleton) {
+      throw new Error('First call Barretenberg.initSingleton() on @aztec/bb.js module.');
+    }
+    return barretenbergSingleton;
+  }
+}
+
+let barretenbergSingletonPromise: Promise<Barretenberg>;
+let barretenbergSingleton: Barretenberg;
+
+let barretenbergSyncSingletonPromise: Promise<BarretenbergSync>;
+let barretenbergSyncSingleton: BarretenbergSync;
+
+export class BarretenbergSync extends SyncApi {
+  constructor(backend: IMsgpackBackendSync) {
+    super(backend);
+  }
+
+  /**
+   * Create a new BarretenbergSync instance.
+   *
+   * If options.backend is set: uses that specific backend (throws if unavailable)
+   * If options.backend is unset: tries backends in order with fallback:
+   *   1. NativeSharedMem (if bb binary + NAPI module available)
+   *   2. Wasm
+   *
+   * Supported backends: Wasm, NativeSharedMem
+   * Not supported: WasmWorker (no workers in sync), NativeUnixSocket (async only)
+   */
+  static async new(options: BackendOptions = {}) {
+    const logger = options.logger ?? (() => {});
+
+    if (options.backend) {
+      return await createSyncBackend(options.backend, options, logger);
+    }
+
+    // Try native, fallback to WASM.
+    try {
+      return await createSyncBackend(BackendType.NativeSharedMemory, options, logger);
+    } catch (err: any) {
+      logger(`Shared memory unavailable (${err.message}), falling back to WASM`);
+    }
+
+    return await createSyncBackend(BackendType.Wasm, options, logger);
+  }
+
+  /**
+   * Initialize the singleton instance.
+   * @param options Backend configuration options
+   */
+  static async initSingleton(options: BackendOptions = {}) {
+    if (!barretenbergSyncSingletonPromise) {
+      barretenbergSyncSingletonPromise = BarretenbergSync.new(options);
+    }
+
+    barretenbergSyncSingleton = await barretenbergSyncSingletonPromise;
+    return barretenbergSyncSingleton;
+  }
+
+  static destroySingleton() {
+    if (barretenbergSyncSingleton) {
+      barretenbergSyncSingleton.destroy();
+      barretenbergSyncSingleton = undefined!;
+      barretenbergSyncSingletonPromise = undefined!;
+    }
+  }
+
+  static getSingleton() {
+    if (!barretenbergSyncSingleton) {
+      throw new Error('First call BarretenbergSync.initSingleton() on @aztec/bb.js module.');
+    }
+    return barretenbergSyncSingleton;
+  }
+}

package/src/barretenberg/pedersen.test.ts

@@ -0,0 +1,69 @@
+import { BarretenbergSync } from './index.js';
+import { Timer } from '../benchmark/timer.js';
+import { Fr } from './testing/fields.js';
+
+describe('pedersen sync', () => {
+  let api: BarretenbergSync;
+
+  beforeAll(async () => {
+    api = await BarretenbergSync.initSingleton();
+  });
+
+  it('pedersenHash', () => {
+    const response = api.pedersenHash({ inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer()], hashIndex: 7 });
+    const result = Fr.fromBuffer(response.hash);
+    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({ inputs: [fields[i * 2].toBuffer(), fields[i * 2 + 1].toBuffer()], hashIndex: 0 });
+    }
+    const us = t.us() / loops;
+    console.log(`Executed ${loops} hashes at an average ${us}us / hash`);
+  });
+
+  // TODO: pedersenHashes not yet in new msgpack API
+  // it.skip('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); // Not in new API yet
+  //   }
+  //   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 response = api.pedersenHashBuffer({ input, hashIndex: 0 });
+    const r = Fr.fromBuffer(response.hash);
+    expect(r).toMatchSnapshot();
+  });
+
+  it('pedersenCommit', () => {
+    const response = api.pedersenCommit({
+      inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer(), new Fr(12n).toBuffer()],
+      hashIndex: 0,
+    });
+    const result = { x: Fr.fromBuffer(response.point.x), y: Fr.fromBuffer(response.point.y) };
+    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({ inputs: [fields[i * 2].toBuffer(), fields[i * 2 + 1].toBuffer()], hashIndex: 0 });
+    }
+    console.log(t.us() / loops);
+  });
+});

package/src/barretenberg/poseidon.bench.test.ts

@@ -0,0 +1,271 @@
+import { Barretenberg, BarretenbergSync } from '../index.js';
+import { BarretenbergWasmMain } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { BackendType } from './index.js';
+import { Fr } from './testing/fields.js';
+
+/**
+ * Async API benchmark test: WASM vs Native backends with proper non-blocking I/O
+ *
+ * This test uses the async Barretenberg API which properly handles:
+ * - Non-blocking I/O for native backend (event-based)
+ * - Concurrent operations via promises
+ * - Better performance for native backend compared to sync API
+ */
+describe('poseidon2Hash benchmark (Async API): WASM vs Native', () => {
+  const ITERATIONS = 10000;
+  const SIZES = [2, 4, 8];
+
+  let wasmApi: Barretenberg | null = null;
+  let nativeSocketApi: Barretenberg | null = null;
+  let nativeShmApi: Barretenberg | null = null;
+  let nativeShmSyncApi: BarretenbergSync | null = null;
+  let wasm: BarretenbergWasmMain;
+
+  beforeAll(async () => {
+    // Setup direct WASM access for baseline benchmark (always required)
+    wasm = new BarretenbergWasmMain();
+    const { module } = await fetchModuleAndThreads(1);
+    await wasm.init(module, 1);
+
+    // Setup WASM API
+    try {
+      wasmApi = await Barretenberg.new({ backend: BackendType.Wasm, threads: 1 });
+    } catch (error) {
+      console.warn('Failed to initialize WASM backend:', error instanceof Error ? error.message : String(error));
+    }
+
+    // Setup native socket API
+    try {
+      nativeSocketApi = await Barretenberg.new({ backend: BackendType.NativeUnixSocket, threads: 1 });
+    } catch (error) {
+      console.warn(
+        'Failed to initialize Native Socket backend:',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+
+    // Setup native shared memory API (async)
+    try {
+      nativeShmApi = await Barretenberg.new({ backend: BackendType.NativeSharedMemory, threads: 1 });
+    } catch (error) {
+      console.warn(
+        'Failed to initialize Native Shared Memory (async) backend:',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+
+    // Setup native shared memory API (sync)
+    try {
+      nativeShmSyncApi = await BarretenbergSync.new({ backend: BackendType.NativeSharedMemory, threads: 1 });
+    } catch (error) {
+      console.warn(
+        'Failed to initialize Native Shared Memory (sync) backend:',
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }, 20000);
+
+  it.each(SIZES)(
+    'benchmark with %p field elements',
+    async size => {
+      // Generate random inputs
+      const inputs = Array(size)
+        .fill(0)
+        .map(() => Fr.random().toBuffer());
+
+      // Benchmark 1: WASM (async)
+      let wasmTime = 0;
+      if (wasmApi) {
+        const wasmStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          await wasmApi.poseidon2Hash({ inputs });
+        }
+        wasmTime = performance.now() - wasmStart;
+      }
+
+      // Benchmark 2: Native Socket (async with non-blocking I/O)
+      let nativeSocketTime = 0;
+      if (nativeSocketApi) {
+        const nativeSocketStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          await nativeSocketApi.poseidon2Hash({ inputs });
+        }
+        nativeSocketTime = performance.now() - nativeSocketStart;
+      }
+
+      // Benchmark 3: Native Socket (async, request pipelined)
+      let nativeSocketPipelinedTime = 0;
+      if (nativeSocketApi) {
+        const nativeSocketPipelinedStart = performance.now();
+        // Use promise.all to pipeline requests
+        const promises = [];
+        for (let i = 0; i < ITERATIONS; i++) {
+          promises.push(nativeSocketApi.poseidon2Hash({ inputs }));
+        }
+        await Promise.all(promises);
+        nativeSocketPipelinedTime = performance.now() - nativeSocketPipelinedStart;
+      }
+
+      // Benchmark 4: Native Shared Memory (async)
+      let nativeShmTime = 0;
+      if (nativeShmApi) {
+        const nativeShmStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          await nativeShmApi.poseidon2Hash({ inputs });
+        }
+        nativeShmTime = performance.now() - nativeShmStart;
+      }
+
+      // Benchmark 5: Native Shared Memory (async, request pipelined)
+      let nativeShmPipelinedTime = 0;
+      if (nativeShmApi) {
+        const nativeShmPipelinedStart = performance.now();
+        // Use promise.all to pipeline requests
+        const promises = [];
+        for (let i = 0; i < ITERATIONS; i++) {
+          promises.push(nativeShmApi.poseidon2Hash({ inputs }));
+        }
+        await Promise.all(promises);
+        nativeShmPipelinedTime = performance.now() - nativeShmPipelinedStart;
+      }
+
+      // Benchmark 6: Native Shared Memory (sync)
+      let nativeShmSyncTime = 0;
+      if (nativeShmSyncApi) {
+        const nativeShmSyncStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          nativeShmSyncApi.poseidon2Hash({ inputs });
+        }
+        nativeShmSyncTime = performance.now() - nativeShmSyncStart;
+      }
+
+      // Calculate metrics (all relative to WASM baseline)
+      const nativeSocketOverhead = ((nativeSocketTime - wasmTime) / wasmTime) * 100;
+      const nativeSocketPipelinedOverhead = ((nativeSocketPipelinedTime - wasmTime) / wasmTime) * 100;
+      const nativeShmOverhead = ((nativeShmTime - wasmTime) / wasmTime) * 100;
+      const nativeShmPipelinedOverhead = ((nativeShmPipelinedTime - wasmTime) / wasmTime) * 100;
+      const nativeShmSyncOverhead = ((nativeShmSyncTime - wasmTime) / wasmTime) * 100;
+
+      const avgWasmTimeUs = (wasmTime / ITERATIONS) * 1000;
+      const avgNativeSocketTimeUs = (nativeSocketTime / ITERATIONS) * 1000;
+      const avgNativeSocketPipelinedTimeUs = (nativeSocketPipelinedTime / ITERATIONS) * 1000;
+      const avgNativeShmTimeUs = (nativeShmTime / ITERATIONS) * 1000;
+      const avgNativeShmPipelinedTimeUs = (nativeShmPipelinedTime / ITERATIONS) * 1000;
+      const avgNativeShmSyncTimeUs = (nativeShmSyncTime / ITERATIONS) * 1000;
+
+      process.stdout.write(
+        `┌─ Size ${size.toString().padStart(3)} field elements ───────────────────────────────────────┐\n`,
+      );
+      const formatOverhead = (overhead: number): string => {
+        const sign = overhead >= 0 ? '+' : '-';
+        const value = Math.abs(overhead).toFixed(1).padStart(6);
+        return `${sign}${value}%`;
+      };
+
+      if (wasmApi) {
+        process.stdout.write(
+          `│ WASM:                    ${wasmTime.toFixed(2).padStart(8)}ms (${avgWasmTimeUs.toFixed(2).padStart(7)}µs/call) [baseline] │\n`,
+        );
+      } else {
+        process.stdout.write(`│ WASM:                                               unavailable │\n`);
+      }
+
+      if (nativeSocketApi) {
+        process.stdout.write(
+          `│ Native Socket:           ${nativeSocketTime.toFixed(2).padStart(8)}ms (${avgNativeSocketTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeSocketOverhead)}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Socket:                                      unavailable │\n`);
+      }
+
+      if (nativeSocketApi) {
+        process.stdout.write(
+          `│ Native Socket Pipelined: ${nativeSocketPipelinedTime
+            .toFixed(2)
+            .padStart(8)}ms (${avgNativeSocketPipelinedTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(
+            nativeSocketPipelinedOverhead,
+          )}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Socket Pipelined:                            unavailable │\n`);
+      }
+
+      if (nativeShmApi) {
+        process.stdout.write(
+          `│ Native Shared:           ${nativeShmTime.toFixed(2).padStart(8)}ms (${avgNativeShmTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmOverhead)}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Shared:                                      unavailable │\n`);
+      }
+
+      if (nativeShmApi) {
+        process.stdout.write(
+          `│ Native Shared Pipelined: ${nativeShmPipelinedTime.toFixed(2).padStart(8)}ms (${avgNativeShmPipelinedTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmPipelinedOverhead)}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Shared Pipelined:                            unavailable │\n`);
+      }
+
+      if (nativeShmSyncApi) {
+        process.stdout.write(
+          `│ Native Shared Sync:      ${nativeShmSyncTime.toFixed(2).padStart(8)}ms (${avgNativeShmSyncTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmSyncOverhead)}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Shared Sync:                                 unavailable │\n`);
+      }
+
+      process.stdout.write(`└─────────────────────────────────────────────────────────────────┘\n`);
+
+      const wasmResult = await wasmApi!.poseidon2Hash({ inputs });
+
+      if (nativeSocketApi) {
+        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeSocketResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      if (nativeShmApi) {
+        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      if (nativeShmSyncApi) {
+        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      // Test always passes, this is just for measuring performance
+      expect(true).toBe(true);
+    },
+    10000,
+  );
+
+  const TEST_VECTORS = [1, 2, 3, 5, 10, 50, 100];
+  const NUM_RANDOM_TESTS = 10;
+
+  it.each(TEST_VECTORS)('produces identical results for %p field elements', async size => {
+    // Test with multiple random input vectors
+    for (let test = 0; test < NUM_RANDOM_TESTS; test++) {
+      const inputs = Array(size)
+        .fill(0)
+        .map(() => Fr.random().toBuffer());
+
+      const wasmResult = await wasmApi!.poseidon2Hash({ inputs });
+
+      if (nativeSocketApi) {
+        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeSocketResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      if (nativeShmApi) {
+        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmResult.hash)).toEqual(wasmResult.hash);
+      }
+
+      if (nativeShmSyncApi) {
+        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(wasmResult.hash);
+      }
+    }
+  });
+});

package/src/barretenberg/poseidon.test.ts

@@ -0,0 +1,39 @@
+import { BarretenbergSync } from './index.js';
+import { Timer } from '../benchmark/timer.js';
+import { Fr } from './testing/fields.js';
+
+describe('poseidon sync', () => {
+  let api: BarretenbergSync;
+
+  beforeAll(async () => {
+    api = await BarretenbergSync.initSingleton();
+  });
+
+  it('poseidonHash', () => {
+    const result = api.poseidon2Hash({ inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer()] });
+    expect(result).toMatchSnapshot();
+  });
+
+  it('poseidonHash perf test', () => {
+    const loops = 1000;
+    const fields = Array.from({ length: loops * 2 }).map(() => Fr.random().toBuffer());
+    const t = new Timer();
+    for (let i = 0; i < loops; ++i) {
+      api.poseidon2Hash({ inputs: [fields[i * 2], fields[i * 2 + 1]] });
+    }
+    const us = t.us() / loops;
+    console.log(`Executed ${loops} hashes at an average ${us}us / hash`);
+  });
+
+  // it('poseidonHashes 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.poseidon2Hashes(fields);
+  //   }
+  //   const us = t.us() / (numHashesPerLoop * loops);
+  //   console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
+  // });
+});

package/src/barretenberg/testing/bigint-buffer.ts

@@ -0,0 +1,43 @@
+/**
+ * Convert a 32-byte BE Buffer to a BigInt.
+ */
+export function buffer32BytesToBigIntBE(buf: Buffer): bigint {
+  return (
+    (buf.readBigUInt64BE(0) << 192n) +
+    (buf.readBigUInt64BE(8) << 128n) +
+    (buf.readBigUInt64BE(16) << 64n) +
+    buf.readBigUInt64BE(24)
+  );
+}
+
+/**
+ * Convert a BE Uint8Array to a BigInt.
+ */
+export function uint8ArrayToBigIntBE(bytes: Uint8Array): bigint {
+  const buffer = Buffer.from(bytes);
+  return buffer32BytesToBigIntBE(buffer);
+}
+
+/**
+ * Convert a BigInt to a 32-byte BE Buffer.
+ */
+export function bigIntToBufferBE(value: bigint, byteLength = 32): Buffer {
+  if (byteLength != 32) {
+    throw new Error(
+      `Only 32 bytes supported for conversion from bigint to buffer, attempted byte length: ${byteLength}`,
+    );
+  }
+  const buf = Buffer.alloc(byteLength);
+  buf.writeBigUInt64BE(value >> 192n, 0);
+  buf.writeBigUInt64BE((value >> 128n) & 0xffffffffffffffffn, 8);
+  buf.writeBigUInt64BE((value >> 64n) & 0xffffffffffffffffn, 16);
+  buf.writeBigUInt64BE(value & 0xffffffffffffffffn, 24);
+  return buf;
+}
+
+/**
+ * Convert a BigInt to a 32-byte BE Uint8Array.
+ */
+export function bigIntToUint8ArrayBE(value: bigint, byteLength = 32): Uint8Array {
+  return new Uint8Array(bigIntToBufferBE(value, byteLength));
+}