@aztec/bb.js 3.0.0-nightly.20251115 → 3.0.0-nightly.20251119

package/src/barretenberg/backend.ts

@@ -1,8 +1,7 @@
-import { BackendOptions, Barretenberg, CircuitOptions } from './index.js';
+import { Barretenberg } from './index.js';
 import { ProofData, uint8ArrayToHex, hexToUint8Array } from '../proof/index.js';
 import { fromChonkProof, toChonkProof } from '../cbind/generated/api_types.js';
 import { ungzip } from 'pako';
-import { Buffer } from 'buffer';
 import { Decoder, Encoder } from 'msgpackr';
 
 export class AztecClientBackendError extends Error {
@@ -58,29 +57,12 @@ function getProofSettingsFromOptions(options?: UltraHonkBackendOptions): {
 }
 
 export class UltraHonkVerifierBackend {
-  protected api!: Barretenberg;
-
-  constructor(
-    protected backendOptions: BackendOptions = { threads: 1 },
-    protected circuitOptions: CircuitOptions = { recursive: false },
-  ) {}
-  /** @ignore */
-  private async instantiate(): Promise<void> {
-    if (!this.api) {
-      const api = await Barretenberg.new(this.backendOptions);
-      const honkRecursion = true;
-      await api.initSRSForCircuitSize(0);
-
-      this.api = api;
-    }
-  }
+  constructor(private api: Barretenberg) {}
 
   async verifyProof(
     proofData: ProofData & { verificationKey: Uint8Array },
     options?: UltraHonkBackendOptions,
   ): Promise<boolean> {
-    await this.instantiate();
-
     const proofFrs: Uint8Array[] = [];
     for (let i = 0; i < proofData.proof.length; i += 32) {
       proofFrs.push(proofData.proof.slice(i, i + 32));
@@ -93,12 +75,6 @@ export class UltraHonkVerifierBackend {
     });
     return verified;
   }
-  destroy(): Promise<void> {
-    if (!this.api) {
-      return Promise.resolve();
-    }
-    return this.api.destroy();
-  }
 }
 
 export class UltraHonkBackend {
@@ -107,37 +83,23 @@ export class UltraHonkBackend {
   // These are initialized asynchronously in the `init` function,
   // constructors cannot be asynchronous which is why we do this.
 
-  protected api!: Barretenberg;
-  protected acirUncompressedBytecode: Uint8Array;
+  private acirUncompressedBytecode: Uint8Array;
 
   constructor(
     acirBytecode: string,
-    protected backendOptions: BackendOptions = { threads: 1 },
-    protected circuitOptions: CircuitOptions = { recursive: false },
+    private api: Barretenberg,
   ) {
     this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
   }
-  /** @ignore */
-  private 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);
-
-      this.api = api;
-    }
-  }
 
   async generateProof(compressedWitness: Uint8Array, options?: UltraHonkBackendOptions): Promise<ProofData> {
-    await this.instantiate();
-
     const witness = ungzip(compressedWitness);
     const { proof, publicInputs } = await this.api.circuitProve({
       witness,
       circuit: {
         name: 'circuit',
-        bytecode: Buffer.from(this.acirUncompressedBytecode),
-        verificationKey: Buffer.from([]), // Empty VK - lower performance.
+        bytecode: this.acirUncompressedBytecode,
+        verificationKey: new Uint8Array(0), // Empty VK - lower performance.
       },
       settings: getProofSettingsFromOptions(options),
     });
@@ -153,8 +115,6 @@ export class UltraHonkBackend {
   }
 
   async verifyProof(proofData: ProofData, options?: UltraHonkBackendOptions): Promise<boolean> {
-    await this.instantiate();
-
     const proofFrs: Uint8Array[] = [];
     for (let i = 0; i < proofData.proof.length; i += 32) {
       proofFrs.push(proofData.proof.slice(i, i + 32));
@@ -177,12 +137,10 @@ export class UltraHonkBackend {
   }
 
   async getVerificationKey(options?: UltraHonkBackendOptions): Promise<Uint8Array> {
-    await this.instantiate();
-
     const vkResult = await this.api.circuitComputeVk({
       circuit: {
         name: 'circuit',
-        bytecode: Buffer.from(this.acirUncompressedBytecode),
+        bytecode: this.acirUncompressedBytecode,
       },
       settings: getProofSettingsFromOptions(options),
     });
@@ -191,7 +149,6 @@ export class UltraHonkBackend {
 
   /** @description Returns a solidity verifier */
   async getSolidityVerifier(vk: Uint8Array, options?: UltraHonkBackendOptions): Promise<string> {
-    await this.instantiate();
     const result = await this.api.circuitWriteSolidityVerifier({
       verificationKey: vk,
       settings: getProofSettingsFromOptions(options),
@@ -206,7 +163,6 @@ export class UltraHonkBackend {
     // 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.
@@ -220,7 +176,7 @@ export class UltraHonkBackend {
     const vkResult = await this.api.circuitComputeVk({
       circuit: {
         name: 'circuit',
-        bytecode: Buffer.from(this.acirUncompressedBytecode),
+        bytecode: this.acirUncompressedBytecode,
       },
       settings: getProofSettingsFromOptions({}),
     });
@@ -242,13 +198,6 @@ export class UltraHonkBackend {
       vkHash: uint8ArrayToHex(vkResult.hash),
     };
   }
-
-  async destroy(): Promise<void> {
-    if (!this.api) {
-      return;
-    }
-    await this.api.destroy();
-  }
 }
 
 export class AztecClientBackend {
@@ -257,22 +206,11 @@ export class AztecClientBackend {
   // These are initialized asynchronously in the `init` function,
   // constructors cannot be asynchronous which is why we do this.
 
-  protected api!: Barretenberg;
-
   constructor(
-    protected acirBuf: Uint8Array[],
-    protected options: BackendOptions = { threads: 1 },
+    private acirBuf: Uint8Array[],
+    private api: Barretenberg,
   ) {}
 
-  /** @ignore */
-  private async instantiate(): Promise<void> {
-    if (!this.api) {
-      const api = await Barretenberg.new(this.options);
-      await api.initSRSChonk();
-      this.api = api;
-    }
-  }
-
   async prove(witnessBuf: Uint8Array[], vksBuf: Uint8Array[] = []): Promise<[Uint8Array[], Uint8Array, Uint8Array]> {
     if (vksBuf.length !== 0 && this.acirBuf.length !== witnessBuf.length) {
       throw new AztecClientBackendError('Witness and bytecodes must have the same stack depth!');
@@ -281,7 +219,6 @@ export class AztecClientBackend {
       // NOTE: we allow 0 as an explicit 'I have no VKs'. This is a deprecated feature.
       throw new AztecClientBackendError('Witness and VKs must have the same stack depth!');
     }
-    await this.instantiate();
 
     // Queue IVC start with the number of circuits
     this.api.chonkStart({ numCircuits: this.acirBuf.length });
@@ -289,22 +226,22 @@ export class AztecClientBackend {
     // Queue load and accumulate for each circuit
     for (let i = 0; i < this.acirBuf.length; i++) {
       const bytecode = this.acirBuf[i];
-      const witness = witnessBuf[i] || Buffer.from([]);
-      const vk = vksBuf[i] || Buffer.from([]);
+      const witness = witnessBuf[i] || new Uint8Array(0);
+      const vk = vksBuf[i] || new Uint8Array(0);
       const functionName = `unknown_wasm_${i}`;
 
       // Load the circuit
       this.api.chonkLoad({
         circuit: {
           name: functionName,
-          bytecode: Buffer.from(bytecode),
-          verificationKey: Buffer.from(vk),
+          bytecode: bytecode,
+          verificationKey: vk,
         },
       });
 
       // Accumulate with witness
       this.api.chonkAccumulate({
-        witness: Buffer.from(witness),
+        witness,
       });
     }
 
@@ -336,16 +273,14 @@ export class AztecClientBackend {
   }
 
   async verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean> {
-    await this.instantiate();
     const result = await this.api.chonkVerify({
       proof: toChonkProof(new Decoder({ useRecords: false }).decode(proof)),
-      vk: Buffer.from(vk),
+      vk,
     });
     return result.valid;
   }
 
   async gates(): Promise<number[]> {
-    await this.instantiate();
     const circuitSizes: number[] = [];
     for (const buf of this.acirBuf) {
       const gates = await this.api.chonkStats({
@@ -359,13 +294,6 @@ export class AztecClientBackend {
     }
     return circuitSizes;
   }
-
-  async destroy(): Promise<void> {
-    if (!this.api) {
-      return;
-    }
-    await this.api.destroy();
-  }
 }
 
 // Converts bytecode from a base64 string to a Uint8Array
@@ -374,17 +302,11 @@ function acirToUint8Array(base64EncodedBytecode: string): Uint8Array {
   return ungzip(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.
+// Base64 decode using atob (works in both browser and Node.js 18+)
 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
+  if (typeof atob === 'function') {
     return Uint8Array.from(atob(input), c => c.charCodeAt(0));
   } else {
-    throw new Error('No implementation found for base64 decoding.');
+    throw new Error('atob is not available. Node.js 18+ or browser required.');
   }
 }

package/src/barretenberg/blake2s.test.ts

@@ -1,5 +1,5 @@
 import { BackendType, Barretenberg, BarretenbergSync } from './index.js';
-import { Fr } from '../types/index.js';
+import { Fr } from './testing/fields.js';
 
 describe('blake2s async', () => {
   let api: Barretenberg;

package/src/barretenberg/index.ts

@@ -31,7 +31,7 @@ export class Barretenberg extends AsyncApi {
    *
    * If options.backend is set: uses that specific backend (throws if unavailable)
    * If options.backend is unset: tries backends in order with fallback:
-   *   1. NativeSharedMemory (if bb binary available)
+   *   1. NativeUnixSocket (if bb binary available)
    *   2. WasmWorker (in browser) or Wasm (in Node.js)
    */
   static async new(options: BackendOptions = {}) {
@@ -39,35 +39,30 @@ export class Barretenberg extends AsyncApi {
 
     if (options.backend) {
       // Explicit backend required - no fallback
-      return await createAsyncBackend(options.backend, options, logger);
+      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.NativeSharedMemory, options, logger);
+        return await createAsyncBackend(BackendType.NativeUnixSocket, options, logger);
       } catch (err: any) {
-        logger(`Shared memory unavailable (${err.message}), falling back to other backends`);
-        try {
-          return await createAsyncBackend(BackendType.NativeUnixSocket, options, logger);
-        } catch (err: any) {
-          logger(`Unix socket unavailable (${err.message}), falling back to WASM`);
-          return await createAsyncBackend(BackendType.Wasm, options, logger);
-        }
+        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.`);
-      return await createAsyncBackend(BackendType.WasmWorker, options, logger);
+      const backend = await createAsyncBackend(BackendType.WasmWorker, options, logger);
+      await backend.initSRSChonk();
+      return backend;
     }
   }
 
-  async initSRSForCircuitSize(circuitSize: number): Promise<void> {
-    const minSRSSize = 2 ** 9; // 2**9 is the dyadic size for the SmallSubgroupIPA MSM.
-    const crs = await Crs.new(Math.max(circuitSize, minSRSSize) + 1, this.options.crsPath, this.options.logger);
-    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1129): Do slab allocator initialization?
-    // await this.commonInitSlabAllocator(circuitSize);
-    await this.srsInitSrs({ pointsBuf: crs.getG1Data(), numPoints: crs.numPoints, g2Point: crs.getG2Data() });
-  }
-
   async initSRSChonk(srsSize = this.getDefaultSrsSize()): Promise<void> {
     // crsPath can be undefined
     const crs = await Crs.new(srsSize + 1, this.options.crsPath, this.options.logger);
@@ -106,11 +101,6 @@ export class Barretenberg extends AsyncApi {
     return [response.numGates, response.numGatesDyadic];
   }
 
-  async acirInitSRS(bytecode: Uint8Array, recursive: boolean, honkRecursion: boolean): Promise<void> {
-    const [_, subgroupSize] = await this.acirGetCircuitSizes(bytecode, recursive, honkRecursion);
-    return this.initSRSForCircuitSize(subgroupSize);
-  }
-
   async destroy() {
     return super.destroy();
   }

package/src/barretenberg/pedersen.test.ts

@@ -1,6 +1,6 @@
 import { BarretenbergSync } from './index.js';
 import { Timer } from '../benchmark/timer.js';
-import { Fr } from '../types/index.js';
+import { Fr } from './testing/fields.js';
 
 describe('pedersen sync', () => {
   let api: BarretenbergSync;