@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-fake-c83136db25

package/README.md

@@ -1,120 +1,91 @@
 # bb.js
 
-Prover/verifier executable and API for barretenberg. Default cli arguments are appropriate for running within Noir
-project structures.
+Prover/verifier library for barretenberg. It bundles support for the following:
 
-## Performance and limitations
+- x86_64 on linux.
+- aarch64 on linux.
+- x86_64 on macos.
+- aarch64 on macos.
+- Single-threaded WASM.
+- Multi-threaded WASM.
 
-Max circuit size is 2^19 gates (524,288). This is due to the underlying WASM 4GB memory limit. This should improve
-with future proving systems, and/or introduction of wasm64.
-
-If running from terminal, or within browser where you can set shared memory COOP/COEP headers, multithreading is enabled.
-Note there are two independent WASM builds, one with threading enabled and one without. This is because the shared
-memory flag is set within the WASM itself. If you're running in a context where you can't have shared memory, we want
-to fallback to single threaded performance.
-
-Performance for 2^19 (small witness generation phase):
-
-- 16 core (not hyperthreads) x86: ~13s.
-- 10 core M1 Mac Pro: ~18s.
-
-Linear scaling was observed up to 32 cores.
-
-Witness generation phase is not multithreaded, and an interesting 512k circuit can take ~12s. This results in:
-
-- 16 core (not hyperthreads) x86: ~26s.
-- 10 core M1 Mac Pro: (TBD)
-
-## Using as a standalone binary
-
-### Installing
-
-To install the package globally for running as a terminal application:
-
-```
-npm install -g @aztec/bb.js@alpha
-```
-
-This will install `bb.js` into your path.
-
-### Usage
-
-Run `bb.js` for further usage information, you'll see e.g.
-
-```
-% bb.js
-Usage: bb.js [options] [command]
-
-Options:
-  -v, --verbose               enable verbose logging (default: false)
-  -h, --help                  display help for command
-
-Commands:
-  prove_and_verify [options]  Generate a proof and verify it. Process exits with success or failure code.
-  prove [options]             Generate a proof and write it to a file.
-  gates [options]             Print gate count to standard output.
-  verify [options]            Verify a proof. Process exists with success or failure code.
-  contract [options]          Output solidity verification key contract.
-  write_vk [options]          Output verification key.
-  proof_as_fields [options]   Return the proof as fields elements
-  vk_as_fields [options]      Return the verifiation key represented as fields elements. Also return the verification key hash.
-  help [command]              display help for command
-```
-
-## Using as a library
+If running within node.js on a support os/architecture we will use appropriate native code.
+If running within node.js on an unsupported architecture we will fallback to multi-threaded WASM.
+If running within the browser and served without COOP/COEP headers, we use the single-threaded WASM.
+If running within the browser served with COOP/COEP headers, we use the multi-threaded WASM.
 
 ### Installing
 
-To install as a package to be used as a library:
-
 ```
-npm install @aztec/bb.js@alpha
+npm install @aztec/bb.js
 ```
 
 or with yarn
 
 ```
-yarn add @aztec/bb.js@alpha
+yarn add @aztec/bb.js
 ```
 
 ### Usage
 
-To create a multithreaded version of the API:
+To create the API and do a blake2s hash:
 
 ```typescript
-const api = await newBarretenbergApiAsync(/* num_threads */);
-// Use.
+import { Crs, Barretenberg, RawBuffer } from './index.js';
+
+const api = await Barretenberg.new({ threads: 1 });
 const input = Buffer.from('hello world!');
 const result = await api.blake2s(input);
 await api.destroy();
 ```
 
-All methods are asynchronous. If no threads are specified, will default to number of cores with a maximum of 16.
+All methods are asynchronous. If no threads are specified, will default to number of cores with a maximum of 32.
 If `1` is specified, fallback to non multi-threaded wasm that doesn't need shared memory.
 
-You can also create a synchronous version of the api that also has no multi-threading. This is only useful in the
-browser if you don't call any multi-threaded functions. It's probably best to just always use async version of the api
-unless you're really trying to avoid the small overhead of worker communication.
+See `src/main.ts` for larger example of how to use.
+
+### Browser Context
+
+It's recommended to use a dynamic import. This allows the developer to pick the time at which the package (several MB
+in size) is loaded and keeps page load times responsive.
 
 ```typescript
-const api = await newBarretenbergApiSync();
-// Use.
-const input = Buffer.from('hello world!');
-const result = api.blake2s(input);
-await api.destroy();
+const { Barretenberg, RawBuffer, Crs } = await import('@aztec/bb.js');
 ```
 
-See `src/main.ts` for one example of how to use.
+### Multithreading in browser
+
+Multithreading in bb.js requires [`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) to be enabled. It is only enabled in browsers if COOP and COEP headers are set by the server. Read more [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements).
+
+You can configure your server to set these headers for pages that perform proof generation. See [this example project](https://github.com/saleel/gitclaim/blob/main/app/next.config.mjs#L48-L67) that implements multi-threaded browser proving, which contains the below Next.js config:
+
+```typescript
+{
+  ...
+  async headers() {
+    return [
+      {
+        source: '/:path*',
+        headers: [
+          { key: 'Cross-Origin-Embedder-Policy', value: 'require-corp' },
+          { key: 'Cross-Origin-Opener-Policy', value: 'same-origin' },
+        ],
+      },
+    ];
+  },
+}
+```
 
-## Development
+Note that adding COOP and COEP headers will disable loading of external scripts, which might be required by your application.
 
-Create a symlink to the root script `bb.js-dev` in your path. You can now run the current state of the code from
-anywhere in your filesystem with no `yarn build` required.
+You can enable these headers for specific pages that perform proof generation, but this may be challenging, especially in single-page applications. One workaround is to move the proof generation to a separate page, load it in an invisible iframe within your main application, and then use `postMessage` to communicate between the pages for generating proofs.
 
-If you change the C++ code run `yarn build:wasm`.
+## Debugging
 
-To run the tests run `yarn test`.
+Got an unhelpful stack trace in wasm? Run:
 
-To run a continuous "stress test" run `yarn simple_test` to do 10 full pk/proof/vk iterations.
+```
+BUILD_CPP=1 NO_STRIP=1 ./script/copy_wasm.sh
+```
 
-To run the same test in the browser run `yarn serve`, navigate to appropriate URL and open the console.
+This will drop unstripped wasms into the dest folder. Run your test again to get a trace.

package/dest/browser/async_map/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/async_map/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAMhG"}

package/dest/{async_map → browser/async_map}/index.js

@@ -13,4 +13,4 @@ export async function asyncMap(arr, fn) {
     }
     return results;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXN5bmNfbWFwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFFBQVEsQ0FBTyxHQUFRLEVBQUUsRUFBbUM7SUFDaEYsTUFBTSxPQUFPLEdBQVEsRUFBRSxDQUFDO0lBQ3hCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxFQUFFO1FBQ25DLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7S0FDbkM7SUFDRCxPQUFPLE9BQU8sQ0FBQztBQUNqQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXN5bmNfbWFwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFFBQVEsQ0FBTyxHQUFRLEVBQUUsRUFBbUM7SUFDaEYsTUFBTSxPQUFPLEdBQVEsRUFBRSxDQUFDO0lBQ3hCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUM7UUFDcEMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBQ0QsT0FBTyxPQUFPLENBQUM7QUFDakIsQ0FBQyJ9

package/dest/browser/barretenberg/backend.d.ts

@@ -0,0 +1,75 @@
+import { BackendOptions, Barretenberg, CircuitOptions } from './index.js';
+import { ProofData } from '../proof/index.js';
+export declare class AztecClientBackendError extends Error {
+    constructor(message: string);
+}
+/**
+ * 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;
+    /** 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.
+     */
+    keccakZK?: boolean;
+    /** Selecting this option will use the poseidon/stark252 hash function instead of poseidon
+     * when generating challenges in the proof.
+     * Use this when you want to verify the created proof on an Starknet chain with Garaga.
+     */
+    starknet?: boolean;
+    /** Selecting this option will use the poseidon/stark252 hash function instead of poseidon
+     * when generating challenges in the proof.
+     * Use this when you want to verify the created proof on an Starknet chain with Garaga.
+     */
+    starknetZK?: boolean;
+};
+export declare class UltraHonkVerifierBackend {
+    protected backendOptions: BackendOptions;
+    protected circuitOptions: CircuitOptions;
+    protected api: Barretenberg;
+    constructor(backendOptions?: BackendOptions, circuitOptions?: CircuitOptions);
+    /** @ignore */
+    private instantiate;
+    verifyProof(proofData: ProofData & {
+        verificationKey: Uint8Array;
+    }, options?: UltraHonkBackendOptions): Promise<boolean>;
+    destroy(): Promise<void>;
+}
+export declare class UltraHonkBackend {
+    protected backendOptions: BackendOptions;
+    protected circuitOptions: CircuitOptions;
+    protected api: Barretenberg;
+    protected acirUncompressedBytecode: Uint8Array;
+    constructor(acirBytecode: string, backendOptions?: BackendOptions, circuitOptions?: CircuitOptions);
+    /** @ignore */
+    private instantiate;
+    generateProof(compressedWitness: Uint8Array, options?: UltraHonkBackendOptions): Promise<ProofData>;
+    verifyProof(proofData: ProofData, options?: UltraHonkBackendOptions): Promise<boolean>;
+    getVerificationKey(options?: UltraHonkBackendOptions): Promise<Uint8Array>;
+    /** @description Returns a solidity verifier */
+    getSolidityVerifier(vk: Uint8Array, options?: UltraHonkBackendOptions): Promise<string>;
+    generateRecursiveProofArtifacts(_proof: Uint8Array, _numOfPublicInputs: number): Promise<{
+        proofAsFields: string[];
+        vkAsFields: string[];
+        vkHash: string;
+    }>;
+    destroy(): Promise<void>;
+}
+export declare class AztecClientBackend {
+    protected acirBuf: Uint8Array[];
+    protected options: BackendOptions;
+    protected api: Barretenberg;
+    constructor(acirBuf: Uint8Array[], options?: BackendOptions);
+    /** @ignore */
+    private instantiate;
+    prove(witnessBuf: Uint8Array[], vksBuf?: Uint8Array[]): Promise<[Uint8Array[], Uint8Array, Uint8Array]>;
+    verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean>;
+    gates(): Promise<number[]>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=backend.d.ts.map

package/dest/browser/barretenberg/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../../src/barretenberg/backend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAoC,MAAM,mBAAmB,CAAC;AAMhF,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,OAAO,EAAE,MAAM;CAG5B;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAsBF,qBAAa,wBAAwB;IAIjC,SAAS,CAAC,cAAc,EAAE,cAAc;IACxC,SAAS,CAAC,cAAc,EAAE,cAAc;IAJ1C,SAAS,CAAC,GAAG,EAAG,YAAY,CAAC;gBAGjB,cAAc,GAAE,cAA+B,EAC/C,cAAc,GAAE,cAAqC;IAEjE,cAAc;YACA,WAAW;IAUnB,WAAW,CACf,SAAS,EAAE,SAAS,GAAG;QAAE,eAAe,EAAE,UAAU,CAAA;KAAE,EACtD,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,OAAO,CAAC;IAenB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAMzB;AAED,qBAAa,gBAAgB;IAWzB,SAAS,CAAC,cAAc,EAAE,cAAc;IACxC,SAAS,CAAC,cAAc,EAAE,cAAc;IAN1C,SAAS,CAAC,GAAG,EAAG,YAAY,CAAC;IAC7B,SAAS,CAAC,wBAAwB,EAAE,UAAU,CAAC;gBAG7C,YAAY,EAAE,MAAM,EACV,cAAc,GAAE,cAA+B,EAC/C,cAAc,GAAE,cAAqC;IAIjE,cAAc;YACA,WAAW;IAUnB,aAAa,CAAC,iBAAiB,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,SAAS,CAAC;IAwBnG,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IAwBtF,kBAAkB,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,UAAU,CAAC;IAahF,+CAA+C;IACzC,mBAAmB,CAAC,EAAE,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC;IAUvF,+BAA+B,CAEnC,MAAM,EAAE,UAAU,EAElB,kBAAkB,EAAE,MAAM,GACzB,OAAO,CAAC;QAAE,aAAa,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAsCvE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAM/B;AAED,qBAAa,kBAAkB;IAS3B,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE;IAC/B,SAAS,CAAC,OAAO,EAAE,cAAc;IAJnC,SAAS,CAAC,GAAG,EAAG,YAAY,CAAC;gBAGjB,OAAO,EAAE,UAAU,EAAE,EACrB,OAAO,GAAE,cAA+B;IAGpD,cAAc;YACA,WAAW;IAQnB,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,MAAM,GAAE,UAAU,EAAO,GAAG,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;IA8D3G,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;IAS3D,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAgB1B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAM/B"}

package/dest/browser/barretenberg/backend.js

@@ -0,0 +1,301 @@
+import { Barretenberg } from './index.js';
+import { 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 {
+    constructor(message) {
+        super(message);
+    }
+}
+function getProofSettingsFromOptions(options) {
+    return {
+        ipaAccumulation: false,
+        oracleHashType: options?.keccak || options?.keccakZK
+            ? 'keccak'
+            : options?.starknet || options?.starknetZK
+                ? 'starknet'
+                : 'poseidon2',
+        // TODO no current way to target non-zk poseidon2 hash
+        disableZk: options?.keccak || options?.starknet ? true : false,
+        optimizedSolidityVerifier: false,
+    };
+}
+export class UltraHonkVerifierBackend {
+    constructor(backendOptions = { threads: 1 }, circuitOptions = { recursive: false }) {
+        this.backendOptions = backendOptions;
+        this.circuitOptions = circuitOptions;
+    }
+    /** @ignore */
+    async instantiate() {
+        if (!this.api) {
+            const api = await Barretenberg.new(this.backendOptions);
+            const honkRecursion = true;
+            await api.initSRSForCircuitSize(0);
+            this.api = api;
+        }
+    }
+    async verifyProof(proofData, options) {
+        await this.instantiate();
+        const proofFrs = [];
+        for (let i = 0; i < proofData.proof.length; i += 32) {
+            proofFrs.push(proofData.proof.slice(i, i + 32));
+        }
+        const { verified } = await this.api.circuitVerify({
+            verificationKey: proofData.verificationKey,
+            publicInputs: proofData.publicInputs.map(hexToUint8Array),
+            proof: proofFrs,
+            settings: getProofSettingsFromOptions(options),
+        });
+        return verified;
+    }
+    destroy() {
+        if (!this.api) {
+            return Promise.resolve();
+        }
+        return this.api.destroy();
+    }
+}
+export class UltraHonkBackend {
+    constructor(acirBytecode, backendOptions = { threads: 1 }, circuitOptions = { recursive: false }) {
+        this.backendOptions = backendOptions;
+        this.circuitOptions = circuitOptions;
+        this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
+    }
+    /** @ignore */
+    async instantiate() {
+        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, options) {
+        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.
+            },
+            settings: getProofSettingsFromOptions(options),
+        });
+        console.log(`Generated proof for circuit with ${publicInputs.length} public inputs and ${proof.length} fields.`);
+        // We return ProofData as a flat buffer and an array of strings to match the current ProofData class.
+        const flatProof = new Uint8Array(proof.length * 32);
+        proof.forEach((fr, i) => {
+            flatProof.set(fr, i * 32);
+        });
+        return { proof: flatProof, publicInputs: publicInputs.map(uint8ArrayToHex) };
+    }
+    async verifyProof(proofData, options) {
+        await this.instantiate();
+        const proofFrs = [];
+        for (let i = 0; i < proofData.proof.length; i += 32) {
+            proofFrs.push(proofData.proof.slice(i, i + 32));
+        }
+        // TODO reconsider API - computing the VK at this point is not optimal
+        const vkResult = await this.api.circuitComputeVk({
+            circuit: {
+                name: 'circuit',
+                bytecode: this.acirUncompressedBytecode,
+            },
+            settings: getProofSettingsFromOptions(options),
+        });
+        const { verified } = await this.api.circuitVerify({
+            verificationKey: vkResult.bytes,
+            publicInputs: proofData.publicInputs.map(hexToUint8Array),
+            proof: proofFrs,
+            settings: getProofSettingsFromOptions(options),
+        });
+        return verified;
+    }
+    async getVerificationKey(options) {
+        await this.instantiate();
+        const vkResult = await this.api.circuitComputeVk({
+            circuit: {
+                name: 'circuit',
+                bytecode: Buffer.from(this.acirUncompressedBytecode),
+            },
+            settings: getProofSettingsFromOptions(options),
+        });
+        return vkResult.bytes;
+    }
+    /** @description Returns a solidity verifier */
+    async getSolidityVerifier(vk, options) {
+        await this.instantiate();
+        const result = await this.api.circuitWriteSolidityVerifier({
+            verificationKey: vk,
+            settings: getProofSettingsFromOptions(options),
+        });
+        return result.solidityCode;
+    }
+    // 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, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _numOfPublicInputs) {
+        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 vkResult = await this.api.circuitComputeVk({
+            circuit: {
+                name: 'circuit',
+                bytecode: Buffer.from(this.acirUncompressedBytecode),
+            },
+            settings: getProofSettingsFromOptions({}),
+        });
+        // Convert VK bytes to field elements (32-byte chunks)
+        const vkAsFields = [];
+        for (let i = 0; i < vkResult.bytes.length; i += 32) {
+            const chunk = vkResult.bytes.slice(i, i + 32);
+            vkAsFields.push(uint8ArrayToHex(chunk));
+        }
+        return {
+            // TODO(https://github.com/noir-lang/noir/issues/5661)
+            proofAsFields: [],
+            vkAsFields,
+            // 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: uint8ArrayToHex(vkResult.hash),
+        };
+    }
+    async destroy() {
+        if (!this.api) {
+            return;
+        }
+        await this.api.destroy();
+    }
+}
+export class AztecClientBackend {
+    constructor(acirBuf, options = { threads: 1 }) {
+        this.acirBuf = acirBuf;
+        this.options = options;
+    }
+    /** @ignore */
+    async instantiate() {
+        if (!this.api) {
+            const api = await Barretenberg.new(this.options);
+            await api.initSRSChonk();
+            this.api = api;
+        }
+    }
+    async prove(witnessBuf, vksBuf = []) {
+        if (vksBuf.length !== 0 && this.acirBuf.length !== witnessBuf.length) {
+            throw new AztecClientBackendError('Witness and bytecodes must have the same stack depth!');
+        }
+        if (vksBuf.length !== 0 && vksBuf.length !== witnessBuf.length) {
+            // 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 });
+        // 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 functionName = `unknown_wasm_${i}`;
+            // Load the circuit
+            this.api.chonkLoad({
+                circuit: {
+                    name: functionName,
+                    bytecode: Buffer.from(bytecode),
+                    verificationKey: Buffer.from(vk),
+                },
+            });
+            // Accumulate with witness
+            this.api.chonkAccumulate({
+                witness: Buffer.from(witness),
+            });
+        }
+        // Generate the proof (and wait for all previous steps to finish)
+        const proveResult = await this.api.chonkProve({});
+        // The API currently expects a msgpack-encoded API.
+        const proof = new Encoder({ useRecords: false }).encode(fromChonkProof(proveResult.proof));
+        // Generate the VK
+        const vkResult = await this.api.chonkComputeIvcVk({
+            circuit: {
+                name: 'hiding',
+                bytecode: this.acirBuf[this.acirBuf.length - 1],
+            },
+        });
+        const proofFields = [
+            proveResult.proof.megaProof,
+            proveResult.proof.goblinProof.mergeProof,
+            proveResult.proof.goblinProof.eccvmProof.preIpaProof,
+            proveResult.proof.goblinProof.eccvmProof.ipaProof,
+            proveResult.proof.goblinProof.translatorProof,
+        ].flat();
+        // Note: Verification may not work correctly until we properly serialize the proof
+        if (!(await this.verify(proof, vkResult.bytes))) {
+            throw new AztecClientBackendError('Failed to verify the private (Chonk) transaction proof!');
+        }
+        return [proofFields, proof, vkResult.bytes];
+    }
+    async verify(proof, vk) {
+        await this.instantiate();
+        const result = await this.api.chonkVerify({
+            proof: toChonkProof(new Decoder({ useRecords: false }).decode(proof)),
+            vk: Buffer.from(vk),
+        });
+        return result.valid;
+    }
+    async gates() {
+        await this.instantiate();
+        const circuitSizes = [];
+        for (const buf of this.acirBuf) {
+            const gates = await this.api.chonkStats({
+                circuit: {
+                    name: 'circuit',
+                    bytecode: buf,
+                },
+                includeGatesPerOpcode: false,
+            });
+            circuitSizes.push(gates.circuitSize);
+        }
+        return circuitSizes;
+    }
+    async destroy() {
+        if (!this.api) {
+            return;
+        }
+        await this.api.destroy();
+    }
+}
+// Converts bytecode from a base64 string to a Uint8Array
+function acirToUint8Array(base64EncodedBytecode) {
+    const compressedByteCode = base64Decode(base64EncodedBytecode);
+    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.
+function base64Decode(input) {
+    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.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backend.js","sourceRoot":"","sources":["../../../src/barretenberg/backend.ts"],"names":[],"mappings":"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"}

package/dest/browser/barretenberg/index.d.ts

@@ -0,0 +1,67 @@
+import { AsyncApi } from '../cbind/generated/async.js';
+import { SyncApi } from '../cbind/generated/sync.js';
+import { IMsgpackBackendSync, IMsgpackBackendAsync } from '../bb_backends/interface.js';
+import { BackendOptions } from '../bb_backends/index.js';
+export { UltraHonkBackend, UltraHonkVerifierBackend, AztecClientBackend } 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 declare class Barretenberg extends AsyncApi {
+    private options;
+    constructor(backend: IMsgpackBackendAsync, options: BackendOptions);
+    /**
+     * 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. NativeSharedMemory (if bb binary available)
+     *   2. WasmWorker (in browser) or Wasm (in Node.js)
+     */
+    static new(options?: BackendOptions): Promise<Barretenberg>;
+    initSRSForCircuitSize(circuitSize: number): Promise<void>;
+    initSRSChonk(srsSize?: number): Promise<void>;
+    getDefaultSrsSize(): number;
+    acirGetCircuitSizes(bytecode: Uint8Array, recursive: boolean, honkRecursion: boolean): Promise<[number, number]>;
+    acirInitSRS(bytecode: Uint8Array, recursive: boolean, honkRecursion: boolean): Promise<void>;
+    destroy(): Promise<void>;
+    /**
+     * Initialize the singleton instance of Barretenberg.
+     * @param options Backend configuration options
+     */
+    static initSingleton(options?: BackendOptions): Promise<Barretenberg>;
+    static destroySingleton(): Promise<void>;
+    /**
+     * Get the singleton instance of Barretenberg.
+     * Must call initSingleton() first.
+     */
+    static getSingleton(): Barretenberg;
+}
+export declare class BarretenbergSync extends SyncApi {
+    constructor(backend: IMsgpackBackendSync);
+    /**
+     * 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 new(options?: BackendOptions): Promise<BarretenbergSync>;
+    /**
+     * Initialize the singleton instance.
+     * @param options Backend configuration options
+     */
+    static initSingleton(options?: BackendOptions): Promise<BarretenbergSync>;
+    static destroySingleton(): void;
+    static getSingleton(): BarretenbergSync;
+}
+//# sourceMappingURL=index.d.ts.map