@aztec/foundation 0.1.0-alpha10

package/dest/aztec-address/index.d.ts

@@ -0,0 +1,96 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../fields/index.js';
+import { BufferReader } from '../serialize/buffer_reader.js';
+/**
+ * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
+ * compare addresses. The maximum value of an address is determined by the field modulus and all instances of AztecAddress
+ * should have a value less than or equal to this max value. This class also provides helper functions to convert
+ * addresses from strings, buffers, and other formats.
+ */
+export declare class AztecAddress {
+    /**
+     * The buffer field.
+     */
+    readonly buffer: Buffer;
+    static SIZE_IN_BYTES: number;
+    static ZERO: AztecAddress;
+    static MODULUS: bigint;
+    static MAX_VALUE: bigint;
+    constructor(
+    /**
+     * The buffer field.
+     */
+    buffer: Buffer);
+    /**
+     * Generates a random AztecAddress instance, using the Fr field (a finite field) to create a random value
+     * within a valid range and then converting it into a Buffer of a fixed size in bytes.
+     *
+     * @returns A new AztecAddress instance with a random value.
+     */
+    static random(): AztecAddress;
+    /**
+     * Creates an AztecAddress instance from a given buffer or BufferReader.
+     * If the input is a Buffer, it wraps it in a BufferReader before processing.
+     * Throws an error if the input length is not equal to the expected size.
+     *
+     * @param buffer - The input buffer or BufferReader containing the address data.
+     * @returns - A new AztecAddress instance with the extracted address data.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): AztecAddress;
+    /**
+     * Create an AztecAddress instance from a hex-encoded string.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 64 hex characters.
+     * Throws an error if the input length is invalid or address value is out of range.
+     *
+     * @param address - The hex-encoded string representing the Aztec address.
+     * @returns An AztecAddress instance.
+     */
+    static fromString(address: string): AztecAddress;
+    /**
+     * Converts the AztecAddress instance into a Buffer.
+     * This method should be used when encoding the address for storage, transmission or serialization purposes.
+     *
+     * @returns A Buffer representation of the AztecAddress instance.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Convert the AztecAddress to a hexadecimal string representation, with a "0x" prefix.
+     * The resulting string will have a length of 66 characters (including the prefix).
+     *
+     * @returns A hexadecimal string representation of the AztecAddress.
+     */
+    toString(): `0x${string}`;
+    /**
+     * Returns a shortened string representation of the AztecAddress, displaying only the first 10 characters and last 4 characters.
+     * This is useful for human-readable displays where the full address is not necessary.
+     *
+     * @returns A shortened string representation of the address.
+     */
+    toShortString(): string;
+    /**
+     * Returns this address as a field element.
+     * @returns A field element with the same value as the address.
+     */
+    toField(): Fr;
+    /**
+     * Determines if this AztecAddress instance is equal to the given AztecAddress instance.
+     * Equality is based on the content of their respective buffers.
+     *
+     * @param rhs - The AztecAddress instance to compare against.
+     * @returns True if the buffers of both instances are equal, false otherwise.
+     */
+    equals(rhs: AztecAddress): boolean;
+    /**
+     * Checks if the AztecAddress is zero.
+     *
+     * @returns Returns true if the AztecAddress is equal to the zero address, otherwise returns false.
+     */
+    isZero(): boolean;
+    /**
+     * Friendly representation for debugging purposes.
+     *
+     * @returns A hex string representing the address.
+     */
+    toFriendlyJSON(): `0x${string}`;
+}
+//# sourceMappingURL=index.d.ts.map

package/dest/aztec-address/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aztec-address/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D;;;;;GAKG;AACH,qBAAa,YAAY;IAOrB;;OAEG;aACa,MAAM,EAAE,MAAM;IAThC,MAAM,CAAC,aAAa,SAAM;IAC1B,MAAM,CAAC,IAAI,eAA8D;IACzE,MAAM,CAAC,OAAO,SAAuE;IACrF,MAAM,CAAC,SAAS,SAA6B;;IAG3C;;OAEG;IACa,MAAM,EAAE,MAAM;IAQhC;;;;;OAKG;IACH,MAAM,CAAC,MAAM;IAIb;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM;IAQjC;;;;;OAKG;IACH,QAAQ;IAIR;;;;;OAKG;IACH,QAAQ,IAAI,KAAK,MAAM,EAAE;IAIzB;;;;;OAKG;IACH,aAAa;IAKb;;;OAGG;IACH,OAAO;IAIP;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,EAAE,YAAY;IAIxB;;;;OAIG;IACH,MAAM;IAIN;;;;OAIG;IACH,cAAc;CAGf"}

package/dest/aztec-address/index.js

@@ -0,0 +1,124 @@
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { Fr } from '../fields/index.js';
+import { BufferReader } from '../serialize/buffer_reader.js';
+/**
+ * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
+ * compare addresses. The maximum value of an address is determined by the field modulus and all instances of AztecAddress
+ * should have a value less than or equal to this max value. This class also provides helper functions to convert
+ * addresses from strings, buffers, and other formats.
+ */
+export class AztecAddress {
+    constructor(
+    /**
+     * The buffer field.
+     */
+    buffer) {
+        this.buffer = buffer;
+        const value = toBigIntBE(buffer);
+        if (value > AztecAddress.MAX_VALUE) {
+            throw new Error(`AztecAddress out of range ${value}.`);
+        }
+    }
+    /**
+     * Generates a random AztecAddress instance, using the Fr field (a finite field) to create a random value
+     * within a valid range and then converting it into a Buffer of a fixed size in bytes.
+     *
+     * @returns A new AztecAddress instance with a random value.
+     */
+    static random() {
+        return new AztecAddress(toBufferBE(Fr.random().value, AztecAddress.SIZE_IN_BYTES));
+    }
+    /**
+     * Creates an AztecAddress instance from a given buffer or BufferReader.
+     * If the input is a Buffer, it wraps it in a BufferReader before processing.
+     * Throws an error if the input length is not equal to the expected size.
+     *
+     * @param buffer - The input buffer or BufferReader containing the address data.
+     * @returns - A new AztecAddress instance with the extracted address data.
+     */
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new this(reader.readBytes(this.SIZE_IN_BYTES));
+    }
+    /**
+     * Create an AztecAddress instance from a hex-encoded string.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 64 hex characters.
+     * Throws an error if the input length is invalid or address value is out of range.
+     *
+     * @param address - The hex-encoded string representing the Aztec address.
+     * @returns An AztecAddress instance.
+     */
+    static fromString(address) {
+        const buf = Buffer.from(address.replace(/^0x/i, ''), 'hex');
+        if (buf.length !== AztecAddress.SIZE_IN_BYTES) {
+            throw new Error(`Invalid length ${buf.length}.`);
+        }
+        return new AztecAddress(buf);
+    }
+    /**
+     * Converts the AztecAddress instance into a Buffer.
+     * This method should be used when encoding the address for storage, transmission or serialization purposes.
+     *
+     * @returns A Buffer representation of the AztecAddress instance.
+     */
+    toBuffer() {
+        return this.buffer;
+    }
+    /**
+     * Convert the AztecAddress to a hexadecimal string representation, with a "0x" prefix.
+     * The resulting string will have a length of 66 characters (including the prefix).
+     *
+     * @returns A hexadecimal string representation of the AztecAddress.
+     */
+    toString() {
+        return `0x${this.buffer.toString('hex')}`;
+    }
+    /**
+     * Returns a shortened string representation of the AztecAddress, displaying only the first 10 characters and last 4 characters.
+     * This is useful for human-readable displays where the full address is not necessary.
+     *
+     * @returns A shortened string representation of the address.
+     */
+    toShortString() {
+        const str = this.toString();
+        return `${str.slice(0, 10)}...${str.slice(-4)}`;
+    }
+    /**
+     * Returns this address as a field element.
+     * @returns A field element with the same value as the address.
+     */
+    toField() {
+        return Fr.fromBuffer(this.toBuffer());
+    }
+    /**
+     * Determines if this AztecAddress instance is equal to the given AztecAddress instance.
+     * Equality is based on the content of their respective buffers.
+     *
+     * @param rhs - The AztecAddress instance to compare against.
+     * @returns True if the buffers of both instances are equal, false otherwise.
+     */
+    equals(rhs) {
+        return this.buffer.equals(rhs.buffer);
+    }
+    /**
+     * Checks if the AztecAddress is zero.
+     *
+     * @returns Returns true if the AztecAddress is equal to the zero address, otherwise returns false.
+     */
+    isZero() {
+        return this.equals(AztecAddress.ZERO);
+    }
+    /**
+     * Friendly representation for debugging purposes.
+     *
+     * @returns A hex string representing the address.
+     */
+    toFriendlyJSON() {
+        return this.toString();
+    }
+}
+AztecAddress.SIZE_IN_BYTES = 32;
+AztecAddress.ZERO = new AztecAddress(Buffer.alloc(AztecAddress.SIZE_IN_BYTES));
+AztecAddress.MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
+AztecAddress.MAX_VALUE = AztecAddress.MODULUS - 1n;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/bigint-buffer/bigint-buffer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bigint-buffer.test.d.ts.map

package/dest/bigint-buffer/bigint-buffer.test.d.ts.map

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

package/dest/bigint-buffer/bigint-buffer.test.js

@@ -0,0 +1,18 @@
+import { toHex } from './index.js';
+describe('bigint-buffer', () => {
+    describe('toHex', () => {
+        it('does not pad even length', () => {
+            expect(toHex(16n)).toEqual('0x10');
+        });
+        it('pads odd length hex to even length', () => {
+            expect(toHex(10n)).toEqual('0x0a');
+        });
+        it('pads zero to even length', () => {
+            expect(toHex(0n)).toEqual('0x00');
+        });
+        it('pads zero to 32 bytes', () => {
+            expect(toHex(0n, true)).toEqual('0x0000000000000000000000000000000000000000000000000000000000000000');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmlnaW50LWJ1ZmZlci50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2JpZ2ludC1idWZmZXIvYmlnaW50LWJ1ZmZlci50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFbkMsUUFBUSxDQUFDLGVBQWUsRUFBRSxHQUFHLEVBQUU7SUFDN0IsUUFBUSxDQUFDLE9BQU8sRUFBRSxHQUFHLEVBQUU7UUFDckIsRUFBRSxDQUFDLDBCQUEwQixFQUFFLEdBQUcsRUFBRTtZQUNsQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3JDLENBQUMsQ0FBQyxDQUFDO1FBRUgsRUFBRSxDQUFDLG9DQUFvQyxFQUFFLEdBQUcsRUFBRTtZQUM1QyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3JDLENBQUMsQ0FBQyxDQUFDO1FBRUgsRUFBRSxDQUFDLDBCQUEwQixFQUFFLEdBQUcsRUFBRTtZQUNsQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3BDLENBQUMsQ0FBQyxDQUFDO1FBRUgsRUFBRSxDQUFDLHVCQUF1QixFQUFFLEdBQUcsRUFBRTtZQUMvQixNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxvRUFBb0UsQ0FBQyxDQUFDO1FBQ3hHLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMsQ0FBQyJ9

package/dest/bigint-buffer/index.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Convert a little-endian buffer into a BigInt.
+ * @param buf - The little-endian buffer to convert.
+ * @returns A BigInt with the little-endian representation of buf.
+ */
+export declare function toBigIntLE(buf: Buffer): bigint;
+/**
+ * Convert a big-endian buffer into a BigInt.
+ * @param buf - The big-endian buffer to convert.
+ * @returns A BigInt with the big-endian representation of buf.
+ */
+export declare function toBigIntBE(buf: Buffer): bigint;
+/**
+ * Convert a BigInt to a little-endian buffer.
+ * @param num - The BigInt to convert.
+ * @param width - The number of bytes that the resulting buffer should be.
+ * @returns A little-endian buffer representation of num.
+ */
+export declare function toBufferLE(num: bigint, width: number): Buffer;
+/**
+ * Convert a BigInt to a big-endian buffer.
+ * @param num - The BigInt to convert.
+ * @param width - The number of bytes that the resulting buffer should be.
+ * @returns A big-endian buffer representation of num.
+ */
+export declare function toBufferBE(num: bigint, width: number): Buffer;
+/**
+ * Converts a BigInt to its hex representation.
+ * @param num - The BigInt to convert.
+ * @param padTo32 - Whether to pad the resulting string to 32 bytes.
+ * @returns An even-length 0x-prefixed string.
+ */
+export declare function toHex(num: bigint, padTo32?: boolean): `0x${string}`;
+//# sourceMappingURL=index.d.ts.map

package/dest/bigint-buffer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bigint-buffer/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM9C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,KAAK,MAAM,EAAE,CAKjE"}

package/dest/bigint-buffer/index.js

@@ -0,0 +1,68 @@
+/**
+ * Convert a little-endian buffer into a BigInt.
+ * @param buf - The little-endian buffer to convert.
+ * @returns A BigInt with the little-endian representation of buf.
+ */
+export function toBigIntLE(buf) {
+    const reversed = Buffer.from(buf);
+    reversed.reverse();
+    const hex = reversed.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
+    }
+    return BigInt(`0x${hex}`);
+}
+/**
+ * Convert a big-endian buffer into a BigInt.
+ * @param buf - The big-endian buffer to convert.
+ * @returns A BigInt with the big-endian representation of buf.
+ */
+export function toBigIntBE(buf) {
+    const hex = buf.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
+    }
+    return BigInt(`0x${hex}`);
+}
+/**
+ * Convert a BigInt to a little-endian buffer.
+ * @param num - The BigInt to convert.
+ * @param width - The number of bytes that the resulting buffer should be.
+ * @returns A little-endian buffer representation of num.
+ */
+export function toBufferLE(num, width) {
+    if (num < BigInt(0))
+        throw new Error(`Cannot convert negative bigint ${num.toString()} to buffer with toBufferLE.`);
+    const hex = num.toString(16);
+    const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    buffer.reverse();
+    return buffer;
+}
+/**
+ * Convert a BigInt to a big-endian buffer.
+ * @param num - The BigInt to convert.
+ * @param width - The number of bytes that the resulting buffer should be.
+ * @returns A big-endian buffer representation of num.
+ */
+export function toBufferBE(num, width) {
+    if (num < BigInt(0))
+        throw new Error(`Cannot convert negative bigint ${num.toString()} to buffer with toBufferBE.`);
+    const hex = num.toString(16);
+    const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    if (buffer.length > width)
+        throw new Error(`Number ${num.toString(16)} does not fit in ${width}`);
+    return buffer;
+}
+/**
+ * Converts a BigInt to its hex representation.
+ * @param num - The BigInt to convert.
+ * @param padTo32 - Whether to pad the resulting string to 32 bytes.
+ * @returns An even-length 0x-prefixed string.
+ */
+export function toHex(num, padTo32 = false) {
+    const str = num.toString(16);
+    const targetLen = str.length % 2 === 0 ? str.length : str.length + 1;
+    const paddedStr = str.padStart(padTo32 ? 64 : targetLen, '0');
+    return `0x${paddedStr}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/collection/array.d.ts

@@ -0,0 +1,30 @@
+import { Tuple } from '../serialize/types.js';
+/**
+ * Pads an array to the target length by appending an element to its end. Throws if target length exceeds the input array length. Does not modify the input array.
+ * @param arr - Array with elements to pad.
+ * @param elem - Element to use for padding.
+ * @param length - Target length.
+ * @returns A new padded array.
+ */
+export declare function padArrayEnd<T, N extends number>(arr: T[], elem: T, length: N): Tuple<T, N>;
+/**
+ * Pads an array to the target length by prepending elements at the beginning. Throws if target length exceeds the input array length. Does not modify the input array.
+ * @param arr - Array with elements to pad.
+ * @param elem - Element to use for padding.
+ * @param length - Target length.
+ * @returns A new padded array.
+ */
+export declare function padArrayStart<T, N extends number>(arr: T[], elem: T, length: N): Tuple<T, N>;
+/**
+ * Returns if an array is composed of empty items.
+ * @param arr - Array to check.
+ * @returns True if every item in the array isEmpty.
+ */
+export declare function isArrayEmpty<T>(arr: T[], isEmpty: (item: T) => boolean): boolean;
+/**
+ * Returns the number of non-empty items in an array.
+ * @param arr - Array to check.
+ * @returns Number of non-empty items in an array.
+ */
+export declare function arrayNonEmptyLength<T>(arr: T[], isEmpty: (item: T) => boolean): number;
+//# sourceMappingURL=array.d.ts.map

package/dest/collection/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/collection/array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAI1F;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAI5F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAKhF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAEtF"}

package/dest/collection/array.js

@@ -0,0 +1,47 @@
+/**
+ * Pads an array to the target length by appending an element to its end. Throws if target length exceeds the input array length. Does not modify the input array.
+ * @param arr - Array with elements to pad.
+ * @param elem - Element to use for padding.
+ * @param length - Target length.
+ * @returns A new padded array.
+ */
+export function padArrayEnd(arr, elem, length) {
+    if (arr.length > length)
+        throw new Error(`Array size exceeds target length`);
+    // Since typescript cannot always deduce that something is a tuple, we cast
+    return [...arr, ...Array(length - arr.length).fill(elem)];
+}
+/**
+ * Pads an array to the target length by prepending elements at the beginning. Throws if target length exceeds the input array length. Does not modify the input array.
+ * @param arr - Array with elements to pad.
+ * @param elem - Element to use for padding.
+ * @param length - Target length.
+ * @returns A new padded array.
+ */
+export function padArrayStart(arr, elem, length) {
+    if (arr.length > length)
+        throw new Error(`Array size exceeds target length`);
+    // Since typescript cannot always deduce that something is a tuple, we cast
+    return [...Array(length - arr.length).fill(elem), ...arr];
+}
+/**
+ * Returns if an array is composed of empty items.
+ * @param arr - Array to check.
+ * @returns True if every item in the array isEmpty.
+ */
+export function isArrayEmpty(arr, isEmpty) {
+    for (const item of arr) {
+        if (!isEmpty(item))
+            return false;
+    }
+    return true;
+}
+/**
+ * Returns the number of non-empty items in an array.
+ * @param arr - Array to check.
+ * @returns Number of non-empty items in an array.
+ */
+export function arrayNonEmptyLength(arr, isEmpty) {
+    return arr.reduce((sum, item) => (isEmpty(item) ? sum : sum + 1), 0);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29sbGVjdGlvbi9hcnJheS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsV0FBVyxDQUFzQixHQUFRLEVBQUUsSUFBTyxFQUFFLE1BQVM7SUFDM0UsSUFBSSxHQUFHLENBQUMsTUFBTSxHQUFHLE1BQU07UUFBRSxNQUFNLElBQUksS0FBSyxDQUFDLGtDQUFrQyxDQUFDLENBQUM7SUFDN0UsMkVBQTJFO0lBQzNFLE9BQU8sQ0FBQyxHQUFHLEdBQUcsRUFBRSxHQUFHLEtBQUssQ0FBQyxNQUFNLEdBQUcsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBZ0IsQ0FBQztBQUMzRSxDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FBc0IsR0FBUSxFQUFFLElBQU8sRUFBRSxNQUFTO0lBQzdFLElBQUksR0FBRyxDQUFDLE1BQU0sR0FBRyxNQUFNO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQyxDQUFDO0lBQzdFLDJFQUEyRTtJQUMzRSxPQUFPLENBQUMsR0FBRyxLQUFLLENBQUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsR0FBRyxHQUFHLENBQWdCLENBQUM7QUFDM0UsQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFJLEdBQVEsRUFBRSxPQUE2QjtJQUNyRSxLQUFLLE1BQU0sSUFBSSxJQUFJLEdBQUcsRUFBRTtRQUN0QixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQztZQUFFLE9BQU8sS0FBSyxDQUFDO0tBQ2xDO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxtQkFBbUIsQ0FBSSxHQUFRLEVBQUUsT0FBNkI7SUFDNUUsT0FBTyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxFQUFFLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQ3ZFLENBQUMifQ==

package/dest/collection/index.d.ts

@@ -0,0 +1,2 @@
+export * from './array.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/collection/index.d.ts.map

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

package/dest/collection/index.js

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

package/dest/crypto/index.d.ts

@@ -0,0 +1,4 @@
+export * from './keccak/index.js';
+export * from './random/index.js';
+export * from './sha256/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/crypto/index.d.ts.map

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

package/dest/crypto/index.js

@@ -0,0 +1,4 @@
+export * from './keccak/index.js';
+export * from './random/index.js';
+export * from './sha256/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY3J5cHRvL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1CQUFtQixDQUFDIn0=

package/dest/crypto/keccak/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Computes the Keccak-256 hash of the given input buffer.
+ *
+ * @param input - The input buffer to be hashed.
+ * @returns The computed Keccak-256 hash as a Buffer.
+ */
+export declare function keccak(input: Buffer): Buffer;
+/**
+ * Computes the keccak-256 hash of a given input string and returns the result as a hexadecimal string.
+ */
+export declare function keccak256String(input: string): string;
+/**
+ * Computes the Keccak-224 hash of the given input buffer.
+ *
+ * @param input - The input buffer to be hashed.
+ * @returns The computed Keccak-224 hash as a Buffer.
+ */
+export declare function keccak224(input: Buffer): Buffer;
+//# sourceMappingURL=index.d.ts.map

package/dest/crypto/keccak/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/keccak/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,UAGnC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,UAK5C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,UAGtC"}

package/dest/crypto/keccak/index.js

@@ -0,0 +1,31 @@
+import { Keccak } from 'sha3';
+/**
+ * Computes the Keccak-256 hash of the given input buffer.
+ *
+ * @param input - The input buffer to be hashed.
+ * @returns The computed Keccak-256 hash as a Buffer.
+ */
+export function keccak(input) {
+    const hash = new Keccak(256);
+    return hash.update(input).digest();
+}
+/**
+ * Computes the keccak-256 hash of a given input string and returns the result as a hexadecimal string.
+ */
+export function keccak256String(input) {
+    const hash = new Keccak(256);
+    hash.reset();
+    hash.update(input);
+    return hash.digest('hex');
+}
+/**
+ * Computes the Keccak-224 hash of the given input buffer.
+ *
+ * @param input - The input buffer to be hashed.
+ * @returns The computed Keccak-224 hash as a Buffer.
+ */
+export function keccak224(input) {
+    const hash = new Keccak(224);
+    return hash.update(input).digest();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3J5cHRvL2tlY2Nhay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRTlCOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLE1BQU0sQ0FBQyxLQUFhO0lBQ2xDLE1BQU0sSUFBSSxHQUFHLElBQUksTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzdCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQztBQUNyQyxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUFDLEtBQWE7SUFDM0MsTUFBTSxJQUFJLEdBQUcsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDN0IsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ2IsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNuQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDNUIsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLFNBQVMsQ0FBQyxLQUFhO0lBQ3JDLE1BQU0sSUFBSSxHQUFHLElBQUksTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzdCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQztBQUNyQyxDQUFDIn0=

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

@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare const randomBytes: (len: number) => Buffer;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/random/index.ts"],"names":[],"mappings":";AAaA,eAAO,MAAM,WAAW,QAAS,MAAM,WAwBtC,CAAC"}

package/dest/crypto/random/index.js

@@ -0,0 +1,36 @@
+import isNode from 'detect-node';
+import nodeCrypto from 'crypto';
+// limit of Crypto.getRandomValues()
+// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
+const MAX_BYTES = 65536;
+const getWebCrypto = () => {
+    if (typeof window !== 'undefined' && window.crypto)
+        return window.crypto;
+    if (typeof self !== 'undefined' && self.crypto)
+        return self.crypto;
+    return undefined;
+};
+export const randomBytes = (len) => {
+    if (isNode) {
+        return nodeCrypto.randomBytes(len);
+    }
+    const crypto = getWebCrypto();
+    if (!crypto) {
+        throw new Error('randomBytes UnsupportedEnvironment');
+    }
+    const buf = Buffer.allocUnsafe(len);
+    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.slice(generated, generated + MAX_BYTES));
+        }
+    }
+    else {
+        crypto.getRandomValues(buf);
+    }
+    return buf;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3J5cHRvL3JhbmRvbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDakMsT0FBTyxVQUFVLE1BQU0sUUFBUSxDQUFDO0FBRWhDLG9DQUFvQztBQUNwQywwRUFBMEU7QUFDMUUsTUFBTSxTQUFTLEdBQUcsS0FBSyxDQUFDO0FBRXhCLE1BQU0sWUFBWSxHQUFHLEdBQUcsRUFBRTtJQUN4QixJQUFJLE9BQU8sTUFBTSxLQUFLLFdBQVcsSUFBSSxNQUFNLENBQUMsTUFBTTtRQUFFLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUN6RSxJQUFJLE9BQU8sSUFBSSxLQUFLLFdBQVcsSUFBSSxJQUFJLENBQUMsTUFBTTtRQUFFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztJQUNuRSxPQUFPLFNBQVMsQ0FBQztBQUNuQixDQUFDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsQ0FBQyxHQUFXLEVBQUUsRUFBRTtJQUN6QyxJQUFJLE1BQU0sRUFBRTtRQUNWLE9BQU8sVUFBVSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQVcsQ0FBQztLQUM5QztJQUVELE1BQU0sTUFBTSxHQUFHLFlBQVksRUFBRSxDQUFDO0lBQzlCLElBQUksQ0FBQyxNQUFNLEVBQUU7UUFDWCxNQUFNLElBQUksS0FBSyxDQUFDLG9DQUFvQyxDQUFDLENBQUM7S0FDdkQ7SUFFRCxNQUFNLEdBQUcsR0FBRyxNQUFNLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3BDLElBQUksR0FBRyxHQUFHLFNBQVMsRUFBRTtRQUNuQiwrQ0FBK0M7UUFDL0Msb0dBQW9HO1FBQ3BHLEtBQUssSUFBSSxTQUFTLEdBQUcsQ0FBQyxFQUFFLFNBQVMsR0FBRyxHQUFHLEVBQUUsU0FBUyxJQUFJLFNBQVMsRUFBRTtZQUMvRCxrRUFBa0U7WUFDbEUsc0NBQXNDO1lBQ3RDLE1BQU0sQ0FBQyxlQUFlLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsU0FBUyxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUM7U0FDckU7S0FDRjtTQUFNO1FBQ0wsTUFBTSxDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsQ0FBQztLQUM3QjtJQUVELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQyxDQUFDIn0=

package/dest/crypto/random/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dest/crypto/random/index.test.d.ts.map

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

package/dest/crypto/random/index.test.js

@@ -0,0 +1,13 @@
+import { randomBytes } from './index.js';
+describe('random', () => {
+    it('randomBytes returns a filled byte array', () => {
+        const data = randomBytes(32);
+        expect(data.length).toEqual(32);
+        let identical = true;
+        for (let i = 1; i < data.length; ++i) {
+            identical = identical && data[i] == data[i - 1];
+        }
+        expect(identical).toEqual(false);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgudGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jcnlwdG8vcmFuZG9tL2luZGV4LnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUV6QyxRQUFRLENBQUMsUUFBUSxFQUFFLEdBQUcsRUFBRTtJQUN0QixFQUFFLENBQUMseUNBQXlDLEVBQUUsR0FBRyxFQUFFO1FBQ2pELE1BQU0sSUFBSSxHQUFHLFdBQVcsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUM3QixNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNoQyxJQUFJLFNBQVMsR0FBRyxJQUFJLENBQUM7UUFDckIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLEVBQUU7WUFDcEMsU0FBUyxHQUFHLFNBQVMsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztTQUNqRDtRQUNELE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbkMsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMsQ0FBQyJ9

package/dest/crypto/sha256/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../../fields/fields.js';
+export declare const sha256: (data: Buffer) => Buffer;
+/**
+ * Squashes the output of sha256 into a field element.
+ * WARNING: if you have not thought about why you are using this, or talked to somebody who has do not use it.
+ * @param buf - Input buffer
+ * @returns Returns a sha256 output squashed into a field element.
+ */
+export declare const sha256ToField: (buf: Buffer) => Fr;
+//# sourceMappingURL=index.d.ts.map

package/dest/crypto/sha256/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/sha256/index.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAE5C,eAAO,MAAM,MAAM,SAAU,MAAM,WAAqD,CAAC;AAEzF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAAS,MAAM,KAAG,EAE3C,CAAC"}