@aztec/foundation 0.76.4 → 0.77.0-testnet-ignition.21

package/src/abi/selector.ts

@@ -1,64 +0,0 @@
-import { inspect } from 'util';
-
-import { toBufferBE } from '../bigint-buffer/index.js';
-import { Fr } from '../fields/index.js';
-import { bufferToHex } from '../string/index.js';
-
-/** A selector is the first 4 bytes of the hash of a signature. */
-export abstract class Selector {
-  /** The size of the selector in bytes. */
-  public static SIZE = 4;
-
-  constructor(/** Value of the selector */ public value: number) {
-    if (value > 2 ** (Selector.SIZE * 8) - 1) {
-      throw new Error(`Selector must fit in ${Selector.SIZE} bytes (got value ${value}).`);
-    }
-  }
-
-  /**
-   * Checks if the selector is empty (all bytes are 0).
-   * @returns True if the 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 = Selector.SIZE): Buffer {
-    return toBufferBE(BigInt(this.value), bufferSize);
-  }
-
-  /**
-   * Serialize as a hex string.
-   * @returns The string.
-   */
-  toString(): string {
-    return bufferToHex(this.toBuffer());
-  }
-
-  [inspect.custom]() {
-    return `Selector<${this.toString()}>`;
-  }
-
-  /**
-   * Checks if this selector is equal to another.
-   * @param other - The other selector.
-   * @returns True if the selectors are equal.
-   */
-  equals(other: Selector): boolean {
-    return this.value === other.value;
-  }
-
-  /**
-   * Returns a new field with the same contents as this EthAddress.
-   *
-   * @returns An Fr instance.
-   */
-  public toField() {
-    return new Fr(BigInt(this.value));
-  }
-}

package/src/abi/u128.ts

@@ -1,71 +0,0 @@
-import { Fr } from '../fields/fields.js';
-
-// A typescript version of noir::std::U128
-export class U128 {
-  private readonly value: bigint;
-
-  constructor(value: bigint | number) {
-    if (typeof value !== 'bigint') {
-      value = BigInt(value);
-    }
-
-    // Check value is within 128 bits
-    if (value < 0n || value >= 2n ** 128n) {
-      throw new Error(`Value ${value} is not within 128 bits and hence cannot be converted to U128.`);
-    }
-
-    this.value = value;
-  }
-
-  static fromU64sLE(lo: bigint, hi: bigint): U128 {
-    // Validate limbs are within valid ranges
-    if (lo < 0n || lo >= 2n ** 64n) {
-      throw new Error(`Lower limb ${lo} is not within valid range (0 to 2^64-1)`);
-    }
-    if (hi < 0n || hi >= 2n ** 64n) {
-      throw new Error(`Higher limb ${hi} is not within valid range (0 to 2^64-1)`);
-    }
-
-    // Combine limbs into full value and create new instance
-    const value = (hi << 64n) | lo;
-    return new U128(value);
-  }
-
-  get lo(): bigint {
-    return this.value & 0xffffffffffffffffn;
-  }
-
-  get hi(): bigint {
-    return this.value >> 64n;
-  }
-
-  toInteger(): bigint {
-    return this.value;
-  }
-
-  // We use little-endian ordering to match the order in which U128 defines its limbs.
-  // This is necessary because of how Noir handles serialization:
-  // - When calling a contract function from TypeScript, the serialization below gets used and then Noir
-  //   deserializes using its intrinsic serialization logic (based on the limb order in the struct).
-  // - When calling a contract function from another function, the `serialize` method is invoked
-  //   on the type first.
-  // For this reason if we didn't use the ordering of U128 limbs here and in the implementation of Serialize
-  // trait for U128 we would get an arguments hash mismatch.
-  toFields(): Fr[] {
-    return [new Fr(this.lo), new Fr(this.hi)];
-  }
-
-  // Has to follow ordering of `toFields()`
-  static fromFields(fields: Fr[]): U128 {
-    if (fields.length !== 2) {
-      throw new Error(`Expected 2 fields for U128, got ${fields.length}`);
-    }
-
-    return U128.fromU64sLE(fields[0].toBigInt(), fields[1].toBigInt());
-  }
-
-  // Has to follow ordering of `toFields()`
-  static getLimbNames(): string[] {
-    return ['lo', 'hi'];
-  }
-}

package/src/abi/utils.ts

@@ -1,86 +0,0 @@
-import { type 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 isEthAddressStruct(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 isEthAddressStruct(abiType: AbiType) {
-  return abiType.kind === 'struct' && abiType.path.endsWith('address::EthAddress');
-}
-
-/**
- * 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('address::AztecAddress');
-}
-
-/**
- * Returns whether the ABI type is an Function Selector defined in Aztec.nr.
- * @param abiType - Type to check.
- * @returns Boolean.
- */
-export function isFunctionSelectorStruct(abiType: AbiType) {
-  return abiType.kind === 'struct' && abiType.path.endsWith('types::abis::function_selector::FunctionSelector');
-}
-
-/**
- * Returns whether the ABI type is the U128 defined in noir::std.
- * @param abiType - Type to check.
- */
-export function isU128Struct(abiType: AbiType) {
-  return abiType.kind === 'struct' && abiType.path.endsWith('U128');
-}
-
-/**
- * Returns whether the ABI type is a struct with a single `inner` field.
- * @param abiType - Type to check.
- */
-export function isWrappedFieldStruct(abiType: AbiType) {
-  return (
-    abiType.kind === 'struct' &&
-    abiType.fields.length === 1 &&
-    abiType.fields[0].name === 'inner' &&
-    abiType.fields[0].type.kind === 'field'
-  );
-}
-
-/**
- * Returns a bigint by parsing a serialized 2's complement signed int.
- * @param b - The signed int as a buffer
- * @returns - a deserialized bigint
- */
-export function parseSignedInt(b: Buffer, width?: number) {
-  const buf = Buffer.from(b);
-
-  // We get the last (width / 8) bytes where width = bits of type (i64, i32 etc)
-  const slicedBuf = width !== undefined ? buf.subarray(-(width / 8)) : buf;
-
-  // Then manually deserialize with 2's complement, with the process as follows:
-
-  // If our most significant bit is high...
-  if (0x80 & slicedBuf.subarray(0, 1).readUInt8()) {
-    // We flip the bits
-    for (let i = 0; i < slicedBuf.length; i++) {
-      slicedBuf[i] = ~slicedBuf[i];
-    }
-
-    // Add one, then negate it
-    return -(BigInt(`0x${slicedBuf.toString('hex')}`) + 1n);
-  }
-
-  // ...otherwise we just return our positive int
-  return BigInt(`0x${slicedBuf.toString('hex')}`);
-}

package/src/aztec-address/index.ts

@@ -1,146 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-import { inspect } from 'util';
-
-import { Fr, Point, fromBuffer } from '../fields/index.js';
-import { hexSchemaFor } from '../schemas/utils.js';
-import { type BufferReader, FieldReader } from '../serialize/index.js';
-import { TypeRegistry } from '../serialize/type_registry.js';
-import { hexToBuffer } from '../string/index.js';
-
-/** Branding to ensure fields are not interchangeable types. */
-export interface AztecAddress {
-  /** Brand. */
-  _branding: 'AztecAddress';
-}
-/**
- * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
- * compare addresses, as well as conversion to and from strings, buffers, and other formats.
- * Addresses are the x coordinate of a point in the Grumpkin curve, and therefore their maximum is determined by the
- * field modulus. An address with a value that is not the x coordinate of a point in the curve is a called an 'invalid
- * address'. These addresses have a greatly reduced feature set, as they cannot own secrets nor have messages encrypted
- * to them, making them quite useless. We need to be able to represent them however as they can be encountered in the
- * wild.
- */
-export class AztecAddress {
-  private xCoord: Fr;
-
-  constructor(buffer: Buffer | Fr) {
-    if ('length' in buffer && buffer.length !== 32) {
-      throw new Error(`Invalid AztecAddress length ${buffer.length}.`);
-    }
-    this.xCoord = new Fr(buffer);
-  }
-
-  [inspect.custom]() {
-    return `AztecAddress<${this.toString()}>`;
-  }
-
-  static isAddress(str: string) {
-    return /^(0x)?[a-fA-F0-9]{64}$/.test(str);
-  }
-
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES;
-
-  static ZERO = new AztecAddress(Buffer.alloc(32, 0));
-
-  static zero(): AztecAddress {
-    return AztecAddress.ZERO;
-  }
-
-  static fromField(fr: Fr) {
-    return new AztecAddress(fr);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    return new AztecAddress(fromBuffer(buffer, Fr));
-  }
-
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return new AztecAddress(reader.readField());
-  }
-
-  static fromBigInt(value: bigint) {
-    return new AztecAddress(new Fr(value));
-  }
-
-  static fromNumber(value: number) {
-    return new AztecAddress(new Fr(value));
-  }
-
-  static fromString(buf: string) {
-    return new AztecAddress(hexToBuffer(buf));
-  }
-
-  /**
-   * @returns a random valid address (i.e. one that can be encrypted to).
-   */
-  static async random() {
-    // About half of random field elements result in invalid addresses, so we loop until we get a valid one.
-    while (true) {
-      const candidate = new AztecAddress(Fr.random());
-      if (await candidate.isValid()) {
-        return candidate;
-      }
-    }
-  }
-
-  get size() {
-    return this.xCoord.size;
-  }
-
-  equals(other: AztecAddress) {
-    return this.xCoord.equals(other.xCoord);
-  }
-
-  isZero() {
-    return this.xCoord.isZero();
-  }
-
-  /**
-   * @returns true if the address is valid. Invalid addresses cannot receive encrypted messages.
-   */
-  async isValid() {
-    // An address is a field value (Fr), which for some purposes is assumed to be the x coordinate of a point in the
-    // Grumpkin curve (notably in order to encrypt to it). An address that is not the x coordinate of such a point is
-    // called an 'invalid' address.
-    //
-    // For Grumpkin, y^2 = x^3 − 17 . There exist values x ∈ Fr for which no y satisfies this equation. This means that
-    // given such an x and t = x^3 − 17, then sqrt(t) does not exist in Fr.
-    return (await Point.YFromX(this.xCoord)) !== null;
-  }
-
-  /**
-   * @returns the Point from which the address is derived. Throws if the address is invalid.
-   */
-  toAddressPoint(): Promise<Point> {
-    return Point.fromXAndSign(this.xCoord, true);
-  }
-
-  toBuffer() {
-    return this.xCoord.toBuffer();
-  }
-
-  toBigInt() {
-    return this.xCoord.toBigInt();
-  }
-
-  toField() {
-    return this.xCoord;
-  }
-
-  toString() {
-    return this.xCoord.toString();
-  }
-
-  toJSON() {
-    return this.toString();
-  }
-
-  static get schema() {
-    return hexSchemaFor(AztecAddress, AztecAddress.isAddress);
-  }
-}
-
-// For deserializing JSON.
-TypeRegistry.register('AztecAddress', AztecAddress);