@aztec/foundation 0.22.0 → 0.24.0

package/src/collection/array.ts

@@ -0,0 +1,64 @@
+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);
+}
+
+/**
+ * Executes the given function n times and returns the results in an array.
+ * @param n - How many times to repeat.
+ * @param fn - Mapper from index to value.
+ * @returns The array with the result from all executions.
+ */
+export function times<T>(n: number, fn: (i: number) => T): T[] {
+  return [...Array(n).keys()].map(i => fn(i));
+}

package/src/collection/index.ts

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

package/src/committable/committable.ts

@@ -0,0 +1,46 @@
+/**
+ * A class that allows for a value to be committed or rolled back.
+ */
+export class Committable<T> {
+  private currentValue: T;
+  private nextValue: T | undefined = undefined;
+
+  constructor(initialValue: T) {
+    this.currentValue = initialValue;
+  }
+
+  /**
+   * Commits the uncommitted value.
+   */
+  public commit() {
+    if (this.nextValue === undefined) {
+      return;
+    }
+    this.currentValue = this.nextValue;
+    this.nextValue = undefined;
+  }
+
+  /**
+   * Rolls back the uncommitted value.
+   */
+  public rollback() {
+    this.nextValue === undefined;
+  }
+
+  /**
+   * Gets the current value.
+   * @param includeUncommitted - Whether to include the uncommitted value.
+   * @returns The current value if includeUncommitted is false, otherwise the uncommitted value.
+   */
+  public get(includeUncommitted: boolean = false): T {
+    return includeUncommitted && this.nextValue ? this.nextValue : this.currentValue;
+  }
+
+  /**
+   * Sets the next value to be committed to.
+   * @param value - The new value to be set.
+   */
+  public set(value: T) {
+    this.nextValue = value;
+  }
+}

package/src/committable/index.ts

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

package/src/crypto/index.ts

@@ -0,0 +1,16 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+
+export * from './keccak/index.js';
+export * from './random/index.js';
+export * from './sha256/index.js';
+export * from './pedersen/index.js';
+
+/**
+ * Init the bb singleton. This constructs (if not already) the barretenberg sync api within bb.js itself.
+ * It takes about 100-200ms to initialize. It may not seem like much, but when in conjunction with many other things
+ * initializing, developers may want to pick precisely when to incur this cost.
+ * If in a test environment, we'll just do it on module load.
+ */
+export async function init() {
+  await BarretenbergSync.initSingleton();
+}

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/pedersen/index.ts

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