@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.21caa21

package/dest/node/proof/index.js

@@ -0,0 +1,63 @@
+export const PAIRING_POINTS_SIZE = 16;
+// Fields are 32 bytes
+const fieldByteSize = 32;
+export function splitHonkProof(proofWithPublicInputs, numPublicInputs) {
+    const publicInputs = proofWithPublicInputs.slice(0, numPublicInputs * fieldByteSize);
+    const proof = proofWithPublicInputs.slice(numPublicInputs * fieldByteSize);
+    return {
+        proof,
+        publicInputs,
+    };
+}
+export function reconstructHonkProof(publicInputs, proof) {
+    const proofWithPublicInputs = Uint8Array.from([...publicInputs, ...proof]);
+    return proofWithPublicInputs;
+}
+export function deflattenFields(flattenedFields) {
+    const publicInputSize = 32;
+    const chunkedFlattenedPublicInputs = [];
+    for (let i = 0; i < flattenedFields.length; i += publicInputSize) {
+        const publicInput = flattenedFields.slice(i, i + publicInputSize);
+        chunkedFlattenedPublicInputs.push(publicInput);
+    }
+    return chunkedFlattenedPublicInputs.map(uint8ArrayToHex);
+}
+export function flattenFieldsAsArray(fields) {
+    const flattenedPublicInputs = fields.map(hexToUint8Array);
+    return flattenUint8Arrays(flattenedPublicInputs);
+}
+function flattenUint8Arrays(arrays) {
+    const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+export function uint8ArrayToHex(buffer) {
+    const hex = [];
+    buffer.forEach(function (i) {
+        let h = i.toString(16);
+        if (h.length % 2) {
+            h = '0' + h;
+        }
+        hex.push(h);
+    });
+    return '0x' + hex.join('');
+}
+export function hexToUint8Array(hex) {
+    const sanitizedHex = BigInt(hex).toString(16).padStart(64, '0');
+    const len = sanitizedHex.length / 2;
+    const u8 = new Uint8Array(len);
+    let i = 0;
+    let j = 0;
+    while (i < len) {
+        u8[i] = parseInt(sanitizedHex.slice(j, j + 2), 16);
+        i += 1;
+        j += 2;
+    }
+    return u8;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node/random/browser/index.d.ts

@@ -0,0 +1,2 @@
+export declare const randomBytes: (len: number) => Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9yYW5kb20vYnJvd3Nlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxlQUFPLE1BQU0sV0FBVywwQ0ErQnZCLENBQUMifQ==

package/dest/node/random/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/random/browser/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,0CA+BvB,CAAC"}

package/dest/node/random/browser/index.js

@@ -0,0 +1,31 @@
+export const randomBytes = (len) => {
+    const getWebCrypto = () => {
+        if (typeof window !== 'undefined' && window.crypto)
+            return window.crypto;
+        if (typeof globalThis !== 'undefined' && globalThis.crypto)
+            return globalThis.crypto;
+        return undefined;
+    };
+    const crypto = getWebCrypto();
+    if (!crypto) {
+        throw new Error('randomBytes UnsupportedEnvironment');
+    }
+    const buf = new Uint8Array(len);
+    // limit of Crypto.getRandomValues()
+    // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
+    const MAX_BYTES = 65536;
+    if (len > MAX_BYTES) {
+        // this is the max bytes crypto.getRandomValues
+        // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
+        for (let generated = 0; generated < len; generated += MAX_BYTES) {
+            // buffer.slice automatically checks if the end is past the end of
+            // the buffer so we don't have to here
+            crypto.getRandomValues(buf.subarray(generated, generated + MAX_BYTES));
+        }
+    }
+    else {
+        crypto.getRandomValues(buf);
+    }
+    return buf;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcmFuZG9tL2Jyb3dzZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLENBQUMsR0FBVyxFQUFFLEVBQUUsQ0FBQztJQUMxQyxNQUFNLFlBQVksR0FBRyxHQUFHLEVBQUUsQ0FBQztRQUN6QixJQUFJLE9BQU8sTUFBTSxLQUFLLFdBQVcsSUFBSSxNQUFNLENBQUMsTUFBTTtZQUFFLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUN6RSxJQUFJLE9BQU8sVUFBVSxLQUFLLFdBQVcsSUFBSSxVQUFVLENBQUMsTUFBTTtZQUFFLE9BQU8sVUFBVSxDQUFDLE1BQU0sQ0FBQztRQUNyRixPQUFPLFNBQVMsQ0FBQztJQUFBLENBQ2xCLENBQUM7SUFFRixNQUFNLE1BQU0sR0FBRyxZQUFZLEVBQUUsQ0FBQztJQUM5QixJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDWixNQUFNLElBQUksS0FBSyxDQUFDLG9DQUFvQyxDQUFDLENBQUM7SUFDeEQsQ0FBQztJQUVELE1BQU0sR0FBRyxHQUFHLElBQUksVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBRWhDLG9DQUFvQztJQUNwQywwRUFBMEU7SUFDMUUsTUFBTSxTQUFTLEdBQUcsS0FBSyxDQUFDO0lBRXhCLElBQUksR0FBRyxHQUFHLFNBQVMsRUFBRSxDQUFDO1FBQ3BCLCtDQUErQztRQUMvQyxvR0FBb0c7UUFDcEcsS0FBSyxJQUFJLFNBQVMsR0FBRyxDQUFDLEVBQUUsU0FBUyxHQUFHLEdBQUcsRUFBRSxTQUFTLElBQUksU0FBUyxFQUFFLENBQUM7WUFDaEUsa0VBQWtFO1lBQ2xFLHNDQUFzQztZQUN0QyxNQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsU0FBUyxFQUFFLFNBQVMsR0FBRyxTQUFTLENBQUMsQ0FBQyxDQUFDO1FBQ3pFLENBQUM7SUFDSCxDQUFDO1NBQU0sQ0FBQztRQUNOLE1BQU0sQ0FBQyxlQUFlLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDOUIsQ0FBQztJQUVELE9BQU8sR0FBRyxDQUFDO0FBQUEsQ0FDWixDQUFDIn0=

package/dest/node/random/index.d.ts

@@ -0,0 +1,2 @@
+export * from './node/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yYW5kb20vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQyJ9

package/dest/node/random/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/random/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dest/{random → node/random}/index.js

@@ -1,2 +1,2 @@
 export * from './node/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmFuZG9tL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmFuZG9tL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUMifQ==

package/dest/node/random/node/index.d.ts

@@ -0,0 +1,2 @@
+export declare function randomBytes(len: number): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9yYW5kb20vbm9kZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSx3QkFBZ0IsV0FBVyxDQUFDLEdBQUcsRUFBRSxNQUFNLDJCQUV0QyJ9

package/dest/node/random/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/random/node/index.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,2BAEtC"}

package/dest/node/random/node/index.js

@@ -0,0 +1,5 @@
+import { randomBytes as cryptoRandomBytes } from 'crypto';
+export function randomBytes(len) {
+    return new Uint8Array(cryptoRandomBytes(len));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcmFuZG9tL25vZGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsSUFBSSxpQkFBaUIsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUUxRCxNQUFNLFVBQVUsV0FBVyxDQUFDLEdBQVcsRUFBRTtJQUN2QyxPQUFPLElBQUksVUFBVSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7QUFBQSxDQUMvQyJ9

package/dest/node/retry/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Generates a backoff sequence for retrying operations with an increasing delay.
+ * The backoff sequence follows this pattern: 1, 1, 1, 2, 4, 8, 16, 32, 64, ...
+ * This generator can be used in combination with the `retry` function to perform
+ * retries with exponential backoff and capped at 64 seconds between attempts.
+ *
+ * @returns A generator that yields the next backoff value in seconds as an integer.
+ */
+export declare function backoffGenerator(): Generator<number, void, unknown>;
+/**
+ * Generates a backoff sequence based on the array of retry intervals to use with the `retry` function.
+ * @param retries - Intervals to retry (in seconds).
+ * @returns A generator sequence.
+ */
+export declare function makeBackoff(retries: number[]): Generator<number, void, unknown>;
+/**
+ * Retry a given asynchronous function with a specific backoff strategy, until it succeeds or backoff generator ends.
+ * It logs the error and retry interval in case an error is caught. The function can be named for better log output.
+ *
+ * @param fn - The asynchronous function to be retried.
+ * @param backoff - The optional backoff generator providing the intervals in seconds between retries. Defaults to a predefined series.
+ * @returns A Promise that resolves with the successful result of the provided function, or rejects if backoff generator ends.
+ * @throws If `NoRetryError` is thrown by the `fn`, it is rethrown.
+ */
+export declare function retry<Result>(fn: () => Promise<Result>, backoff?: Generator<number, void, unknown>): Promise<Result>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZXRyeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7OztHQU9HO0FBQ0gsd0JBQWlCLGdCQUFnQixxQ0FNaEM7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQWlCLFdBQVcsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLG9DQUk3QztBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLEtBQUssQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLE1BQU0sT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLE9BQU8sbUNBQXFCLG1CQWExRiJ9

package/dest/node/retry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/retry/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAiB,gBAAgB,qCAMhC;AAED;;;;GAIG;AACH,wBAAiB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,oCAI7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,mCAAqB,mBAa1F"}

package/dest/node/retry/index.js

@@ -0,0 +1,50 @@
+/**
+ * Generates a backoff sequence for retrying operations with an increasing delay.
+ * The backoff sequence follows this pattern: 1, 1, 1, 2, 4, 8, 16, 32, 64, ...
+ * This generator can be used in combination with the `retry` function to perform
+ * retries with exponential backoff and capped at 64 seconds between attempts.
+ *
+ * @returns A generator that yields the next backoff value in seconds as an integer.
+ */
+export function* backoffGenerator() {
+    const v = [1, 1, 1, 2, 4, 8, 16, 32, 64];
+    let i = 0;
+    while (true) {
+        yield v[Math.min(i++, v.length - 1)];
+    }
+}
+/**
+ * Generates a backoff sequence based on the array of retry intervals to use with the `retry` function.
+ * @param retries - Intervals to retry (in seconds).
+ * @returns A generator sequence.
+ */
+export function* makeBackoff(retries) {
+    for (const retry of retries) {
+        yield retry;
+    }
+}
+/**
+ * Retry a given asynchronous function with a specific backoff strategy, until it succeeds or backoff generator ends.
+ * It logs the error and retry interval in case an error is caught. The function can be named for better log output.
+ *
+ * @param fn - The asynchronous function to be retried.
+ * @param backoff - The optional backoff generator providing the intervals in seconds between retries. Defaults to a predefined series.
+ * @returns A Promise that resolves with the successful result of the provided function, or rejects if backoff generator ends.
+ * @throws If `NoRetryError` is thrown by the `fn`, it is rethrown.
+ */
+export async function retry(fn, backoff = backoffGenerator()) {
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            const s = backoff.next().value;
+            if (s === undefined) {
+                throw err;
+            }
+            await new Promise(resolve => setTimeout(resolve, s * 1000));
+            continue;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmV0cnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUNILE1BQU0sU0FBUyxDQUFDLENBQUMsZ0JBQWdCLEdBQUc7SUFDbEMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ3pDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNWLE9BQU8sSUFBSSxFQUFFLENBQUM7UUFDWixNQUFNLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN2QyxDQUFDO0FBQUEsQ0FDRjtBQUVEOzs7O0dBSUc7QUFDSCxNQUFNLFNBQVMsQ0FBQyxDQUFDLFdBQVcsQ0FBQyxPQUFpQixFQUFFO0lBQzlDLEtBQUssTUFBTSxLQUFLLElBQUksT0FBTyxFQUFFLENBQUM7UUFDNUIsTUFBTSxLQUFLLENBQUM7SUFDZCxDQUFDO0FBQUEsQ0FDRjtBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxLQUFLLENBQVMsRUFBeUIsRUFBRSxPQUFPLEdBQUcsZ0JBQWdCLEVBQUUsRUFBRTtJQUMzRixPQUFPLElBQUksRUFBRSxDQUFDO1FBQ1osSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3BCLENBQUM7UUFBQyxPQUFPLEdBQVEsRUFBRSxDQUFDO1lBQ2xCLE1BQU0sQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxLQUFLLENBQUM7WUFDL0IsSUFBSSxDQUFDLEtBQUssU0FBUyxFQUFFLENBQUM7Z0JBQ3BCLE1BQU0sR0FBRyxDQUFDO1lBQ1osQ0FBQztZQUNELE1BQU0sSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQzVELFNBQVM7UUFDWCxDQUFDO0lBQ0gsQ0FBQztBQUFBLENBQ0YifQ==

package/dest/node-cjs/async_map/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Much the same as Array.map, only it takes an async fn as an element handler, and ensures that each element handler
+ * is executed sequentially.
+ * The pattern of `await Promise.all(arr.map(async e => { ... }))` only works if one's happy with each element handler
+ * being run concurrently.
+ * If one required sequential execution of async fn's, the only alternative was regular loops with mutable state vars.
+ * The equivalent with asyncMap: `await asyncMap(arr, async e => { ... })`.
+ */
+export declare function asyncMap<T, U>(arr: T[], fn: (e: T, i: number) => Promise<U>): Promise<U[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hc3luY19tYXAvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQixRQUFRLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FNaEcifQ==

package/dest/node-cjs/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/node-cjs/async_map/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncMap = asyncMap;
+/**
+ * Much the same as Array.map, only it takes an async fn as an element handler, and ensures that each element handler
+ * is executed sequentially.
+ * The pattern of `await Promise.all(arr.map(async e => { ... }))` only works if one's happy with each element handler
+ * being run concurrently.
+ * If one required sequential execution of async fn's, the only alternative was regular loops with mutable state vars.
+ * The equivalent with asyncMap: `await asyncMap(arr, async e => { ... })`.
+ */
+async function asyncMap(arr, fn) {
+    const results = [];
+    for (let i = 0; i < arr.length; ++i) {
+        results.push(await fn(arr[i], i));
+    }
+    return results;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXN5bmNfbWFwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7O0dBT0c7QUFDSSxLQUFLLG1CQUF5QixHQUFRLEVBQUUsRUFBbUMsRUFBZ0I7SUFDaEcsTUFBTSxPQUFPLEdBQVEsRUFBRSxDQUFDO0lBQ3hCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUM7UUFDcEMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBQ0QsT0FBTyxPQUFPLENBQUM7QUFBQSxDQUNoQiJ9

package/dest/node-cjs/barretenberg/backend.d.ts

@@ -0,0 +1,61 @@
+import { Barretenberg } 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 {
+    private api;
+    constructor(api: Barretenberg);
+    verifyProof(proofData: ProofData & {
+        verificationKey: Uint8Array;
+    }, options?: UltraHonkBackendOptions): Promise<boolean>;
+}
+export declare class UltraHonkBackend {
+    private api;
+    private acirUncompressedBytecode;
+    constructor(acirBytecode: string, api: Barretenberg);
+    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;
+    }>;
+}
+export declare class AztecClientBackend {
+    private acirBuf;
+    private api;
+    constructor(acirBuf: Uint8Array[], api: Barretenberg);
+    prove(witnessBuf: Uint8Array[], vksBuf?: Uint8Array[]): Promise<[Uint8Array[], Uint8Array, Uint8Array]>;
+    verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean>;
+    gates(): Promise<number[]>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node-cjs/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,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAoC,MAAM,mBAAmB,CAAC;AAKhF,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;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;IACvB,OAAO,CAAC,GAAG;IAAvB,YAAoB,GAAG,EAAE,YAAY,EAAI;IAEnC,WAAW,CACf,SAAS,EAAE,SAAS,GAAG;QAAE,eAAe,EAAE,UAAU,CAAA;KAAE,EACtD,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,OAAO,CAAC,CAYlB;CACF;AAED,qBAAa,gBAAgB;IAUzB,OAAO,CAAC,GAAG;IAJb,OAAO,CAAC,wBAAwB,CAAa;IAE7C,YACE,YAAY,EAAE,MAAM,EACZ,GAAG,EAAE,YAAY,EAG1B;IAEK,aAAa,CAAC,iBAAiB,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,SAAS,CAAC,CAoBxG;IAEK,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC,CAoB3F;IAEK,kBAAkB,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,UAAU,CAAC,CAS/E;IAED,+CAA+C;IACzC,mBAAmB,CAAC,EAAE,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC,CAM5F;IAGK,+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,CAmC5E;CACF;AAED,qBAAa,kBAAkB;IAO3B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,GAAG;IAFb,YACU,OAAO,EAAE,UAAU,EAAE,EACrB,GAAG,EAAE,YAAY,EACvB;IAEE,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,MAAM,GAAE,UAAU,EAAO,GAAG,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CA2DhH;IAEK,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAMhE;IAEK,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAa/B;CACF"}

package/dest/node-cjs/barretenberg/backend.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AztecClientBackend = exports.UltraHonkBackend = exports.UltraHonkVerifierBackend = exports.AztecClientBackendError = void 0;
+const index_js_1 = require("../proof/index.js");
+const api_types_js_1 = require("../cbind/generated/api_types.js");
+const pako_1 = require("pako");
+const msgpackr_1 = require("msgpackr");
+class AztecClientBackendError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.AztecClientBackendError = AztecClientBackendError;
+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,
+    };
+}
+class UltraHonkVerifierBackend {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    async verifyProof(proofData, options) {
+        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(index_js_1.hexToUint8Array),
+            proof: proofFrs,
+            settings: getProofSettingsFromOptions(options),
+        });
+        return verified;
+    }
+}
+exports.UltraHonkVerifierBackend = UltraHonkVerifierBackend;
+class UltraHonkBackend {
+    api;
+    // These type assertions are used so that we don't
+    // have to initialize `api` in the constructor.
+    // These are initialized asynchronously in the `init` function,
+    // constructors cannot be asynchronous which is why we do this.
+    acirUncompressedBytecode;
+    constructor(acirBytecode, api) {
+        this.api = api;
+        this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
+    }
+    async generateProof(compressedWitness, options) {
+        const witness = (0, pako_1.ungzip)(compressedWitness);
+        const { proof, publicInputs } = await this.api.circuitProve({
+            witness,
+            circuit: {
+                name: 'circuit',
+                bytecode: this.acirUncompressedBytecode,
+                verificationKey: new Uint8Array(0), // 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(index_js_1.uint8ArrayToHex) };
+    }
+    async verifyProof(proofData, options) {
+        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(index_js_1.hexToUint8Array),
+            proof: proofFrs,
+            settings: getProofSettingsFromOptions(options),
+        });
+        return verified;
+    }
+    async getVerificationKey(options) {
+        const vkResult = await this.api.circuitComputeVk({
+            circuit: {
+                name: 'circuit',
+                bytecode: this.acirUncompressedBytecode,
+            },
+            settings: getProofSettingsFromOptions(options),
+        });
+        return vkResult.bytes;
+    }
+    /** @description Returns a solidity verifier */
+    async getSolidityVerifier(vk, options) {
+        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) {
+        // 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: 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((0, index_js_1.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: (0, index_js_1.uint8ArrayToHex)(vkResult.hash),
+        };
+    }
+}
+exports.UltraHonkBackend = UltraHonkBackend;
+class AztecClientBackend {
+    acirBuf;
+    api;
+    // These type assertions are used so that we don't
+    // have to initialize `api` in the constructor.
+    // These are initialized asynchronously in the `init` function,
+    // constructors cannot be asynchronous which is why we do this.
+    constructor(acirBuf, api) {
+        this.acirBuf = acirBuf;
+        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!');
+        }
+        // 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] || 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: bytecode,
+                    verificationKey: vk,
+                },
+            });
+            // Accumulate with witness
+            this.api.chonkAccumulate({
+                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 msgpackr_1.Encoder({ useRecords: false }).encode((0, api_types_js_1.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) {
+        const result = await this.api.chonkVerify({
+            proof: (0, api_types_js_1.toChonkProof)(new msgpackr_1.Decoder({ useRecords: false }).decode(proof)),
+            vk,
+        });
+        return result.valid;
+    }
+    async gates() {
+        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;
+    }
+}
+exports.AztecClientBackend = AztecClientBackend;
+// Converts bytecode from a base64 string to a Uint8Array
+function acirToUint8Array(base64EncodedBytecode) {
+    const compressedByteCode = base64Decode(base64EncodedBytecode);
+    return (0, pako_1.ungzip)(compressedByteCode);
+}
+// Base64 decode using atob (works in both browser and Node.js 18+)
+function base64Decode(input) {
+    if (typeof atob === 'function') {
+        return Uint8Array.from(atob(input), c => c.charCodeAt(0));
+    }
+    else {
+        throw new Error('atob is not available. Node.js 18+ or browser required.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backend.js","sourceRoot":"","sources":["../../../src/barretenberg/backend.ts"],"names":[],"mappings":"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"}

package/dest/node-cjs/barretenberg/blake2s.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxha2Uycy50ZXN0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmFycmV0ZW5iZXJnL2JsYWtlMnMudGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/node-cjs/barretenberg/blake2s.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blake2s.test.d.ts","sourceRoot":"","sources":["../../../src/barretenberg/blake2s.test.ts"],"names":[],"mappings":""}