@aztec/foundation 0.16.4 → 0.16.5

package/src/abi/encoder.ts

@@ -1,120 +0,0 @@
-import { ABIType, FunctionAbi, isAddressStruct } from '@aztec/foundation/abi';
-
-import { Fr } from '../fields/index.js';
-
-/**
- * Encodes arguments for a function call.
- * Missing support for integer and string.
- */
-class ArgumentEncoder {
-  private flattened: Fr[] = [];
-
-  constructor(private abi: FunctionAbi, private args: any[]) {}
-
-  static typeSize(abiType: ABIType): number {
-    switch (abiType.kind) {
-      case 'field':
-      case 'boolean':
-      case 'integer':
-        return 1;
-      case 'string':
-        return abiType.length;
-      case 'array':
-        return abiType.length * ArgumentEncoder.typeSize(abiType.type);
-      case 'struct':
-        return abiType.fields.reduce((acc, field) => acc + ArgumentEncoder.typeSize(field.type), 0);
-      default: {
-        const exhaustiveCheck: never = abiType;
-        throw new Error(`Unhandled abi type: ${exhaustiveCheck}`);
-      }
-    }
-  }
-
-  /**
-   * Encodes a single argument from the given type to field.
-   * @param abiType - The abi type of the argument.
-   * @param arg - The value to encode.
-   * @param name - Name.
-   */
-  private encodeArgument(abiType: ABIType, arg: any, name?: string) {
-    if (arg === undefined || arg == null) {
-      throw new Error(`Undefined argument ${name ?? 'unnamed'} of type ${abiType.kind}`);
-    }
-    switch (abiType.kind) {
-      case 'field':
-        if (typeof arg === 'number') {
-          this.flattened.push(new Fr(BigInt(arg)));
-        } else if (typeof arg === 'bigint') {
-          this.flattened.push(new Fr(arg));
-        } else if (typeof arg === 'boolean') {
-          this.flattened.push(new Fr(arg ? 1n : 0n));
-        } else if (typeof arg === 'object') {
-          if (Buffer.isBuffer(arg)) {
-            this.flattened.push(Fr.fromBuffer(arg));
-          } else if (typeof arg.toField === 'function') {
-            this.flattened.push(arg.toField());
-          } else {
-            throw new Error(`Argument for ${name} cannot be serialized to a field`);
-          }
-        } else {
-          throw new Error(`Invalid argument "${arg}" of type ${abiType.kind}`);
-        }
-        break;
-      case 'boolean':
-        this.flattened.push(new Fr(arg ? 1n : 0n));
-        break;
-      case 'array':
-        for (let i = 0; i < abiType.length; i += 1) {
-          this.encodeArgument(abiType.type, arg[i], `${name}[${i}]`);
-        }
-        break;
-      case 'struct':
-        // If the abi expects a struct like { address: Field } and the supplied arg does not have
-        // an address field in it, we try to encode it as if it were a field directly.
-        if (isAddressStruct(abiType) && typeof arg.address === 'undefined') {
-          this.encodeArgument({ kind: 'field' }, arg, `${name}.address`);
-          break;
-        }
-        for (const field of abiType.fields) {
-          this.encodeArgument(field.type, arg[field.name], `${name}.${field.name}`);
-        }
-        break;
-      case 'integer':
-        this.flattened.push(new Fr(arg));
-        break;
-      default:
-        throw new Error(`Unsupported type: ${abiType.kind}`);
-    }
-  }
-
-  /**
-   * Encodes all the arguments for the given function ABI.
-   * @returns The encoded arguments.
-   */
-  public encode() {
-    for (let i = 0; i < this.abi.parameters.length; i += 1) {
-      const parameterAbi = this.abi.parameters[i];
-      this.encodeArgument(parameterAbi.type, this.args[i], parameterAbi.name);
-    }
-    return this.flattened;
-  }
-}
-
-/**
- * Encodes all the arguments for a function call.
- * @param abi - The function ABI entry.
- * @param args - The arguments to encode.
- * @returns The encoded arguments.
- */
-export function encodeArguments(abi: FunctionAbi, args: any[]) {
-  return new ArgumentEncoder(abi, args).encode();
-}
-
-/**
- * Returns the size of the arguments for a function ABI.
- * @param abi - The function ABI entry.
- * @returns The size of the arguments.
- */
-export function countArgumentsSize(abi: FunctionAbi) {
-  return abi.parameters.reduce((acc, parameter) => acc + ArgumentEncoder.typeSize(parameter.type), 0);
-}

package/src/abi/function_selector.ts

@@ -1,135 +0,0 @@
-import { ABIParameter, decodeFunctionSignature } from '@aztec/foundation/abi';
-import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { keccak } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader } from '@aztec/foundation/serialize';
-
-/**
- * A function selector is the first 4 bytes of the hash of a function signature.
- */
-export class FunctionSelector {
-  /**
-   * The size of the function selector in bytes.
-   */
-  public static SIZE = 4;
-
-  constructor(/** number representing the function selector */ public value: number) {
-    if (value > 2 ** (FunctionSelector.SIZE * 8) - 1) {
-      throw new Error(`Function selector must fit in ${FunctionSelector.SIZE} bytes.`);
-    }
-  }
-
-  /**
-   * Checks if the function selector is empty (all bytes are 0).
-   * @returns True if the function selector is empty (all bytes are 0).
-   */
-  public isEmpty(): boolean {
-    return this.value === 0;
-  }
-
-  /**
-   * Serialize as a buffer.
-   * @param bufferSize - The buffer size.
-   * @returns The buffer.
-   */
-  toBuffer(bufferSize = FunctionSelector.SIZE): Buffer {
-    return toBufferBE(BigInt(this.value), bufferSize);
-  }
-
-  /**
-   * Serialize as a hex string.
-   * @returns The string.
-   */
-  toString(): string {
-    return this.toBuffer().toString('hex');
-  }
-
-  /**
-   * Checks if this function selector is equal to another.
-   * @param other - The other function selector.
-   * @returns True if the function selectors are equal.
-   */
-  equals(other: FunctionSelector): boolean {
-    return this.value === other.value;
-  }
-
-  /**
-   * Deserializes from a buffer or reader, corresponding to a write in cpp.
-   * @param buffer - Buffer  or BufferReader to read from.
-   * @returns The FunctionSelector.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader): FunctionSelector {
-    const reader = BufferReader.asReader(buffer);
-    const value = Number(toBigIntBE(reader.readBytes(FunctionSelector.SIZE)));
-    return new FunctionSelector(value);
-  }
-
-  /**
-   * Returns a new field with the same contents as this EthAddress.
-   *
-   * @returns An Fr instance.
-   */
-  public toField() {
-    return new Fr(BigInt(this.value));
-  }
-
-  /**
-   * Converts a field to function selector.
-   * @param fr - The field to convert.
-   * @returns The function selector.
-   */
-  static fromField(fr: Fr): FunctionSelector {
-    return new FunctionSelector(Number(fr.toBigInt()));
-  }
-
-  /**
-   * Creates a function selector from a signature.
-   * @param signature - Signature of the function to generate the selector for (e.g. "transfer(field,field)").
-   * @returns Function selector.
-   */
-  static fromSignature(signature: string): FunctionSelector {
-    // throw if signature contains whitespace
-    if (/\s/.test(signature)) {
-      throw new Error('Function Signature cannot contain whitespace');
-    }
-    return FunctionSelector.fromBuffer(keccak(Buffer.from(signature)).subarray(0, FunctionSelector.SIZE));
-  }
-
-  /**
-   * Creates a function selector for a given function name and parameters.
-   * @param name - The name of the function.
-   * @param parameters - An array of ABIParameter objects, each containing the type information of a function parameter.
-   * @returns A Buffer containing the 4-byte function selector.
-   */
-  static fromNameAndParameters(name: string, parameters: ABIParameter[]) {
-    const signature = decodeFunctionSignature(name, parameters);
-    const selector = FunctionSelector.fromSignature(signature);
-    // If using the debug logger here it kill the typing in the `server_world_state_synchronizer` and jest tests.
-    // console.log(`Function selector for ${signature} is ${selector}`);
-    return selector;
-  }
-
-  /**
-   * 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 selector - The hex-encoded string representing the Aztec address.
-   * @returns An AztecAddress instance.
-   */
-  static fromString(selector: string) {
-    const buf = Buffer.from(selector.replace(/^0x/i, ''), 'hex');
-    if (buf.length !== FunctionSelector.SIZE) {
-      throw new Error(`Invalid length ${buf.length}.`);
-    }
-    return FunctionSelector.fromBuffer(buf);
-  }
-
-  /**
-   * Creates an empty function selector.
-   * @returns An empty function selector.
-   */
-  static empty(): FunctionSelector {
-    return new FunctionSelector(0);
-  }
-}

package/src/abi/index.ts

@@ -1,6 +0,0 @@
-export * from './abi.js';
-export * from './abi_coder.js';
-export * from './encoder.js';
-export * from './decoder.js';
-export * from './function_selector.js';
-export * from './utils.js';

package/src/abi/utils.ts

@@ -1,28 +0,0 @@
-import { ABIType } from './abi.js';
-
-/**
- * Returns whether the ABI type is an Aztec or Ethereum Address defined in Aztec.nr.
- * @param abiType - Type to check.
- * @returns Boolean.
- */
-export function isAddressStruct(abiType: ABIType) {
-  return isEthereumAddressStruct(abiType) || isAztecAddressStruct(abiType);
-}
-
-/**
- * Returns whether the ABI type is an Ethereum Address defined in Aztec.nr.
- * @param abiType - Type to check.
- * @returns Boolean.
- */
-export function isEthereumAddressStruct(abiType: ABIType) {
-  return abiType.kind === 'struct' && abiType.path.endsWith('::types::address::EthereumAddress');
-}
-
-/**
- * Returns whether the ABI type is an Aztec Address defined in Aztec.nr.
- * @param abiType - Type to check.
- * @returns Boolean.
- */
-export function isAztecAddressStruct(abiType: ABIType) {
-  return abiType.kind === 'struct' && abiType.path.endsWith('::types::address::AztecAddress');
-}

package/src/async-map/index.ts

@@ -1,18 +0,0 @@
-/**
- * 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

@@ -1,30 +0,0 @@
-import { Fr } from '../fields/index.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.
- * 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 extends Fr {
-  constructor(buffer: Buffer) {
-    if (buffer.length !== 32) {
-      throw new Error(`Invalid length ${buffer.length}.`);
-    }
-    super(buffer);
-  }
-
-  static fromField(fr: Fr) {
-    return new AztecAddress(fr.toBuffer());
-  }
-
-  static fromBigInt(value: bigint) {
-    return AztecAddress.fromField(new Fr(value));
-  }
-
-  static fromString(buf: string) {
-    const buffer = Buffer.from(buf.replace(/^0x/i, ''), 'hex');
-    return new AztecAddress(buffer);
-  }
-}

package/src/bigint-buffer/index.ts

@@ -1,74 +0,0 @@
-/**
- * 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

@@ -1,54 +0,0 @@
-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

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

package/src/committable/committable.ts

@@ -1,46 +0,0 @@
-/**
- * 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

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

package/src/crypto/index.ts

@@ -1,16 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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