@aztec/foundation 0.0.0-test.0

package/src/crypto/sha256/index.ts

@@ -0,0 +1,147 @@
+/* eslint-disable camelcase */
+import { default as hash } from 'hash.js';
+
+import { Fr } from '../../fields/fields.js';
+import { truncateAndPad } from '../../serialize/free_funcs.js';
+import { type Bufferable, serializeToBuffer } from '../../serialize/serialize.js';
+
+export function sha256(data: Buffer) {
+  return Buffer.from(hash.sha256().update(data).digest());
+}
+
+export function sha256Trunc(data: Buffer) {
+  return truncateAndPad(sha256(data));
+}
+
+export function sha256ToField(data: Bufferable[]) {
+  const buffer = serializeToBuffer(data);
+  return Fr.fromBuffer(sha256Trunc(buffer));
+}
+
+/**
+ * The "SHA256 Compression" operation (component operation of SHA256 "Hash").
+ * WARNING: modifies `state` in place (and also returns it)
+ *
+ * This algorithm is extracted from the hash.js package
+ * and modified to take in an initial state to operate on.
+ *
+ * @param state - The initial state to operate on (modified in-place). 8 u32s.
+ * @param inputs - The inputs to compress into the state. 16 u32s.
+ * @returns The modified state. 8 u32s.
+ */
+export function sha256Compression(state: Uint32Array, inputs: Uint32Array): Uint32Array {
+  if (state.length !== 8) {
+    throw new Error('`state` argument to SHA256 compression must be of length 8');
+  }
+  if (inputs.length !== 16) {
+    throw new Error('`inputs` argument to SHA256 compression must be of length 16');
+  }
+
+  const W = new Array(64);
+  const k = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98,
+    0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8,
+    0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
+    0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
+    0xc67178f2,
+  ];
+  let i = 0;
+  for (i = 0; i < 16; i++) {
+    W[i] = inputs[i];
+  }
+  for (i = 16; i < W.length; i++) {
+    W[i] = sum32_4(
+      W[i - 16],
+      W[i - 7],
+      g0_256(W[i - 15]), // Rot17, Rot18, Sh3
+      g1_256(W[i - 2]), //ROt17, Rot19, Sh10
+    );
+  }
+
+  let a = state[0];
+  let b = state[1];
+  let c = state[2];
+  let d = state[3];
+  let e = state[4];
+  let f = state[5];
+  let g = state[6];
+  let h = state[7];
+
+  for (let i = 0; i < 64; i++) {
+    const T1 = sum32_5(
+      h,
+      s1_256(e), // Rot6, Rot11, Rot25
+      ch32(e, f, g),
+      k[i],
+      W[i],
+    );
+
+    const T2 = sum32(
+      s0_256(a), // Rot2, Rot13, Rot22
+      maj32(a, b, c),
+    );
+    h = g;
+    g = f;
+    f = e;
+    e = sum32(d, T1);
+    d = c;
+    c = b;
+    b = a;
+    a = sum32(T1, T2);
+  }
+
+  state[0] = sum32(state[0], a);
+  state[1] = sum32(state[1], b);
+  state[2] = sum32(state[2], c);
+  state[3] = sum32(state[3], d);
+  state[4] = sum32(state[4], e);
+  state[5] = sum32(state[5], f);
+  state[6] = sum32(state[6], g);
+  state[7] = sum32(state[7], h);
+  return state;
+}
+
+// SHA256  HELPER FUNCTIONS (from hash.js package)
+
+function rotr32(w: number, b: number) {
+  return (w >>> b) | (w << (32 - b));
+}
+
+function sum32(a: number, b: number) {
+  return (a + b) >>> 0;
+}
+
+function sum32_4(a: number, b: number, c: number, d: number) {
+  return (a + b + c + d) >>> 0;
+}
+
+function sum32_5(a: number, b: number, c: number, d: number, e: number) {
+  return (a + b + c + d + e) >>> 0;
+}
+
+function ch32(x: number, y: number, z: number) {
+  return (x & y) ^ (~x & z);
+}
+
+function maj32(x: number, y: number, z: number) {
+  return (x & y) ^ (x & z) ^ (y & z);
+}
+
+function s0_256(x: number) {
+  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
+}
+
+function s1_256(x: number) {
+  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
+}
+
+function g0_256(x: number) {
+  return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);
+}
+
+function g1_256(x: number) {
+  return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);
+}

package/src/crypto/sha512/index.ts

@@ -0,0 +1,16 @@
+import { default as hash } from 'hash.js';
+
+import { GrumpkinScalar } from '../../fields/fields.js';
+import { type Bufferable, serializeToBuffer } from '../../serialize/serialize.js';
+
+export const sha512 = (data: Buffer) => Buffer.from(hash.sha512().update(data).digest());
+
+/**
+ * @dev We don't truncate in this function (unlike in sha256ToField) because this function is used in situations where
+ * we don't care only about collision resistance but we need the output to be uniformly distributed as well. This is
+ * because we use it as a pseudo-random function.
+ */
+export const sha512ToGrumpkinScalar = (data: Bufferable[]) => {
+  const buffer = serializeToBuffer(data);
+  return GrumpkinScalar.fromBufferReduce(sha512(buffer));
+};

package/src/crypto/signature/index.ts

@@ -0,0 +1,17 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+/**
+ * Interface to represent a signature.
+ */
+export interface Signature {
+  /**
+   * Serializes to a buffer.
+   * @returns A buffer.
+   */
+  toBuffer(): Buffer;
+  /**
+   * Serializes to an array of fields.
+   * @returns Fields.
+   */
+  toFields(): Fr[];
+}

package/src/crypto/sync/index.ts

@@ -0,0 +1,6 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+
+export * from './poseidon/index.js';
+export * from './pedersen/index.js';
+
+await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);

package/src/crypto/sync/pedersen/index.ts

@@ -0,0 +1,45 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+
+import { Fr } from '../../../fields/fields.js';
+import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
+
+/**
+ * Create a pedersen commitment (point) from an array of input fields.
+ * Left pads any inputs less than 32 bytes.
+ */
+export function pedersenCommit(input: Buffer[], offset = 0) {
+  if (!input.every(i => i.length <= 32)) {
+    throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
+  }
+  input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
+  const point = BarretenbergSync.getSingleton().pedersenCommit(
+    input.map(i => new FrBarretenberg(i)),
+    offset,
+  );
+  // toBuffer returns Uint8Arrays (browser/worker-boundary friendly).
+  // TODO: rename toTypedArray()?
+  return [Buffer.from(point.x.toBuffer()), Buffer.from(point.y.toBuffer())];
+}
+
+/**
+ * Create a pedersen hash (field) from an array of input fields.
+ * @param input - The input fieldables to hash.
+ * @param index - The separator index to use for the hash.
+ * @returns The pedersen hash.
+ */
+export function pedersenHash(input: Fieldable[], index = 0): Fr {
+  const inputFields = serializeToFields(input);
+  const hash = BarretenbergSync.getSingleton().pedersenHash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+    index,
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+/**
+ * Create a pedersen hash from an arbitrary length buffer.
+ */
+export function pedersenHashBuffer(input: Buffer, index = 0) {
+  const result = BarretenbergSync.getSingleton().pedersenHashBuffer(input, index);
+  return Buffer.from(result.toBuffer());
+}

package/src/crypto/sync/poseidon/index.ts

@@ -0,0 +1,76 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+
+import { Fr } from '../../../fields/fields.js';
+import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
+
+/**
+ * Create a poseidon hash (field) from an array of input fields.
+ * @param input - The input fields to hash.
+ * @returns The poseidon hash.
+ */
+export function poseidon2Hash(input: Fieldable[]): Fr {
+  const inputFields = serializeToFields(input);
+  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+/**
+ * Create a poseidon hash (field) from an array of input fields and a domain separator.
+ * @param input - The input fields to hash.
+ * @param separator - The domain separator.
+ * @returns The poseidon hash.
+ */
+export function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Fr {
+  const inputFields = serializeToFields(input);
+  inputFields.unshift(new Fr(separator));
+
+  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
+  const inputFields = serializeToFields(input);
+  const result = BarretenbergSync.getSingleton().poseidon2HashAccumulate(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
+  );
+  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
+}
+
+/**
+ * Runs a Poseidon2 permutation.
+ * @param input the input state. Expected to be of size 4.
+ * @returns the output state, size 4.
+ */
+export function poseidon2Permutation(input: Fieldable[]): Fr[] {
+  const inputFields = serializeToFields(input);
+  // We'd like this assertion but it's not possible to use it in the browser.
+  // assert(input.length === 4, 'Input state must be of size 4');
+  const res = BarretenbergSync.getSingleton().poseidon2Permutation(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
+  );
+  // We'd like this assertion but it's not possible to use it in the browser.
+  // assert(res.length === 4, 'Output state must be of size 4');
+  return res.map(o => Fr.fromBuffer(Buffer.from(o.toBuffer())));
+}
+
+export function poseidon2HashBytes(input: Buffer): Fr {
+  const inputFields = [];
+  for (let i = 0; i < input.length; i += 31) {
+    const fieldBytes = Buffer.alloc(32, 0);
+    input.slice(i, i + 31).copy(fieldBytes);
+
+    // Noir builds the bytes as little-endian, so we need to reverse them.
+    fieldBytes.reverse();
+    inputFields.push(Fr.fromBuffer(fieldBytes));
+  }
+
+  const res = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+
+  return Fr.fromBuffer(Buffer.from(res.toBuffer()));
+}

package/src/decorators/index.ts

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

package/src/decorators/memoize.ts

@@ -0,0 +1,11 @@
+export function memoize<This extends object, Result>(fn: () => Result, context: ClassMethodDecoratorContext) {
+  return function (this: This) {
+    const key = `__${String(context.name)}_value`;
+    const thisWithKey = this as { [key: string]: Result };
+    if (!(key in this)) {
+      const result = fn.call(this);
+      thisWithKey[key] = result;
+    }
+    return thisWithKey[key];
+  };
+}

package/src/error/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Represents an error thrown when an operation is interrupted unexpectedly.
+ * This custom error class extends the built-in Error class in JavaScript and
+ * can be used to handle cases where a process or task is terminated before completion.
+ */
+export class InterruptError extends Error {
+  public override readonly name = 'InterruptError';
+}
+
+/**
+ * An error thrown when an action times out.
+ */
+export class TimeoutError extends Error {
+  public override readonly name = 'TimeoutError';
+}
+
+/**
+ * Represents an error thrown when an operation is aborted.
+ */
+export class AbortError extends Error {
+  public override readonly name = 'AbortError';
+}

package/src/eth-address/index.ts

@@ -0,0 +1,241 @@
+import { inspect } from 'util';
+
+import { keccak256String } from '../crypto/keccak/index.js';
+import { randomBytes } from '../crypto/random/index.js';
+import { Fr } from '../fields/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
+import { BufferReader, FieldReader } from '../serialize/index.js';
+import { TypeRegistry } from '../serialize/type_registry.js';
+import { bufferToHex } from '../string/index.js';
+
+/**
+ * Represents an Ethereum address as a 20-byte buffer and provides various utility methods
+ * for converting between different representations, generating random addresses, validating
+ * checksums, and comparing addresses. EthAddress can be instantiated using a buffer or string,
+ * and can be serialized/deserialized from a buffer or BufferReader.
+ */
+export class EthAddress {
+  /** The size of an Ethereum address in bytes. */
+  public static SIZE_IN_BYTES = 20;
+  /** Represents a zero Ethereum address with 20 bytes filled with zeros. */
+  public static ZERO = new EthAddress(Buffer.alloc(EthAddress.SIZE_IN_BYTES));
+
+  constructor(private buffer: Buffer) {
+    if (buffer.length !== EthAddress.SIZE_IN_BYTES) {
+      throw new Error(`Expect buffer size to be ${EthAddress.SIZE_IN_BYTES}. Got ${buffer.length}.`);
+    }
+  }
+
+  /**
+   * Creates an EthAddress instance from a valid Ethereum address string.
+   * The input 'address' can be either in checksum format or lowercase, and it can be prefixed with '0x'.
+   * Throws an error if the input is not a valid Ethereum address.
+   *
+   * @param address - The string representing the Ethereum address.
+   * @returns An EthAddress instance.
+   */
+  public static fromString(address: string) {
+    if (!EthAddress.isAddress(address)) {
+      throw new Error(`Invalid address string: ${address}`);
+    }
+    return new EthAddress(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
+  }
+
+  /**
+   * Create a random EthAddress instance with 20 random bytes.
+   * This method generates a new Ethereum address with a randomly generated set of 20 bytes.
+   * It is useful for generating test addresses or unique identifiers.
+   *
+   * @returns A randomly generated EthAddress instance.
+   */
+  public static random() {
+    return new EthAddress(randomBytes(20));
+  }
+
+  /**
+   * Determines if the given string represents a valid Ethereum address.
+   * A valid address should meet the following criteria:
+   * 1. Contains exactly 40 hex characters (excluding an optional '0x' prefix).
+   * 2. Is either all lowercase, all uppercase, or has a valid checksum based on EIP-55.
+   *
+   * @param address - The string to be checked for validity as an Ethereum address.
+   * @returns True if the input string represents a valid Ethereum address, false otherwise.
+   */
+  public static isAddress(address: string) {
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+      // Does not have the basic requirements of an address.
+      return false;
+    } else if (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)) {
+      // It's ALL lowercase or ALL uppercase.
+      return true;
+    } else {
+      return EthAddress.checkAddressChecksum(address);
+    }
+  }
+
+  /**
+   * Checks if the EthAddress instance represents a zero address.
+   * A zero address consists of 20 bytes filled with zeros and is considered an invalid address.
+   *
+   * @returns A boolean indicating whether the EthAddress instance is a zero address or not.
+   */
+  public isZero() {
+    return this.equals(EthAddress.ZERO);
+  }
+
+  /**
+   * Checks if the given Ethereum address has a valid checksum.
+   * The input 'address' should be prefixed with '0x' or not, and have exactly 40 hex characters.
+   * Returns true if the address has a valid checksum, false otherwise.
+   *
+   * @param address - The hex-encoded string representing the Ethereum address.
+   * @returns A boolean value indicating whether the address has a valid checksum.
+   */
+  public static checkAddressChecksum(address: string) {
+    address = address.replace(/^0x/i, '');
+    const addressHash = keccak256String(address.toLowerCase());
+
+    for (let i = 0; i < 40; i++) {
+      // The nth letter should be uppercase if the nth digit of casemap is 1.
+      if (
+        (parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) ||
+        (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])
+      ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Converts an Ethereum address to its checksum format.
+   * The input 'address' should be prefixed with '0x' or not, and have exactly 40 hex characters.
+   * The checksum format is created by capitalizing certain characters in the hex string
+   * based on the hash of the lowercase address.
+   * Throws an error if the input address is invalid.
+   *
+   * @param address - The Ethereum address as a hex-encoded string.
+   * @returns The Ethereum address in its checksum format.
+   */
+  public static toChecksumAddress(address: string) {
+    if (!EthAddress.isAddress(address)) {
+      throw new Error('Invalid address string.');
+    }
+
+    address = address.toLowerCase().replace(/^0x/i, '');
+    const addressHash = keccak256String(address);
+    let checksumAddress = '0x';
+
+    for (let i = 0; i < address.length; i++) {
+      // If ith character is 9 to f then make it uppercase.
+      if (parseInt(addressHash[i], 16) > 7) {
+        checksumAddress += address[i].toUpperCase();
+      } else {
+        checksumAddress += address[i];
+      }
+    }
+    return checksumAddress;
+  }
+
+  /**
+   * Checks whether the given EthAddress instance is equal to the current instance.
+   * Equality is determined by comparing the underlying byte buffers of both instances.
+   *
+   * @param rhs - The EthAddress instance to compare with the current instance.
+   * @returns A boolean value indicating whether the two instances are equal (true) or not (false).
+   */
+  public equals(rhs: EthAddress) {
+    return this.buffer.equals(rhs.buffer);
+  }
+
+  /**
+   * Converts the Ethereum address to a hex-encoded string.
+   * The resulting string is prefixed with '0x' and has exactly 40 hex characters.
+   * This method can be used to represent the EthAddress instance in the widely used hexadecimal format.
+   *
+   * @returns A hex-encoded string representation of the Ethereum address.
+   */
+  public toString() {
+    return bufferToHex(this.buffer);
+  }
+
+  [inspect.custom]() {
+    return `EthAddress<${this.toString()}>`;
+  }
+
+  /**
+   * Returns the Ethereum address as a checksummed string.
+   * The output string will have characters in the correct upper or lowercase form, according to EIP-55.
+   * This provides a way to verify if an address is typed correctly, by checking the character casing.
+   *
+   * @returns A checksummed Ethereum address string.
+   */
+  public toChecksumString() {
+    return EthAddress.toChecksumAddress(this.buffer.toString('hex'));
+  }
+
+  /**
+   * Returns a 20-byte buffer representation of the Ethereum address.
+   * @returns A 20-byte Buffer containing the Ethereum address.
+   */
+  public toBuffer() {
+    return this.buffer;
+  }
+
+  /**
+   * Returns a 32-byte buffer representation of the Ethereum address, with the original 20-byte address
+   * occupying the last 20 bytes and the first 12 bytes being zero-filled.
+   * This format is commonly used in smart contracts when handling addresses as 32-byte values.
+   *
+   * @returns A 32-byte Buffer containing the padded Ethereum address.
+   */
+  public toBuffer32() {
+    const buffer = Buffer.alloc(32);
+    this.buffer.copy(buffer, 12);
+    return buffer;
+  }
+
+  /**
+   * Returns a new field with the same contents as this EthAddress.
+   *
+   * @returns An Fr instance.
+   */
+  public toField() {
+    return Fr.fromBuffer(this.toBuffer32());
+  }
+
+  /**
+   * Converts a field to a eth address.
+   * @param fr - The field to convert.
+   * @returns The eth address.
+   */
+  static fromField(fr: Fr): EthAddress {
+    return new EthAddress(fr.toBuffer().slice(-EthAddress.SIZE_IN_BYTES));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return EthAddress.fromField(reader.readField());
+  }
+
+  /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer to read from.
+   * @returns The EthAddress.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): EthAddress {
+    const reader = BufferReader.asReader(buffer);
+    return new EthAddress(reader.readBytes(EthAddress.SIZE_IN_BYTES));
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  static get schema() {
+    return hexSchemaFor(EthAddress, EthAddress.isAddress);
+  }
+}
+
+// For deserializing JSON.
+TypeRegistry.register('EthAddress', EthAddress);