@aztec/foundation 0.0.0-test.0

package/README.md

@@ -0,0 +1 @@
+# Foundation

package/dest/array/array.d.ts

@@ -0,0 +1,71 @@
+import type { Tuple } from '../serialize/index.js';
+export type { FieldsOf } from '../types/index.js';
+/**
+ * Create an array over an integer range.
+ * @param n - The number of integers.
+ * @param offset - The starting number.
+ * @returns The array of numbers.
+ */
+export declare function range(n: number, offset?: number): number[];
+/**
+ * Create an array over an integer range, filled with a function 'fn'.
+ * This is used over e.g. lodash because it resolved to a tuple type, needed for our fixed array type safety.
+ * @param n - The number of integers.
+ * @param fn - The generator function.
+ * @returns The array of numbers.
+ */
+export declare function makeTuple<T, N extends number>(length: N, fn: (i: number) => T, offset?: number): Tuple<T, N>;
+/**
+ * Create an array over an integer range, filled with a function 'fn'.
+ * This is used over e.g. lodash because it resolved to a tuple type, needed for our fixed array type safety.
+ * @param n - The number of integers.
+ * @param fn - The generator function.
+ * @returns The array of numbers.
+ */
+export declare function makeTupleAsync<T, N extends number>(length: N, fn: (i: number) => Promise<T>, offset?: number): Promise<Tuple<T, N>>;
+/**
+ * Create an array over an integer range, filled with a function 'fn'. However, the latter half of the array are set to zeros.
+ * see `makeTuple` above.
+ * @param n - The number of integers.
+ * @param fn - The generator function.
+ * @returns The array of numbers.
+ */
+export declare function makeHalfFullTuple<T, N extends number>(length: N, fn: (i: number) => T, offset: number | undefined, makeEmpty: () => T): Tuple<T, N>;
+/**
+ * Assert a member of an object is a certain length.
+ * @param obj - An object.
+ * @param member - A member string.
+ * @param length - The length.
+ */
+export declare function assertMemberLength<F extends string, T extends {
+    [f in F]: {
+        /**
+         * A property which the tested member of the object T has to have.
+         */
+        length: number;
+    };
+}>(obj: T, member: F, length: number): void;
+/**
+ * Assert all subarrays in a member of an object are a certain length.
+ * @param obj - An object.
+ * @param member - A member string.
+ * @param length - The expected length for each subarray.
+ */
+export declare function assertItemsLength<F extends string, T extends {
+    [f in F]: {
+        /**
+         * A property which the tested member of the object T has to have.
+         */
+        length: number;
+    }[];
+}>(obj: T, member: F, length: number): void;
+/**
+ * Checks that the permutation is valid. Throws an error if it is not.
+ * @param original - The original array.
+ * @param permutation - The array which is allegedly a permutation of the original.
+ * @param indexes - The indices of the original array which the permutation should map to.
+ * @param isEqual - A function to compare the elements of the original and permutation arrays.
+ */
+export declare function assertPermutation<T>(original: T[], permutation: T[], indexes: number[], isEqual: (a: T, b: T) => boolean): void;
+export declare function assertRightPadded<T>(arr: T[], isEmpty: (item: T) => boolean): void;
+//# sourceMappingURL=array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/array/array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,YAAY,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,SAAI,YAM1C;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,EAAE,MAAM,SAAI,eAEzF;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,SAAI,wBAM7G;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EACnD,MAAM,EAAE,CAAC,EACT,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,EACpB,MAAM,oBAAI,EACV,SAAS,EAAE,MAAM,CAAC,eAGnB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS;KACP,CAAC,IAAI,CAAC,GAAG;QACR;;WAEG;QACH,MAAM,EAAE,MAAM,CAAC;KAChB;CACF,EACD,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,QAIlC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS;KACP,CAAC,IAAI,CAAC,GAAG;QACR;;WAEG;QACH,MAAM,EAAE,MAAM,CAAC;KAChB,EAAE;CACJ,EACD,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,QAOlC;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,QAAQ,EAAE,CAAC,EAAE,EACb,WAAW,EAAE,CAAC,EAAE,EAChB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAC/B,IAAI,CAmBN;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,QAS3E"}

package/dest/array/array.js

@@ -0,0 +1,100 @@
+/**
+ * Create an array over an integer range.
+ * @param n - The number of integers.
+ * @param offset - The starting number.
+ * @returns The array of numbers.
+ */ export function range(n, offset = 0) {
+    const ret = [];
+    for(let i = 0; i < n; i++){
+        ret.push(offset + i);
+    }
+    return ret;
+}
+/**
+ * Create an array over an integer range, filled with a function 'fn'.
+ * This is used over e.g. lodash because it resolved to a tuple type, needed for our fixed array type safety.
+ * @param n - The number of integers.
+ * @param fn - The generator function.
+ * @returns The array of numbers.
+ */ export function makeTuple(length, fn, offset = 0) {
+    return Array.from({
+        length
+    }, (_, i)=>fn(i + offset));
+}
+/**
+ * Create an array over an integer range, filled with a function 'fn'.
+ * This is used over e.g. lodash because it resolved to a tuple type, needed for our fixed array type safety.
+ * @param n - The number of integers.
+ * @param fn - The generator function.
+ * @returns The array of numbers.
+ */ export async function makeTupleAsync(length, fn, offset = 0) {
+    return await Promise.all(Array(length).fill(0).map(async (_, i)=>await fn(i + offset)));
+}
+/**
+ * Create an array over an integer range, filled with a function 'fn'. However, the latter half of the array are set to zeros.
+ * see `makeTuple` above.
+ * @param n - The number of integers.
+ * @param fn - The generator function.
+ * @returns The array of numbers.
+ */ export function makeHalfFullTuple(length, fn, offset = 0, makeEmpty) {
+    return Array.from({
+        length
+    }, (_, i)=>i < length / 2 ? fn(i + offset) : makeEmpty());
+}
+/**
+ * Assert a member of an object is a certain length.
+ * @param obj - An object.
+ * @param member - A member string.
+ * @param length - The length.
+ */ export function assertMemberLength(obj, member, length) {
+    if (obj[member].length !== length) {
+        throw new Error(`Expected ${member} to have length ${length} but was ${obj[member].length}`);
+    }
+}
+/**
+ * Assert all subarrays in a member of an object are a certain length.
+ * @param obj - An object.
+ * @param member - A member string.
+ * @param length - The expected length for each subarray.
+ */ export function assertItemsLength(obj, member, length) {
+    const arrays = obj[member];
+    for(let i = 0; i < arrays.length; i++){
+        if (arrays[i].length !== length) {
+            throw new Error(`Expected ${member}[${i}] to have length ${length} but was ${arrays[i].length}`);
+        }
+    }
+}
+/**
+ * Checks that the permutation is valid. Throws an error if it is not.
+ * @param original - The original array.
+ * @param permutation - The array which is allegedly a permutation of the original.
+ * @param indexes - The indices of the original array which the permutation should map to.
+ * @param isEqual - A function to compare the elements of the original and permutation arrays.
+ */ export function assertPermutation(original, permutation, indexes, isEqual) {
+    if (original.length !== permutation.length || original.length !== indexes.length) {
+        throw new Error(`Invalid lengths: ${original.length}, ${permutation.length}, ${indexes.length}`);
+    }
+    const seenValue = new Set();
+    for(let i = 0; i < indexes.length; i++){
+        const index = indexes[i];
+        const permutedValue = permutation[i];
+        const originalValueAtIndex = original[index];
+        if (!isEqual(permutedValue, originalValueAtIndex)) {
+            throw new Error(`Invalid permutation at index ${index}: ${permutedValue} !== ${originalValueAtIndex}`);
+        }
+        if (seenValue.has(index)) {
+            throw new Error(`Duplicate index in permutation: ${index}`);
+        }
+        seenValue.add(index);
+    }
+}
+export function assertRightPadded(arr, isEmpty) {
+    let seenEmpty = false;
+    for(let i = 0; i < arr.length; i++){
+        if (isEmpty(arr[i])) {
+            seenEmpty = true;
+        } else if (seenEmpty) {
+            throw new Error(`Non-empty element at index [${i}] after empty element`);
+        }
+    }
+}

package/dest/array/index.d.ts

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

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

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

package/dest/array/index.js

@@ -0,0 +1 @@
+export * from './array.js';

package/dest/async-map/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Maps an array of elements by applying an asynchronous function to each element in sequence,
+ * and returns a new array with the results. The function receives each element of the array
+ * and its index as arguments, and should return a Promise that resolves to the desired value.
+ *
+ * @typeParam T - The original array element type.
+ * @typeParam U - The resulting array element type.
+ * @param arr - The array to map.
+ * @param fn - The async function to apply on each element of the array.
+ * @returns A Promise that resolves to a new array containing the mapped values.
+ */
+export declare function asyncMap<T, U>(arr: T[], fn: (e: T, i: number) => Promise<U>): Promise<U[]>;
+//# sourceMappingURL=index.d.ts.map

package/dest/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;;;;;;;;;;GAUG;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/index.js

@@ -0,0 +1,17 @@
+/**
+ * Maps an array of elements by applying an asynchronous function to each element in sequence,
+ * and returns a new array with the results. The function receives each element of the array
+ * and its index as arguments, and should return a Promise that resolves to the desired value.
+ *
+ * @typeParam T - The original array element type.
+ * @typeParam U - The resulting array element type.
+ * @param arr - The array to map.
+ * @param fn - The async function to apply on each element of the array.
+ * @returns A Promise that resolves to a new array containing the mapped values.
+ */ export async function asyncMap(arr, fn) {
+    const results = [];
+    for(let i = 0; i < arr.length; ++i){
+        results.push(await fn(arr[i], i));
+    }
+    return results;
+}

package/dest/async-pool/index.d.ts

@@ -0,0 +1,3 @@
+/** Executes the given async function over the iterable, up to a determined number of promises in parallel. */
+export declare function asyncPool<T, R>(poolLimit: number, iterable: T[], iteratorFn: (item: T, iterable: T[]) => Promise<R>): Promise<Awaited<R>[]>;
+//# sourceMappingURL=index.d.ts.map

package/dest/async-pool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async-pool/index.ts"],"names":[],"mappings":"AA2BA,8GAA8G;AAC9G,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,yBAqBnH"}

package/dest/async-pool/index.js

@@ -0,0 +1,47 @@
+/*
+ * Adapted from https://github.com/rxaviers/async-pool/blob/1.x/lib/es6.js
+ *
+ * Copyright (c) 2017 Rafael Xavier de Souza http://rafael.xavier.blog.br
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */ /** Executes the given async function over the iterable, up to a determined number of promises in parallel. */ export function asyncPool(poolLimit, iterable, iteratorFn) {
+    let i = 0;
+    const ret = [];
+    const executing = new Set();
+    const enqueue = ()=>{
+        if (i === iterable.length) {
+            return Promise.resolve();
+        }
+        const item = iterable[i++];
+        const p = Promise.resolve().then(()=>iteratorFn(item, iterable));
+        ret.push(p);
+        executing.add(p);
+        const clean = ()=>executing.delete(p);
+        p.then(clean).catch(clean);
+        let r = Promise.resolve();
+        if (executing.size >= poolLimit) {
+            r = Promise.race(executing);
+        }
+        return r.then(()=>enqueue());
+    };
+    return enqueue().then(()=>Promise.all(ret));
+}

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

@@ -0,0 +1,42 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <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}`;
+/**
+ * Converts a hex string to a buffer. Throws if input is not a valid hex string.
+ * @param value - The hex string to convert. May be 0x prefixed or not.
+ * @returns A buffer.
+ */
+export declare function fromHex(value: string): Buffer;
+//# 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,CAQ7D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAU7D;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,KAAK,MAAM,EAAE,CAKjE;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7C"}

package/dest/bigint-buffer/index.js

@@ -0,0 +1,76 @@
+/**
+ * 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}`;
+}
+/**
+ * Converts a hex string to a buffer. Throws if input is not a valid hex string.
+ * @param value - The hex string to convert. May be 0x prefixed or not.
+ * @returns A buffer.
+ */ export function fromHex(value) {
+    const hexRegex = /^(0x)?[0-9a-fA-F]*$/;
+    if (!hexRegex.test(value) || value.length % 2 !== 0) {
+        throw new Error(`Invalid hex string: ${value}`);
+    }
+    return Buffer.from(value.replace(/^0x/i, ''), 'hex');
+}

package/dest/buffer/buffer32.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+/**
+ * A class representing a 32 byte Buffer.
+ */
+export declare class Buffer32 {
+    /**
+     * The buffer containing the hash.
+     */
+    buffer: Buffer;
+    /**
+     * The size of the hash in bytes.
+     */
+    static SIZE: number;
+    /**
+     * Buffer32 with value zero.
+     */
+    static ZERO: Buffer32;
+    constructor(
+    /**
+     * The buffer containing the hash.
+     */
+    buffer: Buffer);
+    /**
+     * Returns the raw buffer of the hash.
+     * @returns The buffer containing the hash.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Creates a Buffer32 from a buffer.
+     * @param buffer - The buffer to create from.
+     * @returns A new Buffer32 object.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): Buffer32;
+    /**
+     * Checks if this hash and another hash are equal.
+     * @param hash - A hash to compare with.
+     * @returns True if the hashes are equal, false otherwise.
+     */
+    equals(hash: Buffer32): boolean;
+    /**
+     * Returns true if this hash is zero.
+     * @returns True if this hash is zero.
+     */
+    isZero(): boolean;
+    /**
+     * Convert this hash to a hex string.
+     * @returns The hex string.
+     */
+    toString(): `0x${string}`;
+    toJSON(): `0x${string}`;
+    /**
+     * Convert this hash to a big int.
+     * @returns The big int.
+     */
+    toBigInt(): bigint;
+    /**
+     * Creates a Buffer32 from a bigint.
+     * @param hash - The tx hash as a big int.
+     * @returns The Buffer32.
+     */
+    static fromBigInt(hash: bigint): Buffer32;
+    static fromField(hash: Fr): Buffer32;
+    /**
+     * Converts this hash from a buffer of 28 bytes.
+     * Verifies the input is 28 bytes.
+     * @param buffer - The 28 byte buffer to construct from.
+     * @returns A Buffer32 created from the input buffer with 4 bytes 0 padding at the front.
+     */
+    static fromBuffer28(buffer: Buffer): Buffer32;
+    /**
+     * Converts a string into a Buffer32 object.
+     * @param str - The TX hash in string format.
+     * @returns A new Buffer32 object.
+     */
+    static fromString(str: string): Buffer32;
+    /**
+     * Converts a number into a Buffer32 object.
+     * @param num - The number to convert.
+     * @returns A new Buffer32 object.
+     */
+    static fromNumber(num: number): Buffer32;
+    /**
+     * Generates a random Buffer32.
+     * @returns A new Buffer32 object.
+     */
+    static random(): Buffer32;
+}
+//# sourceMappingURL=buffer32.d.ts.map

package/dest/buffer/buffer32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer32.d.ts","sourceRoot":"","sources":["../../src/buffer/buffer32.ts"],"names":[],"mappings":";;AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,YAAY,EAAsC,MAAM,6BAA6B,CAAC;AAI/F;;GAEG;AACH,qBAAa,QAAQ;IAYjB;;OAEG;IACI,MAAM,EAAE,MAAM;IAdvB;;OAEG;IACH,OAAc,IAAI,SAAM;IAExB;;OAEG;IACH,OAAc,IAAI,WAA6C;;IAG7D;;OAEG;IACI,MAAM,EAAE,MAAM;IAOvB;;;OAGG;IACI,QAAQ;IAIf;;;;OAIG;WACW,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAKtD;;;;OAIG;IACI,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO;IAItC;;;OAGG;IACI,MAAM,IAAI,OAAO;IAIxB;;;OAGG;IACI,QAAQ;IAIf,MAAM;IAIN;;;OAGG;IACI,QAAQ;IAGf;;;;OAIG;WACW,UAAU,CAAC,IAAI,EAAE,MAAM;WAIvB,SAAS,CAAC,IAAI,EAAE,EAAE;IAIhC;;;;;OAKG;WACW,YAAY,CAAC,MAAM,EAAE,MAAM;IAQzC;;;;OAIG;WACW,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;IAU/C;;;;OAIG;WACW,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;IAI/C;;;OAGG;WACW,MAAM,IAAI,QAAQ;CAGjC"}

package/dest/buffer/buffer32.js

@@ -0,0 +1,115 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { BufferReader, deserializeBigInt, serializeBigInt } from '@aztec/foundation/serialize';
+import { bufferToHex } from '../string/index.js';
+/**
+ * A class representing a 32 byte Buffer.
+ */ export class Buffer32 {
+    buffer;
+    /**
+   * The size of the hash in bytes.
+   */ static SIZE = 32;
+    /**
+   * Buffer32 with value zero.
+   */ static ZERO = new Buffer32(Buffer.alloc(Buffer32.SIZE));
+    constructor(/**
+     * The buffer containing the hash.
+     */ buffer){
+        this.buffer = buffer;
+        if (buffer.length !== Buffer32.SIZE) {
+            throw new Error(`Expected buffer to have length ${Buffer32.SIZE} but was ${buffer.length}`);
+        }
+    }
+    /**
+   * Returns the raw buffer of the hash.
+   * @returns The buffer containing the hash.
+   */ toBuffer() {
+        return this.buffer;
+    }
+    /**
+   * Creates a Buffer32 from a buffer.
+   * @param buffer - The buffer to create from.
+   * @returns A new Buffer32 object.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new Buffer32(reader.readBytes(Buffer32.SIZE));
+    }
+    /**
+   * Checks if this hash and another hash are equal.
+   * @param hash - A hash to compare with.
+   * @returns True if the hashes are equal, false otherwise.
+   */ equals(hash) {
+        return this.buffer.equals(hash.buffer);
+    }
+    /**
+   * Returns true if this hash is zero.
+   * @returns True if this hash is zero.
+   */ isZero() {
+        return this.buffer.equals(Buffer.alloc(32, 0));
+    }
+    /**
+   * Convert this hash to a hex string.
+   * @returns The hex string.
+   */ toString() {
+        return bufferToHex(this.buffer);
+    }
+    toJSON() {
+        return this.toString();
+    }
+    /**
+   * Convert this hash to a big int.
+   * @returns The big int.
+   */ toBigInt() {
+        return deserializeBigInt(this.buffer, 0, Buffer32.SIZE).elem;
+    }
+    /**
+   * Creates a Buffer32 from a bigint.
+   * @param hash - The tx hash as a big int.
+   * @returns The Buffer32.
+   */ static fromBigInt(hash) {
+        return new Buffer32(serializeBigInt(hash, Buffer32.SIZE));
+    }
+    static fromField(hash) {
+        return new Buffer32(serializeBigInt(hash.toBigInt()));
+    }
+    /**
+   * Converts this hash from a buffer of 28 bytes.
+   * Verifies the input is 28 bytes.
+   * @param buffer - The 28 byte buffer to construct from.
+   * @returns A Buffer32 created from the input buffer with 4 bytes 0 padding at the front.
+   */ static fromBuffer28(buffer) {
+        if (buffer.length != 28) {
+            throw new Error(`Expected Buffer32 input buffer to be 28 bytes`);
+        }
+        const padded = Buffer.concat([
+            Buffer.alloc(this.SIZE - 28),
+            buffer
+        ]);
+        return new Buffer32(padded);
+    }
+    /**
+   * Converts a string into a Buffer32 object.
+   * @param str - The TX hash in string format.
+   * @returns A new Buffer32 object.
+   */ static fromString(str) {
+        if (str.startsWith('0x')) {
+            str = str.slice(2);
+        }
+        if (str.length !== 64) {
+            throw new Error(`Expected string to be 64 characters long, but was ${str.length}`);
+        }
+        return new Buffer32(Buffer.from(str, 'hex'));
+    }
+    /**
+   * Converts a number into a Buffer32 object.
+   * @param num - The number to convert.
+   * @returns A new Buffer32 object.
+   */ static fromNumber(num) {
+        return new Buffer32(serializeBigInt(BigInt(num), Buffer32.SIZE));
+    }
+    /**
+   * Generates a random Buffer32.
+   * @returns A new Buffer32 object.
+   */ static random() {
+        return new Buffer32(Buffer.from(randomBytes(Buffer32.SIZE)));
+    }
+}

package/dest/buffer/index.d.ts

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

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

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

package/dest/buffer/index.js

@@ -0,0 +1 @@
+export * from './buffer32.js';