@aztec/foundation 0.15.0 → 0.16.0

package/src/aztec-address/index.ts

@@ -1,162 +1,30 @@
-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.
+ * 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.
+ * It 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}.`);
+export class AztecAddress extends Fr {
+  constructor(buffer: Buffer) {
+    if (buffer.length !== 32) {
+      throw new Error(`Invalid length ${buffer.length}.`);
     }
+    super(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() {
-    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);
-  }
-
-  /**
-   * Creates an AztecAddress from a bigint.
-   * The provided value must be within the range of a field.
-   * @param address - The bigint representation of the address.
-   * @returns An AztecAddress instance.
-   */
-  static fromBigInt(address: bigint) {
-    return new AztecAddress(toBufferBE(address, AztecAddress.SIZE_IN_BYTES));
-  }
-
-  /**
-   * 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 from a Field element.
-   * @param field - The Field element to convert.
-   * @returns An Address Object from a Field element with the same value.
-   */
-  static fromField(field: Fr): AztecAddress {
-    return new AztecAddress(toBufferBE(field.value, AztecAddress.SIZE_IN_BYTES));
-  }
-
-  /**
-   * Returns this address as a field element.
-   * @returns A field element with the same value as the address.
-   */
-  toField() {
-    return Fr.fromBuffer(this.toBuffer());
-  }
-
-  /**
-   * Returns this address as a bigint. Useful for creating maps indexed by addresses.
-   * @returns A bigint with the same value as the address.
-   */
-  toBigInt() {
-    return toBigIntBE(this.buffer);
-  }
-
-  /**
-   * Determines if this AztecAddress instance is equal to the given AztecAddress instance.
-   * Equality is based on the content of their respective buffers.
-   *
-   * @param other - The AztecAddress instance to compare against.
-   * @returns True if the buffers of both instances are equal, false otherwise.
-   */
-  equals(other: AztecAddress) {
-    return this.buffer.equals(other.buffer);
+  static fromField(fr: Fr) {
+    return new AztecAddress(fr.toBuffer());
   }
 
-  /**
-   * 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);
+  static fromBigInt(value: bigint) {
+    return AztecAddress.fromField(new Fr(value));
   }
 
-  /**
-   * Friendly representation for debugging purposes.
-   *
-   * @returns A hex string representing the address.
-   */
-  toFriendlyJSON() {
-    return this.toString();
+  static fromString(buf: string) {
+    const buffer = Buffer.from(buf.replace(/^0x/i, ''), 'hex');
+    return new AztecAddress(buffer);
   }
 }

package/src/bigint-buffer/index.ts

@@ -33,7 +33,9 @@ export function toBigIntBE(buf: Buffer): bigint {
  * @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.`);
+  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();
@@ -47,10 +49,14 @@ export function toBufferLE(num: bigint, width: number): Buffer {
  * @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.`);
+  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}`);
+  if (buffer.length > width) {
+    throw new Error(`Number ${num.toString(16)} does not fit in ${width}`);
+  }
   return buffer;
 }
 

package/src/collection/array.ts

@@ -8,7 +8,9 @@ import { Tuple } from '../serialize/types.js';
  * @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`);
+  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>;
 }
@@ -21,7 +23,9 @@ export function padArrayEnd<T, N extends number>(arr: T[], elem: T, length: N):
  * @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`);
+  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>;
 }
@@ -33,7 +37,9 @@ export function padArrayStart<T, N extends number>(arr: T[], elem: T, length: N)
  */
 export function isArrayEmpty<T>(arr: T[], isEmpty: (item: T) => boolean): boolean {
   for (const item of arr) {
-    if (!isEmpty(item)) return false;
+    if (!isEmpty(item)) {
+      return false;
+    }
   }
   return true;
 }

package/src/crypto/pedersen/pedersen.wasm.ts

@@ -1,6 +1,8 @@
-import { Pedersen } from '@aztec/bb.js';
+import { BarretenbergSync, Fr } from '@aztec/bb.js';
 
-const pedersen = await Pedersen.new();
+// Get the singleton. This constructs (if not already) the barretenberg sync api within bb.js itself.
+// This can be called from multiple other modules as needed, and it ensures it's only constructed once.
+const api = await BarretenbergSync.getSingleton();
 
 /**
  * Create a pedersen commitment (point) from an array of input fields.
@@ -11,8 +13,10 @@ export function pedersenCommit(input: Buffer[]) {
     throw new Error('All input buffers must be <= 32 bytes.');
   }
   input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
-  const [x, y] = pedersen.pedersenCommit(input);
-  return [Buffer.from(x), Buffer.from(y)];
+  const point = api.pedersenCommit(input.map(i => new Fr(i)));
+  // toBuffer returns Uint8Arrays (browser/worker-boundary friendly).
+  // TODO: rename toTypedArray()?
+  return [Buffer.from(point.x.toBuffer()), Buffer.from(point.y.toBuffer())];
 }
 
 /**
@@ -24,5 +28,19 @@ export function pedersenHash(input: Buffer[], index = 0) {
     throw new Error('All input buffers must be <= 32 bytes.');
   }
   input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
-  return Buffer.from(pedersen.pedersenHash(input, index));
+  return Buffer.from(
+    api
+      .pedersenHash(
+        input.map(i => new Fr(i)),
+        index,
+      )
+      .toBuffer(),
+  );
+}
+
+/**
+ * Create a pedersen hash from an arbitrary length buffer.
+ */
+export function pedersenHashBuffer(input: Buffer, index = 0) {
+  return Buffer.from(api.pedersenHashBuffer(input, index).toBuffer());
 }

package/src/crypto/random/index.ts

@@ -6,8 +6,12 @@ import isNode from 'detect-node';
 const MAX_BYTES = 65536;
 
 const getWebCrypto = () => {
-  if (typeof window !== 'undefined' && window.crypto) return window.crypto;
-  if (typeof self !== 'undefined' && self.crypto) return self.crypto;
+  if (typeof window !== 'undefined' && window.crypto) {
+    return window.crypto;
+  }
+  if (typeof self !== 'undefined' && self.crypto) {
+    return self.crypto;
+  }
   return undefined;
 };
 

package/src/crypto/sha256/index.ts

@@ -1,16 +1,3 @@
 import { default as hash } from 'hash.js';
 
-import { toBigIntBE, toBufferBE } from '../../bigint-buffer/index.js';
-import { Fr } from '../../fields/fields.js';
-
 export const sha256 = (data: Buffer) => Buffer.from(hash.sha256().update(data).digest());
-
-/**
- * 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 const sha256ToField = (buf: Buffer): Fr => {
-  return Fr.fromBuffer(toBufferBE(toBigIntBE(sha256(buf)) % Fr.MODULUS, 32));
-};