@aztec/bb.js 0.87.2 → 0.87.3-nightly.20250528

package/src/barretenberg_api/index.ts

@@ -408,7 +408,7 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirProveUltraKeccakZKHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
+  async acirProveUltraKeccakZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
     const inArgs = [acirVec, witnessVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
@@ -432,6 +432,18 @@ export class BarretenbergApi {
     return out[0];
   }
 
+  async acirProveUltraStarknetZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_prove_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
   async acirVerifyUltraHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
     const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
@@ -456,7 +468,7 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirVerifyUltraKeccakZKHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+  async acirVerifyUltraKeccakZkHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
     const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
     const result = await this.wasm.callWasmExport(
@@ -480,6 +492,18 @@ export class BarretenbergApi {
     return out[0];
   }
 
+  async acirVerifyUltraStarknetZkHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): Promise<boolean> {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_verify_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
   async acirWriteVkUltraHonk(acirVec: Uint8Array): Promise<Uint8Array> {
     const inArgs = [acirVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
@@ -504,7 +528,7 @@ export class BarretenbergApi {
     return out[0];
   }
 
-  async acirWriteVkUltraKeccakZKHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+  async acirWriteVkUltraKeccakZkHonk(acirVec: Uint8Array): Promise<Uint8Array> {
     const inArgs = [acirVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = await this.wasm.callWasmExport(
@@ -528,6 +552,18 @@ export class BarretenbergApi {
     return out[0];
   }
 
+  async acirWriteVkUltraStarknetZkHonk(acirVec: Uint8Array): Promise<Uint8Array> {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = await this.wasm.callWasmExport(
+      'acir_write_vk_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
   async acirProofAsFieldsUltraHonk(proofBuf: Uint8Array): Promise<Fr[]> {
     const inArgs = [proofBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [VectorDeserializer(Fr)];
@@ -964,7 +1000,7 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
-  acirProveUltraKeccakZKHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+  acirProveUltraKeccakZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
     const inArgs = [acirVec, witnessVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = this.wasm.callWasmExport(
@@ -976,11 +1012,23 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
-  acirProveUltraKeccakZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+  acirProveUltraStarknetHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
     const inArgs = [acirVec, witnessVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = this.wasm.callWasmExport(
-      'acir_prove_ultra_keccak_zk_honk',
+      'acir_prove_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
+  acirProveUltraStarknetZkHonk(acirVec: Uint8Array, witnessVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec, witnessVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_prove_ultra_starknet_zk_honk',
       inArgs,
       outTypes.map(t => t.SIZE_IN_BYTES),
     );
@@ -1000,7 +1048,19 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
-  acirVerifyUltraKeccakZKHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+  acirVerifyUltraKeccakHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_ultra_keccak_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
+  acirVerifyUltraKeccakZkHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
     const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [BoolDeserializer()];
     const result = this.wasm.callWasmExport(
@@ -1012,6 +1072,30 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
+  acirVerifyUltraStarknetHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
+  acirVerifyUltraStarknetZkHonk(proofBuf: Uint8Array, vkBuf: Uint8Array): boolean {
+    const inArgs = [proofBuf, vkBuf].map(serializeBufferable);
+    const outTypes: OutputType[] = [BoolDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_verify_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
   acirWriteVkUltraHonk(acirVec: Uint8Array): Uint8Array {
     const inArgs = [acirVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
@@ -1036,7 +1120,7 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
-  acirWriteVkUltraKeccakZKHonk(acirVec: Uint8Array): Uint8Array {
+  acirWriteVkUltraKeccakZkHonk(acirVec: Uint8Array): Uint8Array {
     const inArgs = [acirVec].map(serializeBufferable);
     const outTypes: OutputType[] = [BufferDeserializer()];
     const result = this.wasm.callWasmExport(
@@ -1048,6 +1132,30 @@ export class BarretenbergApiSync {
     return out[0];
   }
 
+  acirWriteVkUltraStarknetHonk(acirVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_write_vk_ultra_starknet_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
+  acirWriteVkUltraStarknetZkHonk(acirVec: Uint8Array): Uint8Array {
+    const inArgs = [acirVec].map(serializeBufferable);
+    const outTypes: OutputType[] = [BufferDeserializer()];
+    const result = this.wasm.callWasmExport(
+      'acir_write_vk_ultra_starknet_zk_honk',
+      inArgs,
+      outTypes.map(t => t.SIZE_IN_BYTES),
+    );
+    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
+    return out[0];
+  }
+
   acirProofAsFieldsUltraHonk(proofBuf: Uint8Array): Fr[] {
     const inArgs = [proofBuf].map(serializeBufferable);
     const outTypes: OutputType[] = [VectorDeserializer(Fr)];

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -1,4 +1,4 @@
-import createDebug from 'debug';
+import { createDebugLogger } from '../../log/index.js';
 import { randomBytes } from '../../random/index.js';
 
 /**
@@ -9,7 +9,7 @@ export class BarretenbergWasmBase {
   protected memStore: { [key: string]: Uint8Array } = {};
   protected memory!: WebAssembly.Memory;
   protected instance!: WebAssembly.Instance;
-  protected logger: (msg: string) => void = createDebug('bb.js:bb_wasm_base');
+  protected logger: (msg: string) => void = createDebugLogger('bb_wasm_base');
 
   protected getImportObj(memory: WebAssembly.Memory) {
     /* eslint-disable camelcase */

package/src/barretenberg_wasm/barretenberg_wasm_main/factory/browser/index.ts

@@ -1,15 +1,11 @@
-import debug from 'debug';
+import { logOptions } from '../../../../log/index.js';
 import { readinessListener } from '../../../helpers/browser/index.js';
 
 export async function createMainWorker() {
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
-  const worker = new Worker(new URL(/* webpackIgnore: true */ './main.worker.js', import.meta.url), {
-    type: 'module',
-  });
-  const debugStr = debug.disable();
-  debug.enable(debugStr);
-  worker.postMessage({ debug: debugStr });
+  const worker = new Worker(new URL('./main.worker.js', import.meta.url), { type: 'module' });
+  worker.postMessage({ log: logOptions });
   await new Promise<void>(resolve => readinessListener(worker, resolve));
   return worker;
 }

package/src/barretenberg_wasm/barretenberg_wasm_main/factory/browser/main.worker.ts

@@ -1,11 +1,11 @@
 import { expose } from 'comlink';
 import { BarretenbergWasmMain } from '../../index.js';
-import debug from 'debug';
 import { Ready } from '../../../helpers/browser/index.js';
+import { initLogger } from '../../../../log/browser/index.js';
 
 addEventListener('message', e => {
-  if (e.data.debug) {
-    debug.enable(e.data.debug);
+  if (e.data.log) {
+    initLogger(e.data.log);
   }
 });
 

package/src/barretenberg_wasm/barretenberg_wasm_main/factory/node/index.ts

@@ -1,6 +1,7 @@
 import { Worker } from 'worker_threads';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { logOptions } from '../../../../log/index.js';
 
 function getCurrentDir() {
   if (typeof __dirname !== 'undefined') {
@@ -14,5 +15,7 @@ function getCurrentDir() {
 
 export function createMainWorker() {
   const __dirname = getCurrentDir();
-  return Promise.resolve(new Worker(__dirname + `/main.worker.js`));
+  const worker = new Worker(__dirname + `/main.worker.js`);
+  worker.postMessage({ log: logOptions });
+  return Promise.resolve(worker);
 }

package/src/barretenberg_wasm/barretenberg_wasm_main/factory/node/main.worker.ts

@@ -2,9 +2,18 @@ import { parentPort } from 'worker_threads';
 import { expose } from 'comlink';
 import { BarretenbergWasmMain } from '../../index.js';
 import { nodeEndpoint } from '../../../helpers/node/node_endpoint.js';
+import { initLogger } from '../../../../log/node/index.js';
 
 if (!parentPort) {
   throw new Error('No parentPort');
 }
 
+const endpoint = nodeEndpoint(parentPort);
+
+endpoint.addEventListener('message', (e: any) => {
+  if (e.data.log) {
+    initLogger(e.data.log);
+  }
+});
+
 expose(new BarretenbergWasmMain(), nodeEndpoint(parentPort));

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -1,11 +1,11 @@
 import { type Worker } from 'worker_threads';
-import createDebug from 'debug';
 import { Remote } from 'comlink';
 import { getNumCpu, getRemoteBarretenbergWasm, getSharedMemoryAvailable } from '../helpers/index.js';
 import { createThreadWorker } from '../barretenberg_wasm_thread/factory/node/index.js';
 import { type BarretenbergWasmThreadWorker } from '../barretenberg_wasm_thread/index.js';
 import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
 import { HeapAllocator } from './heap_allocator.js';
+import { createDebugLogger } from '../../log/index.js';
 
 /**
  * This is the "main thread" implementation of BarretenbergWasm.
@@ -29,7 +29,7 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   public async init(
     module: WebAssembly.Module,
     threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
-    logger: (msg: string) => void = createDebug('bb.js:bb_wasm'),
+    logger: (msg: string) => void = createDebugLogger('bb_wasm'),
     initial = 32,
     maximum = 2 ** 16,
   ) {

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/index.ts

@@ -1,15 +1,11 @@
-import debug from 'debug';
+import { logOptions } from '../../../../log/index.js';
 import { readinessListener } from '../../../helpers/browser/index.js';
 
 export async function createThreadWorker() {
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
-  const worker = new Worker(new URL(/* webpackIgnore: true */ './thread.worker.js', import.meta.url), {
-    type: 'module',
-  });
-  const debugStr = debug.disable();
-  debug.enable(debugStr);
-  worker.postMessage({ debug: debugStr });
+  const worker = new Worker(new URL('./thread.worker.js', import.meta.url), { type: 'module' });
+  worker.postMessage({ log: logOptions });
   await new Promise<void>(resolve => readinessListener(worker, resolve));
   return worker;
 }

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/thread.worker.ts

@@ -1,11 +1,11 @@
 import { expose } from 'comlink';
 import { BarretenbergWasmThread } from '../../index.js';
-import debug from 'debug';
 import { Ready } from '../../../helpers/browser/index.js';
+import { initLogger } from '../../../../log/browser/index.js';
 
 addEventListener('message', e => {
-  if (e.data.debug) {
-    debug.enable(e.data.debug);
+  if (e.data.log) {
+    initLogger(e.data.log);
   }
 });
 

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/node/index.ts

@@ -1,6 +1,7 @@
 import { Worker } from 'worker_threads';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { logOptions } from '../../../../log/index.js';
 
 function getCurrentDir() {
   if (typeof __dirname !== 'undefined') {
@@ -14,5 +15,7 @@ function getCurrentDir() {
 
 export function createThreadWorker() {
   const __dirname = getCurrentDir();
-  return Promise.resolve(new Worker(__dirname + `/thread.worker.js`));
+  const worker = new Worker(__dirname + `/thread.worker.js`);
+  worker.postMessage({ log: logOptions });
+  return Promise.resolve(worker);
 }

package/src/barretenberg_wasm/barretenberg_wasm_thread/factory/node/thread.worker.ts

@@ -2,9 +2,18 @@ import { parentPort } from 'worker_threads';
 import { expose } from 'comlink';
 import { BarretenbergWasmThread } from '../../index.js';
 import { nodeEndpoint } from '../../../helpers/node/node_endpoint.js';
+import { initLogger } from '../../../../log/node/index.js';
 
 if (!parentPort) {
   throw new Error('No parentPort');
 }
 
-expose(new BarretenbergWasmThread(), nodeEndpoint(parentPort));
+const endpoint = nodeEndpoint(parentPort);
+
+endpoint.addEventListener('message', (e: any) => {
+  if (e.data.log) {
+    initLogger(e.data.log);
+  }
+});
+
+expose(new BarretenbergWasmThread(), endpoint);

package/src/barretenberg_wasm/fetch_code/browser/index.ts

@@ -12,8 +12,8 @@ export async function fetchCode(multithreaded: boolean, wasmPath?: string) {
     url = `${filePath}/${fileName}${suffix}.${extensions.join('.')}`;
   } else {
     url = multithreaded
-      ? (await import(/* webpackIgnore: true */ './barretenberg-threads.js')).default
-      : (await import(/* webpackIgnore: true */ './barretenberg.js')).default;
+      ? (await import('./barretenberg-threads.js')).default
+      : (await import('./barretenberg.js')).default;
   }
   const res = await fetch(url);
   // Default bb wasm is compressed, but user could point it to a non-compressed version
@@ -27,7 +27,7 @@ export async function fetchCode(multithreaded: boolean, wasmPath?: string) {
     buffer[2] === 0x08;
   if (isGzip) {
     const decompressedData = pako.ungzip(buffer);
-    return decompressedData.buffer;
+    return decompressedData.buffer as unknown as Uint8Array<ArrayBuffer>;
   } else {
     return buffer;
   }

package/src/barretenberg_wasm/fetch_code/node/index.ts

@@ -27,7 +27,7 @@ export async function fetchCode(multithreaded: boolean, wasmPath?: string) {
     buffer[2] === 0x08;
   if (isGzip) {
     const decompressedData = pako.ungzip(buffer);
-    return decompressedData.buffer;
+    return decompressedData.buffer as unknown as Uint8Array<ArrayBuffer>;
   } else {
     return buffer;
   }

package/src/barretenberg_wasm/helpers/browser/index.ts

@@ -21,6 +21,15 @@ export function killSelf() {
   self.close();
 }
 
+export function getAvailableThreads(logger: (msg: string) => void): number {
+  if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
+    return navigator.hardwareConcurrency;
+  } else {
+    logger(`Could not detect environment to query number of threads. Falling back to one thread.`);
+    return 1;
+  }
+}
+
 // Solution to async initialization of workers, taken from
 // https://github.com/GoogleChromeLabs/comlink/issues/635#issuecomment-1598913044
 

package/src/barretenberg_wasm/helpers/node/index.ts

@@ -42,3 +42,14 @@ export function killSelf(): never {
   process.kill(process.pid);
   throw new Error();
 }
+
+export function getAvailableThreads(logger: (msg: string) => void): number {
+  try {
+    return os.cpus().length;
+  } catch (e: any) {
+    logger(
+      `Could not detect environment to query number of threads. Falling back to one thread. Error: ${e.message ?? e}`,
+    );
+    return 1;
+  }
+}

package/src/barretenberg_wasm/index.ts

@@ -1,11 +1,11 @@
-import createDebug from 'debug';
-import { getSharedMemoryAvailable } from './helpers/node/index.js';
+import { getSharedMemoryAvailable, getAvailableThreads } from './helpers/node/index.js';
 import { fetchCode } from './fetch_code/index.js';
+import { createDebugLogger } from '../log/index.js';
 
 export async function fetchModuleAndThreads(
   desiredThreads = 32,
   wasmPath?: string,
-  logger: (msg: string) => void = createDebug('bb.js:fetch_mat'),
+  logger: (msg: string) => void = createDebugLogger('fetch_mat'),
 ) {
   const shared = getSharedMemoryAvailable();
 
@@ -20,19 +20,3 @@ export async function fetchModuleAndThreads(
   logger('Compilation of bb wasm complete');
   return { module, threads: limitedThreads };
 }
-
-async function getAvailableThreads(logger: (msg: string) => void): Promise<number> {
-  if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
-    return navigator.hardwareConcurrency;
-  } else {
-    try {
-      const os = await import('os');
-      return os.cpus().length;
-    } catch (e: any) {
-      logger(
-        `Could not detect environment to query number of threads. Falling back to one thread. Error: ${e.message ?? e}`,
-      );
-      return 1;
-    }
-  }
-}

package/src/crs/node/index.ts

@@ -2,9 +2,9 @@ import { NetCrs, NetGrumpkinCrs } from '../net_crs.js';
 import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync, createWriteStream } from 'fs';
 import { stat } from 'fs/promises';
 import { Readable } from 'stream';
-import createDebug from 'debug';
 import { homedir } from 'os';
 import { finished } from 'stream/promises';
+import { createDebugLogger } from '../../log/index.js';
 
 /**
  * Generic CRS finder utility class.
@@ -13,13 +13,13 @@ export class Crs {
   constructor(
     public readonly numPoints: number,
     public readonly path: string,
-    private readonly logger: (msg: string) => void = createDebug('bb.js:crs'),
+    private readonly logger: (msg: string) => void = createDebugLogger('crs'),
   ) {}
 
   static async new(
     numPoints: number,
     crsPath = homedir() + '/.bb-crs',
-    logger: (msg: string) => void = createDebug('bb.js:crs'),
+    logger: (msg: string) => void = createDebugLogger('crs'),
   ) {
     const crs = new Crs(numPoints, crsPath, logger);
     await crs.init();
@@ -82,13 +82,13 @@ export class GrumpkinCrs {
   constructor(
     public readonly numPoints: number,
     public readonly path: string,
-    private readonly logger: (msg: string) => void = createDebug('bb.js:crs'),
+    private readonly logger: (msg: string) => void = createDebugLogger('crs'),
   ) {}
 
   static async new(
     numPoints: number,
     crsPath = homedir() + '/.bb-crs',
-    logger: (msg: string) => void = createDebug('bb.js:crs'),
+    logger: (msg: string) => void = createDebugLogger('crs'),
   ) {
     const crs = new GrumpkinCrs(numPoints, crsPath, logger);
     await crs.init();

package/src/index.ts

@@ -8,5 +8,6 @@ export {
   AztecClientBackend,
 } from './barretenberg/index.js';
 
+export { randomBytes } from './random/index.js';
 export { RawBuffer, Fr } from './types/index.js';
 export { splitHonkProof, reconstructHonkProof, deflattenFields, type ProofData } from './proof/index.js';

package/src/log/browser/index.ts

@@ -0,0 +1,35 @@
+import { pino } from 'pino';
+import { LogOptions } from '../types.js';
+import { Logger } from 'pino';
+
+const defaultOptions = {
+  name: 'bb.js',
+  useOnlyCustomLevels: false,
+  customLevels: { verbose: 25 },
+  browser: { asObject: false },
+};
+
+// Options must be exposed so they can be provided to threads upon creation
+// This way we ensure all loggers are spawned with the same options
+export let logOptions: LogOptions | undefined;
+
+let logger: Logger<'verbose'> | undefined;
+
+export function initLogger({ level = 'info' }: LogOptions = { level: 'info', useStdErr: false }) {
+  if (logger) {
+    return logger;
+  }
+  logOptions = { level, useStdErr: false };
+  logger = pino({ ...defaultOptions, level });
+}
+
+export function createDebugLogger(name: string) {
+  initLogger();
+
+  const sublogger = logger!.child({
+    name,
+  });
+  return (msg: string) => {
+    sublogger.debug(msg);
+  };
+}

package/src/log/index.ts

@@ -0,0 +1 @@
+export { initLogger, createDebugLogger, logOptions } from './node/index.js';

package/src/log/node/index.ts

@@ -0,0 +1,41 @@
+import { Logger, pino } from 'pino';
+import { LogLevels, LogOptions } from '../types.js';
+
+const defaultOptions = {
+  name: 'bb.js',
+  useOnlyCustomLevels: false,
+  customLevels: { verbose: 25 },
+};
+
+const defaultLevel = (process.env.LOG_LEVEL || 'info') as LogLevels;
+
+// Options must be exposed so they can be provided to threads upon creation
+// This way we ensure all loggers are spawned with the same options
+export let logOptions: LogOptions | undefined;
+
+let logger: Logger<'verbose'> | undefined;
+
+export function initLogger(
+  { level = defaultLevel, useStdErr = false }: LogOptions = { level: defaultLevel, useStdErr: false },
+) {
+  if (logger) {
+    return logger;
+  }
+  logOptions = { level, useStdErr };
+  const transport = pino.transport({
+    target: 'pino/file',
+    options: { destination: useStdErr ? 2 : 1 },
+  });
+  logger = pino({ ...defaultOptions, level }, transport);
+}
+
+export function createDebugLogger(name: string) {
+  initLogger();
+
+  const sublogger = logger!.child({
+    name,
+  });
+  return (msg: string) => {
+    sublogger.debug(msg);
+  };
+}

package/src/log/types.ts

@@ -0,0 +1,6 @@
+export type LogLevels = 'silent' | 'info' | 'debug' | 'warn' | 'error' | 'trace' | 'verbose';
+
+export type LogOptions = {
+  level: LogLevels;
+  useStdErr: boolean;
+};