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

package/src/abi/decoder.ts

@@ -1,195 +0,0 @@
-import { AztecAddress } from '../aztec-address/index.js';
-import { Fr } from '../fields/index.js';
-import { type ABIParameter, type ABIVariable, type AbiType } from './abi.js';
-import { U128 } from './u128.js';
-import { isAztecAddressStruct, isU128Struct, parseSignedInt } from './utils.js';
-
-/**
- * The type of our decoded ABI.
- */
-export type AbiDecoded = bigint | boolean | AztecAddress | AbiDecoded[] | { [key: string]: AbiDecoded };
-
-/**
- * Decodes values using a provided ABI.
- */
-class AbiDecoder {
-  constructor(private types: AbiType[], private flattened: Fr[]) {}
-
-  /**
-   * Decodes a single return value from field to the given type.
-   * @param abiType - The type of the return value.
-   * @returns The decoded return value.
-   */
-  private decodeNext(abiType: AbiType): AbiDecoded {
-    switch (abiType.kind) {
-      case 'field':
-        return this.getNextField().toBigInt();
-      case 'integer': {
-        const nextField = this.getNextField();
-
-        if (abiType.sign === 'signed') {
-          // We parse the buffer using 2's complement
-          return parseSignedInt(nextField.toBuffer(), abiType.width);
-        }
-
-        return nextField.toBigInt();
-      }
-      case 'boolean':
-        return !this.getNextField().isZero();
-      case 'array': {
-        const array = [];
-        for (let i = 0; i < abiType.length; i += 1) {
-          array.push(this.decodeNext(abiType.type));
-        }
-        return array;
-      }
-      case 'struct': {
-        if (isU128Struct(abiType)) {
-          const fields = [
-            new Fr(this.decodeNext({ kind: 'field' }) as bigint),
-            new Fr(this.decodeNext({ kind: 'field' }) as bigint),
-          ];
-          return U128.fromFields(fields).toInteger();
-        }
-
-        const struct: { [key: string]: AbiDecoded } = {};
-        if (isAztecAddressStruct(abiType)) {
-          return new AztecAddress(this.getNextField().toBuffer());
-        }
-
-        for (const field of abiType.fields) {
-          struct[field.name] = this.decodeNext(field.type);
-        }
-        return struct;
-      }
-      case 'string': {
-        const array = [];
-        for (let i = 0; i < abiType.length; i += 1) {
-          array.push(this.getNextField().toBigInt());
-        }
-        return array;
-      }
-      case 'tuple': {
-        const array = [];
-        for (const tupleAbiType of abiType.fields) {
-          array.push(this.decodeNext(tupleAbiType));
-        }
-        return array;
-      }
-      default:
-        throw new Error(`Unsupported type: ${abiType}`);
-    }
-  }
-
-  /**
-   * Gets the next field in the flattened buffer.
-   * @returns The next field in the flattened buffer.
-   */
-  private getNextField(): Fr {
-    const field = this.flattened.shift();
-    if (!field) {
-      throw new Error('Not enough return values');
-    }
-    return field;
-  }
-
-  /**
-   * Decodes all the values for the given ABI.
-   * The decided value can be simple types, structs or arrays
-   * @returns The decoded return values.
-   */
-  public decode(): AbiDecoded {
-    if (this.types.length > 1) {
-      throw new Error('Multiple types not supported');
-    }
-    if (this.types.length === 0) {
-      return [];
-    }
-    return this.decodeNext(this.types[0]);
-  }
-}
-
-/**
- * Decodes values in a flattened Field array using a provided ABI.
- * @param abi - The ABI to use as reference.
- * @param buffer - The flattened Field array to decode.
- * @returns
- */
-export function decodeFromAbi(typ: AbiType[], buffer: Fr[]) {
-  return new AbiDecoder(typ, buffer.slice()).decode();
-}
-
-/**
- * Decodes the signature of a function from the name and parameters.
- */
-export class FunctionSignatureDecoder {
-  private separator: string;
-  constructor(private name: string, private parameters: ABIParameter[], private includeNames = false) {
-    this.separator = includeNames ? ', ' : ',';
-  }
-
-  /**
-   * Decodes a single function parameter type for the function signature.
-   * @param param - The parameter type to decode.
-   * @returns A string representing the parameter type.
-   */
-  private getParameterType(param: AbiType): string {
-    switch (param.kind) {
-      case 'field':
-        return 'Field';
-      case 'integer':
-        if (param.sign === 'signed') {
-          throw new Error('Unsupported type: signed integer');
-        }
-        return `u${param.width}`;
-      case 'boolean':
-        return 'bool';
-      case 'array':
-        return `[${this.getParameterType(param.type)};${param.length}]`;
-      case 'string':
-        return `str<${param.length}>`;
-      case 'struct':
-        return `(${param.fields.map(field => `${this.decodeParameter(field)}`).join(this.separator)})`;
-      default:
-        throw new Error(`Unsupported type: ${param}`);
-    }
-  }
-
-  /**
-   * Decodes a single function parameter for the function signature.
-   * @param param - The parameter to decode.
-   * @returns A string representing the parameter type and optionally its name.
-   */
-  private decodeParameter(param: ABIVariable): string {
-    const type = this.getParameterType(param.type);
-    return this.includeNames ? `${param.name}: ${type}` : type;
-  }
-
-  /**
-   * Decodes all the parameters and build the function signature
-   * @returns The function signature.
-   */
-  public decode(): string {
-    return `${this.name}(${this.parameters.map(param => this.decodeParameter(param)).join(this.separator)})`;
-  }
-}
-
-/**
- * Decodes a function signature from the name and parameters.
- * @param name - The name of the function.
- * @param parameters - The parameters of the function.
- * @returns - The function signature.
- */
-export function decodeFunctionSignature(name: string, parameters: ABIParameter[]) {
-  return new FunctionSignatureDecoder(name, parameters).decode();
-}
-
-/**
- * Decodes a function signature from the name and parameters including parameter names.
- * @param name - The name of the function.
- * @param parameters - The parameters of the function.
- * @returns - The user-friendly function signature.
- */
-export function decodeFunctionSignatureWithParameterNames(name: string, parameters: ABIParameter[]) {
-  return new FunctionSignatureDecoder(name, parameters, true).decode();
-}

package/src/abi/encoder.ts

@@ -1,170 +0,0 @@
-import { Fr } from '../fields/index.js';
-import { type AbiType, type FunctionAbi } from './abi.js';
-import { U128 } from './u128.js';
-import { isAddressStruct, isFunctionSelectorStruct, isU128Struct, isWrappedFieldStruct } from './utils.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);
-      case 'tuple':
-        return abiType.fields.reduce((acc, field) => acc + ArgumentEncoder.typeSize(field), 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 === 'string') {
-          this.flattened.push(Fr.fromString(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 if (typeof arg.value === 'string') {
-            this.flattened.push(Fr.fromHexString(arg.value));
-          } 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 'string':
-        for (let i = 0; i < abiType.length; i += 1) {
-          // If the string is shorter than the defined length, pad it with 0s.
-          const toInsert = i < arg.length ? BigInt((arg as string).charCodeAt(i)) : 0n;
-          this.flattened.push(new Fr(toInsert));
-        }
-        break;
-      case 'struct': {
-        // If the type defines the encoding to noir, we use it
-        if (arg.encodeToNoir !== undefined) {
-          this.flattened.push(...arg.encodeToNoir());
-          break;
-        }
-
-        // 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.
-        const isAddress = isAddressStruct(abiType);
-        if (isAddress && typeof arg.address === 'undefined' && typeof arg.inner === 'undefined') {
-          this.encodeArgument({ kind: 'field' }, arg, `${name}.inner`);
-          break;
-        }
-        // Or if the supplied argument does have an address field in it, like a CompleteAddress,
-        // we encode it directly as a field.
-        if (isAddress && typeof arg.address !== 'undefined') {
-          this.encodeArgument({ kind: 'field' }, arg.address, `${name}.address`);
-          break;
-        }
-        if (isFunctionSelectorStruct(abiType)) {
-          this.encodeArgument({ kind: 'integer', sign: 'unsigned', width: 32 }, arg.value ?? arg, `${name}.inner`);
-          break;
-        }
-        if (isU128Struct(abiType)) {
-          // U128 struct has low and high limbs - so we first convert the value to the 2 limbs and then we encode them
-          const value = new U128(arg);
-          const limbs = value.toFields();
-          const limbNames = U128.getLimbNames();
-          this.encodeArgument({ kind: 'field' }, limbs[0], `${name}.${limbNames[0]}`);
-          this.encodeArgument({ kind: 'field' }, limbs[1], `${name}.${limbNames[1]}`);
-          break;
-        }
-        if (isWrappedFieldStruct(abiType)) {
-          this.encodeArgument({ kind: 'field' }, arg.inner ?? arg, `${name}.inner`);
-          break;
-        }
-        for (const field of abiType.fields) {
-          this.encodeArgument(field.type, arg[field.name], `${name}.${field.name}`);
-        }
-        break;
-      }
-      case 'integer':
-        if (typeof arg === 'string') {
-          const value = BigInt(arg);
-          this.flattened.push(new Fr(value));
-        } else {
-          this.flattened.push(new Fr(arg));
-        }
-        break;
-      default:
-        throw new Error(`Unsupported type: ${abiType}`);
-    }
-  }
-
-  /**
-   * 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/event_selector.ts

@@ -1,92 +0,0 @@
-import { fromHex, toBigIntBE } from '../bigint-buffer/index.js';
-import { poseidon2HashBytes, randomBytes } from '../crypto/index.js';
-import { type Fr } from '../fields/fields.js';
-import { hexSchemaFor } from '../schemas/utils.js';
-import { BufferReader } from '../serialize/buffer_reader.js';
-import { Selector } from './selector.js';
-
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Event selector branding */
-export interface EventSelector {
-  /** Brand. */
-  _branding: 'EventSelector';
-}
-
-/** An event selector is the first 4 bytes of the hash of an event signature. */
-export class EventSelector extends Selector {
-  /**
-   * Deserializes from a buffer or reader, corresponding to a write in cpp.
-   * @param buffer - Buffer  or BufferReader to read from.
-   * @returns The Selector.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    const value = Number(toBigIntBE(reader.readBytes(Selector.SIZE)));
-    return new EventSelector(value);
-  }
-
-  /**
-   * Converts a field to selector.
-   * @param fr - The field to convert.
-   * @returns The selector.
-   */
-  static fromField(fr: Fr) {
-    return new EventSelector(Number(fr.toBigInt()));
-  }
-
-  /**
-   * Creates a selector from a signature.
-   * @param signature - Signature to generate the selector for (e.g. "transfer(field,field)").
-   * @returns selector.
-   */
-  static async fromSignature(signature: string) {
-    // throw if signature contains whitespace
-    if (/\s/.test(signature)) {
-      throw new Error('Signature cannot contain whitespace');
-    }
-    const hash = await poseidon2HashBytes(Buffer.from(signature));
-    // We take the last Selector.SIZE big endian bytes
-    const bytes = hash.toBuffer().slice(-Selector.SIZE);
-    return EventSelector.fromBuffer(bytes);
-  }
-
-  /**
-   * Create a Selector instance from a hex-encoded string.
-   *
-   * @param selector - The hex-encoded string representing the Selector.
-   * @returns An Selector instance.
-   * @throws If the selector length is invalid.
-   */
-  static fromString(selector: string) {
-    const buf = fromHex(selector);
-    if (buf.length !== Selector.SIZE) {
-      throw new Error(`Invalid EventSelector length ${buf.length} (expected ${Selector.SIZE}).`);
-    }
-    return EventSelector.fromBuffer(buf);
-  }
-
-  /**
-   * Creates an empty selector.
-   * @returns An empty selector.
-   */
-  static empty() {
-    return new EventSelector(0);
-  }
-
-  /**
-   * Creates a random selector.
-   * @returns A random selector.
-   */
-  static random() {
-    return EventSelector.fromBuffer(randomBytes(Selector.SIZE));
-  }
-
-  toJSON() {
-    return this.toString();
-  }
-
-  static get schema() {
-    return hexSchemaFor(EventSelector);
-  }
-}

package/src/abi/function_selector.ts

@@ -1,124 +0,0 @@
-import { fromHex, toBigIntBE } from '../bigint-buffer/index.js';
-import { poseidon2HashBytes, randomBytes } from '../crypto/index.js';
-import { type Fr } from '../fields/fields.js';
-import { hexSchemaFor } from '../schemas/utils.js';
-import { BufferReader } from '../serialize/buffer_reader.js';
-import { FieldReader } from '../serialize/field_reader.js';
-import { TypeRegistry } from '../serialize/type_registry.js';
-import { type ABIParameter } from './abi.js';
-import { decodeFunctionSignature } from './decoder.js';
-import { Selector } from './selector.js';
-
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Function selector branding */
-export interface FunctionSelector {
-  /** Brand. */
-  _branding: 'FunctionSelector';
-}
-
-/** A function selector is the first 4 bytes of the hash of a function signature. */
-export class FunctionSelector extends Selector {
-  /**
-   * Deserializes from a buffer or reader, corresponding to a write in cpp.
-   * @param buffer - Buffer  or BufferReader to read from.
-   * @returns The Selector.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    const value = Number(toBigIntBE(reader.readBytes(Selector.SIZE)));
-    return new FunctionSelector(value);
-  }
-
-  /**
-   * Converts a field to selector.
-   * @param fr - The field to convert.
-   * @returns The selector.
-   */
-  static fromField(fr: Fr) {
-    return new FunctionSelector(Number(fr.toBigInt()));
-  }
-
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return FunctionSelector.fromField(reader.readField());
-  }
-
-  /**
-   * Creates a selector from a signature.
-   * @param signature - Signature to generate the selector for (e.g. "transfer(field,field)").
-   * @returns selector.
-   */
-  static async fromSignature(signature: string) {
-    // throw if signature contains whitespace
-    if (/\s/.test(signature)) {
-      throw new Error('Signature cannot contain whitespace');
-    }
-    const hash = await poseidon2HashBytes(Buffer.from(signature));
-    // We take the last Selector.SIZE big endian bytes
-    const bytes = hash.toBuffer().slice(-Selector.SIZE);
-    return FunctionSelector.fromBuffer(bytes);
-  }
-
-  /**
-   * Create a Selector instance from a hex-encoded string.
-   *
-   * @param selector - The hex-encoded string representing the Selector.
-   * @returns An Selector instance.
-   * @throws If the selector length is invalid.
-   */
-  static fromString(selector: string) {
-    const buf = fromHex(selector);
-    if (buf.length !== Selector.SIZE) {
-      throw new Error(`Invalid FunctionSelector length ${buf.length} (expected ${Selector.SIZE}).`);
-    }
-    return FunctionSelector.fromBuffer(buf);
-  }
-
-  /**
-   * Creates an empty selector.
-   * @returns An empty selector.
-   */
-  static empty() {
-    return new FunctionSelector(0);
-  }
-
-  /**
-   * 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 selector.
-   */
-  static fromNameAndParameters(args: { name: string; parameters: ABIParameter[] }): Promise<FunctionSelector>;
-  static fromNameAndParameters(name: string, parameters: ABIParameter[]): Promise<FunctionSelector>;
-  static async fromNameAndParameters(
-    nameOrArgs: string | { name: string; parameters: ABIParameter[] },
-    maybeParameters?: ABIParameter[],
-  ): Promise<FunctionSelector> {
-    const { name, parameters } =
-      typeof nameOrArgs === 'string' ? { name: nameOrArgs, parameters: maybeParameters! } : nameOrArgs;
-    const signature = decodeFunctionSignature(name, parameters);
-    const selector = await this.fromSignature(signature);
-    // If using the debug logger here it kill the typing in the `server_world_state_synchronizer` and jest tests.
-    // console.log(`selector for ${signature} is ${selector}`);
-    return selector;
-  }
-
-  /**
-   * Creates a random instance.
-   */
-  static random() {
-    return FunctionSelector.fromBuffer(randomBytes(Selector.SIZE));
-  }
-
-  toJSON() {
-    return this.toString();
-  }
-
-  static get schema() {
-    return hexSchemaFor(FunctionSelector);
-  }
-}
-
-// For deserializing JSON.
-TypeRegistry.register('FunctionSelector', FunctionSelector);

package/src/abi/index.ts

@@ -1,9 +0,0 @@
-export * from './abi.js';
-export * from './buffer.js';
-export * from './decoder.js';
-export * from './encoder.js';
-export * from './event_selector.js';
-export * from './function_selector.js';
-export * from './note_selector.js';
-export * from './utils.js';
-export * from './u128.js';

package/src/abi/note_selector.ts

@@ -1,78 +0,0 @@
-import { toBigIntBE } from '../bigint-buffer/index.js';
-import { randomInt } from '../crypto/index.js';
-import { Fr } from '../fields/fields.js';
-import { hexSchemaFor } from '../schemas/utils.js';
-import { BufferReader } from '../serialize/buffer_reader.js';
-import { TypeRegistry } from '../serialize/type_registry.js';
-import { Selector } from './selector.js';
-
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Note selector branding */
-export interface NoteSelector {
-  /** Brand. */
-  _branding: 'NoteSelector';
-}
-
-/**
- * A note selector is a 7 bit long value that identifies a note type within a contract.
- * TODO(#10952): Encoding of note type id can be reduced to 7 bits.
- */
-export class NoteSelector extends Selector {
-  /**
-   * Deserializes from a buffer or reader, corresponding to a write in cpp.
-   * @param buffer - Buffer  or BufferReader to read from.
-   * @returns The Selector.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    const value = Number(toBigIntBE(reader.readBytes(Selector.SIZE)));
-    if (value >= 1 << 7) {
-      throw new Error(`Invalid note selector: ${value}`);
-    }
-    return new NoteSelector(value);
-  }
-
-  static fromString(buf: string) {
-    const withoutPrefix = buf.replace(/^0x/i, '').slice(-8);
-    const buffer = Buffer.from(withoutPrefix, 'hex');
-    return NoteSelector.fromBuffer(buffer);
-  }
-
-  /**
-   * Converts a field to selector.
-   * @param fr - The field to convert.
-   * @returns The selector.
-   */
-  static fromField(fr: Fr) {
-    return new NoteSelector(Number(fr.toBigInt()));
-  }
-
-  /**
-   * Creates an empty selector.
-   * @returns An empty selector.
-   */
-  static empty() {
-    return new NoteSelector(0);
-  }
-
-  /**
-   * Creates a random selector.
-   * @returns A random selector.
-   */
-  static random() {
-    const value = randomInt(1 << 7);
-    return NoteSelector.fromField(new Fr(value));
-  }
-
-  toJSON() {
-    return this.toString();
-  }
-
-  static get schema() {
-    return hexSchemaFor(NoteSelector);
-  }
-}
-
-// For deserializing JSON.
-TypeRegistry.register('NoteSelector', NoteSelector);