@aztec/foundation 0.1.0-alpha10

package/dest/wasm/worker/worker_pool.d.ts

@@ -0,0 +1,40 @@
+import { WasmWorker } from './wasm_worker.js';
+/**
+ * Type of a worker factory.
+ * Used to customize WorkerPool worker construction.
+ */
+export type CreateWorker = (name: string, minMem: number, maxMem: number) => WasmWorker;
+/**
+ * Allocates a pool of WasmWorker's.
+ * Worker 0 is allocated MAX_PAGES memory pages. This is because worker 0 will need to hold the proving key
+ * (i.e. Has state), whereas the others are pure compute (they hold a little crs state).
+ */
+export declare class WorkerPool {
+    /**
+     * The maximum number of memory pages to be used by the webassembly.
+     */
+    static MAX_PAGES: number;
+    /**
+     * The workers in the pool.
+     */
+    private workers;
+    /**
+     * Create an instance and initialize the workers.
+     * @param createWorker - Worker factory.
+     * @param poolSize - Pool size.
+     * @returns An initialized WorkerPool.
+     */
+    static new(createWorker: CreateWorker, poolSize: number): Promise<WorkerPool>;
+    /**
+     * Initialize the workers.
+     * @param createWorker - Worker factory().
+     * @param poolSize - Pool size.
+     * @param maxMem - Max memory pages.
+     */
+    init(createWorker: CreateWorker, poolSize: number, maxMem?: number): Promise<void>;
+    /**
+     * Tell all workers in the pool to stop processing.
+     */
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=worker_pool.d.ts.map

package/dest/wasm/worker/worker_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker_pool.d.ts","sourceRoot":"","sources":["../../../src/wasm/worker/worker_pool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAI9C;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,UAAU,CAAC;AACxF;;;;GAIG;AACH,qBAAa,UAAU;IAYrB;;OAEG;IACH,OAAc,SAAS,SAAQ;IAC/B;;OAEG;IACH,OAAO,CAAC,OAAO,CAAoB;IAEnC;;;;;OAKG;WACU,GAAG,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM;IAM7D;;;;;OAKG;IACU,IAAI,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAuB;IAY7F;;OAEG;IACU,OAAO;CAGrB"}

package/dest/wasm/worker/worker_pool.js

@@ -0,0 +1,62 @@
+import { createDebugLogger } from '../../log/index.js';
+const debug = createDebugLogger('bb:worker_pool');
+/**
+ * Allocates a pool of WasmWorker's.
+ * Worker 0 is allocated MAX_PAGES memory pages. This is because worker 0 will need to hold the proving key
+ * (i.e. Has state), whereas the others are pure compute (they hold a little crs state).
+ */
+export class WorkerPool {
+    constructor() {
+        /**
+         * The workers in the pool.
+         */
+        this.workers = [];
+    }
+    /**
+     * Create an instance and initialize the workers.
+     * @param createWorker - Worker factory.
+     * @param poolSize - Pool size.
+     * @returns An initialized WorkerPool.
+     */
+    static async new(createWorker, poolSize) {
+        const pool = new WorkerPool();
+        await pool.init(createWorker, poolSize);
+        return pool;
+    }
+    /**
+     * Initialize the workers.
+     * @param createWorker - Worker factory().
+     * @param poolSize - Pool size.
+     * @param maxMem - Max memory pages.
+     */
+    async init(createWorker, poolSize, maxMem = WorkerPool.MAX_PAGES) {
+        debug(`creating ${poolSize} workers...`);
+        const start = new Date().getTime();
+        this.workers = await Promise.all(Array(poolSize)
+            .fill(0)
+            .map((_, i) => createWorker(`${i}`, i === 0 ? Math.min(WorkerPool.MAX_PAGES, maxMem) : 768, maxMem)));
+        debug(`created workers: ${new Date().getTime() - start}ms`);
+    }
+    /**
+     * Tell all workers in the pool to stop processing.
+     */
+    async destroy() {
+        await Promise.all(this.workers.map(w => w.destroyWorker()));
+    }
+}
+// TODO(AD): Revisit what this means in aztec 3 context
+// --
+// Introduction of low mem prover work (polynomial cache) may actually increase mem usage when the backing store isn't
+// enabled. We were seeing intermittent failings related to memory in production for some users when limiting to
+// 6660 (416MB). It would be nice to understand why this is (the non determinism and/or the increased mem usage).
+// For now, increasing mem usage to 512MB. This maybe preferable to backing out the low mem work, but
+// ironically may break the chance of us using it in mobile.
+// We *could* enable the low memory backing store, but this needs a little bit of work to actually
+// read/write from indexeddb, performance testing, and actual further memory load testing.
+// At this point it's hard to know what our memory savings would be relative to just fully reverting the LMP.
+// public static MAX_PAGES = 6660;
+/**
+ * The maximum number of memory pages to be used by the webassembly.
+ */
+WorkerPool.MAX_PAGES = 8192;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyX3Bvb2wuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvd2FzbS93b3JrZXIvd29ya2VyX3Bvb2wudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHdkQsTUFBTSxLQUFLLEdBQUcsaUJBQWlCLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztBQU9sRDs7OztHQUlHO0FBQ0gsTUFBTSxPQUFPLFVBQVU7SUFBdkI7UUFnQkU7O1dBRUc7UUFDSyxZQUFPLEdBQWlCLEVBQUUsQ0FBQztJQXNDckMsQ0FBQztJQXBDQzs7Ozs7T0FLRztJQUNILE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFlBQTBCLEVBQUUsUUFBZ0I7UUFDM0QsTUFBTSxJQUFJLEdBQUcsSUFBSSxVQUFVLEVBQUUsQ0FBQztRQUM5QixNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQ3hDLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0ksS0FBSyxDQUFDLElBQUksQ0FBQyxZQUEwQixFQUFFLFFBQWdCLEVBQUUsTUFBTSxHQUFHLFVBQVUsQ0FBQyxTQUFTO1FBQzNGLEtBQUssQ0FBQyxZQUFZLFFBQVEsYUFBYSxDQUFDLENBQUM7UUFDekMsTUFBTSxLQUFLLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNuQyxJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FDOUIsS0FBSyxDQUFDLFFBQVEsQ0FBQzthQUNaLElBQUksQ0FBQyxDQUFDLENBQUM7YUFDUCxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUN2RyxDQUFDO1FBRUYsS0FBSyxDQUFDLG9CQUFvQixJQUFJLElBQUksRUFBRSxDQUFDLE9BQU8sRUFBRSxHQUFHLEtBQUssSUFBSSxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLE9BQU87UUFDbEIsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUM5RCxDQUFDOztBQXZERCx1REFBdUQ7QUFDdkQsS0FBSztBQUNMLHNIQUFzSDtBQUN0SCxnSEFBZ0g7QUFDaEgsaUhBQWlIO0FBQ2pILHFHQUFxRztBQUNyRyw0REFBNEQ7QUFDNUQsa0dBQWtHO0FBQ2xHLDBGQUEwRjtBQUMxRiw2R0FBNkc7QUFDN0csa0NBQWtDO0FBQ2xDOztHQUVHO0FBQ1csb0JBQVMsR0FBRyxJQUFJLEFBQVAsQ0FBUSJ9

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@aztec/foundation",
+  "version": "0.1.0-alpha10",
+  "exports": {
+    "./eslint": "./.eslintrc.cjs",
+    "./prettier": "./.prettierrc.json",
+    "./abi": "./dest/abi/index.js",
+    "./async-map": "./dest/async-map/index.js",
+    "./aztec-address": "./dest/aztec-address/index.js",
+    "./collection": "./dest/collection/index.js",
+    "./crypto": "./dest/crypto/index.js",
+    "./error": "./dest/error/index.js",
+    "./eth-address": "./dest/eth-address/index.js",
+    "./fifo": "./dest/fifo/index.js",
+    "./json-rpc": "./dest/json-rpc/index.js",
+    "./log": "./dest/log/index.js",
+    "./mutex": "./dest/mutex/index.js",
+    "./fields": "./dest/fields/index.js",
+    "./retry": "./dest/retry/index.js",
+    "./running-promise": "./dest/running-promise/index.js",
+    "./serialize": "./dest/serialize/index.js",
+    "./sleep": "./dest/sleep/index.js",
+    "./timer": "./dest/timer/index.js",
+    "./transport": "./dest/transport/index.js",
+    "./wasm": "./dest/wasm/index.js",
+    "./bigint-buffer": "./dest/bigint-buffer/index.js",
+    "./types": "./dest/types/index.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "@koa/cors": "^4.0.0",
+    "debug": "^4.3.4",
+    "detect-node": "^2.1.0",
+    "hash.js": "^1.1.7",
+    "koa": "^2.14.1",
+    "koa-bodyparser": "^4.4.0",
+    "koa-compress": "^5.1.0",
+    "koa-router": "^12.0.0",
+    "leveldown": "^6.1.1",
+    "levelup": "^5.1.1",
+    "memdown": "^6.1.1",
+    "sha3": "^2.1.4"
+  }
+}

package/src/abi/index.ts

@@ -0,0 +1,147 @@
+/**
+ * A named type.
+ */
+export interface ABIVariable {
+  /**
+   * The name of the variable.
+   */
+  name: string;
+  /**
+   * The type of the variable.
+   */
+  type: ABIType;
+}
+
+/**
+ * Indicates whether a parameter is public or secret/private.
+ */
+export enum ABIParameterVisibility {
+  PUBLIC = 'public',
+  SECRET = 'secret',
+}
+
+/**
+ * A function parameter.
+ */
+export interface ABIParameter extends ABIVariable {
+  /**
+   * Indicates whether a parameter is public or secret/private.
+   */
+  visibility: ABIParameterVisibility;
+}
+
+/**
+ * A basic type.
+ */
+export interface BasicType<T extends string> {
+  /**
+   * The kind of the type.
+   */
+  kind: T;
+}
+
+/**
+ * A variable type.
+ */
+export type ABIType = BasicType<'field'> | BasicType<'boolean'> | IntegerType | ArrayType | StringType | StructType;
+
+/**
+ * An integer type.
+ */
+export interface IntegerType extends BasicType<'integer'> {
+  /**
+   * The sign of the integer.
+   */
+  sign: string;
+  /**
+   * The width of the integer in bits.
+   */
+  width: number;
+}
+
+/**
+ * An array type.
+ */
+export interface ArrayType extends BasicType<'array'> {
+  /**
+   * The length of the array.
+   */
+  length: number;
+  /**
+   * The type of the array elements.
+   */
+  type: ABIType;
+}
+
+/**
+ * A string type.
+ */
+export interface StringType extends BasicType<'string'> {
+  /**
+   * The length of the string.
+   */
+  length: number;
+}
+
+/**
+ * A struct type.
+ */
+export interface StructType extends BasicType<'struct'> {
+  /**
+   * The fields of the struct.
+   */
+  fields: ABIVariable[];
+}
+
+/**
+ * Noir function types.
+ */
+export enum FunctionType {
+  SECRET = 'secret',
+  OPEN = 'open',
+  UNCONSTRAINED = 'unconstrained',
+}
+
+/**
+ * The ABI entry of a function.
+ */
+export interface FunctionAbi {
+  /**
+   * The name of the function.
+   */
+  name: string;
+  /**
+   * Whether the function is secret.
+   */
+  functionType: FunctionType;
+  /**
+   * Function parameters.
+   */
+  parameters: ABIParameter[];
+  /**
+   * The types of the return values.
+   */
+  returnTypes: ABIType[];
+  /**
+   * The ACIR bytecode of the function.
+   */
+  bytecode: string;
+  /**
+   * The verification key of the function.
+   */
+  verificationKey?: string;
+}
+
+/**
+ * Defines ABI of a contract.
+ */
+export interface ContractAbi {
+  /**
+   * The name of the contract.
+   */
+  name: string;
+  /**
+   * The functions of the contract.
+   */
+  functions: FunctionAbi[];
+}

package/src/async-map/async_map.test.ts

@@ -0,0 +1,9 @@
+import { asyncMap } from './index.js';
+
+describe('asyncMap', () => {
+  test('execute list item sequentially', async () => {
+    const sleepAndLog = (ms: number, idx: number) => new Promise(resolve => setTimeout(() => resolve(idx), ms));
+    const result = await asyncMap([100, 0, 30, 1], (ms, i) => sleepAndLog(ms, i));
+    expect(result).toEqual([0, 1, 2, 3]);
+  });
+});

package/src/async-map/index.ts

@@ -0,0 +1,18 @@
+/**
+ * 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<T, U>(arr: T[], fn: (e: T, i: number) => Promise<U>): Promise<U[]> {
+  const results: U[] = [];
+  for (let i = 0; i < arr.length; ++i) {
+    results.push(await fn(arr[i], i));
+  }
+  return results;
+}

package/src/aztec-address/index.ts

@@ -0,0 +1,135 @@
+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 {
+  static SIZE_IN_BYTES = 32;
+  static ZERO = new AztecAddress(Buffer.alloc(AztecAddress.SIZE_IN_BYTES));
+  static MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
+  static MAX_VALUE = AztecAddress.MODULUS - 1n;
+
+  constructor(
+    /**
+     * The buffer field.
+     */
+    public readonly 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: Buffer | BufferReader) {
+    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: string) {
+    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(): `0x${string}` {
+    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: AztecAddress) {
+    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();
+  }
+}

package/src/bigint-buffer/bigint-buffer.test.ts

@@ -0,0 +1,21 @@
+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');
+    });
+  });
+});

package/src/bigint-buffer/index.ts

@@ -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: Buffer): bigint {
+  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: Buffer): bigint {
+  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: bigint, width: number): Buffer {
+  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: bigint, width: number): Buffer {
+  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: bigint, padTo32 = false): `0x${string}` {
+  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}`;
+}

package/src/collection/array.ts

@@ -0,0 +1,48 @@
+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 function padArrayEnd<T, N extends number>(arr: T[], elem: T, length: N): Tuple<T, N> {
+  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)] as 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 function padArrayStart<T, N extends number>(arr: T[], elem: T, length: N): Tuple<T, N> {
+  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] as 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 function isArrayEmpty<T>(arr: T[], isEmpty: (item: T) => boolean): boolean {
+  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<T>(arr: T[], isEmpty: (item: T) => boolean): number {
+  return arr.reduce((sum, item) => (isEmpty(item) ? sum : sum + 1), 0);
+}

package/src/collection/index.ts

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

package/src/crypto/index.ts

@@ -0,0 +1,3 @@
+export * from './keccak/index.js';
+export * from './random/index.js';
+export * from './sha256/index.js';

package/src/crypto/keccak/index.ts

@@ -0,0 +1,33 @@
+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: Buffer) {
+  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: string) {
+  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: Buffer) {
+  const hash = new Keccak(224);
+  return hash.update(input).digest();
+}

package/src/crypto/random/index.test.ts

@@ -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);
+  });
+});