@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/abi/contract_artifact.ts

@@ -1,28 +1,30 @@
 import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
 
+import {
+  AZTEC_INITIALIZER_ATTRIBUTE,
+  AZTEC_ONLY_SELF_ATTRIBUTE,
+  AZTEC_PRIVATE_ATTRIBUTE,
+  AZTEC_PUBLIC_ATTRIBUTE,
+  AZTEC_UTILITY_ATTRIBUTE,
+  AZTEC_VIEW_ATTRIBUTE,
+  type NoirCompiledContract,
+} from '../noir/index.js';
 import {
   type ABIParameter,
   type ABIParameterVisibility,
+  ARTIFACT_VERSION_BEFORE_INJECTION,
   type AbiType,
   type BasicValue,
   type ContractArtifact,
   ContractArtifactSchema,
-  type ContractNote,
   type FieldLayout,
+  type FunctionAbi,
   type FunctionArtifact,
   FunctionType,
   type IntegerValue,
   type StructValue,
   type TypedStructFieldValue,
-} from '../abi/index.js';
-import {
-  AZTEC_INITIALIZER_ATTRIBUTE,
-  AZTEC_INTERNAL_ATTRIBUTE,
-  AZTEC_PRIVATE_ATTRIBUTE,
-  AZTEC_PUBLIC_ATTRIBUTE,
-  AZTEC_VIEW_ATTRIBUTE,
-  type NoirCompiledContract,
-} from '../noir/index.js';
+} from './abi.js';
 
 /**
  * Serializes a contract artifact to a buffer for storage.
@@ -38,22 +40,37 @@ export function contractArtifactToBuffer(artifact: ContractArtifact): Buffer {
  * @param buffer - Buffer to deserialize.
  * @returns Deserialized artifact.
  */
-export function contractArtifactFromBuffer(buffer: Buffer): Promise<ContractArtifact> {
+export function contractArtifactFromBuffer(buffer: Buffer): ContractArtifact {
   return jsonParseWithSchema(buffer.toString('utf-8'), ContractArtifactSchema);
 }
 
 /**
  * Gets nargo build output and returns a valid contract artifact instance.
+ * Does not include public bytecode, apart from the public_dispatch function.
  * @param input - Input object as generated by nargo compile.
  * @returns A valid contract artifact instance.
  */
 export function loadContractArtifact(input: NoirCompiledContract): ContractArtifact {
   if (isContractArtifact(input)) {
+    // TODO(F-557): Remove this fallback once pre-version artifacts are no longer tested.
+    if (!(input as unknown as Record<string, unknown>).aztecVersion) {
+      return { ...input, aztecVersion: ARTIFACT_VERSION_BEFORE_INJECTION };
+    }
     return input;
   }
   return generateContractArtifact(input);
 }
 
+/**
+ * Gets nargo build output and returns a valid contract artifact instance.
+ * Differs from loadContractArtifact() by retaining all bytecode.
+ * @param input - Input object as generated by nargo compile.
+ * @returns A valid contract artifact instance.
+ */
+export function loadContractArtifactForPublic(input: NoirCompiledContract): ContractArtifact {
+  return generateContractArtifactForPublic(input);
+}
+
 /**
  * Checks if the given input looks like a valid ContractArtifact. The check is not exhaustive,
  * and it's just meant to differentiate between nargo raw build artifacts and the ones
@@ -79,6 +96,22 @@ function isContractArtifact(input: any): input is ContractArtifact {
     if (typeof fn.functionType !== 'string') {
       return false;
     }
+    if (!retainBytecode(fn) && fn.bytecode.length) {
+      // We want to remove the bytecode of public fns (apart from the dispatch fn) to save space
+      // If the input is private-only, we don't need to use generateContractArtifact() below
+      return false;
+    }
+  }
+  if (!Array.isArray(maybeContractArtifact.nonDispatchPublicFunctions)) {
+    return false;
+  }
+  for (const fn of maybeContractArtifact.nonDispatchPublicFunctions) {
+    if (typeof fn.name !== 'string') {
+      return false;
+    }
+    if (typeof fn.functionType !== 'string') {
+      return false;
+    }
   }
   return true;
 }
@@ -103,32 +136,38 @@ function generateFunctionParameter(param: NoirCompiledContractFunctionParameter)
 type NoirCompiledContractFunction = NoirCompiledContract['functions'][number];
 
 /**
- * Generates a function build artifact.
+ * Returns true if we should retain bytecode
+ */
+export function retainBytecode(input: NoirCompiledContractFunction | FunctionArtifact): boolean {
+  const functionType =
+    (input as FunctionArtifact).functionType ?? getFunctionType(input as NoirCompiledContractFunction);
+  return functionType !== FunctionType.PUBLIC || input.name == 'public_dispatch';
+}
+
+/**
+ * Generates a function abi.
  * @param fn - Noir function entry.
  * @param contract - Parent contract.
- * @returns Function artifact.
+ * @returns Function abi.
  */
-function generateFunctionArtifact(
-  fn: NoirCompiledContractFunction,
-  contract: NoirCompiledContract,
-): Omit<FunctionArtifact, 'bytecode'> & { bytecode: string } {
+function generateFunctionAbi(fn: NoirCompiledContractFunction, contract: NoirCompiledContract): FunctionAbi {
   if (fn.custom_attributes === undefined) {
     throw new Error(
       `No custom attributes found for contract function ${fn.name}. Try rebuilding the contract with the latest nargo version.`,
     );
   }
   const functionType = getFunctionType(fn);
-  const isInternal = fn.custom_attributes.includes(AZTEC_INTERNAL_ATTRIBUTE);
+  const isOnlySelf = fn.custom_attributes.includes(AZTEC_ONLY_SELF_ATTRIBUTE);
   const isStatic = fn.custom_attributes.includes(AZTEC_VIEW_ATTRIBUTE);
 
-  // If the function is not unconstrained, the first item is inputs or CallContext which we should omit
+  // If the function is not a utility function, the first item is inputs or CallContext which we should omit
   let parameters = fn.abi.parameters.map(generateFunctionParameter);
   if (hasKernelFunctionInputs(parameters)) {
     parameters = parameters.slice(1);
   }
 
   let returnTypes: AbiType[] = [];
-  if (functionType === FunctionType.UNCONSTRAINED) {
+  if (functionType === FunctionType.UTILITY) {
     returnTypes = fn.abi.return_type ? [fn.abi.return_type.abi_type] : returnTypes;
   } else {
     const pathToFind = `${contract.name}::${fn.name}_abi`;
@@ -151,15 +190,31 @@ function generateFunctionArtifact(
   return {
     name: fn.name,
     functionType,
-    isInternal,
+    isOnlySelf,
     isStatic,
     isInitializer: fn.custom_attributes.includes(AZTEC_INITIALIZER_ATTRIBUTE),
     parameters,
     returnTypes,
-    bytecode: fn.bytecode,
-    debugSymbols: fn.debug_symbols,
     errorTypes: fn.abi.error_types,
     ...(fn.assert_messages ? { assertMessages: fn.assert_messages } : undefined),
+  };
+}
+
+/**
+ * Generates a function build artifact.
+ * @param fn - Noir function entry.
+ * @param contract - Parent contract.
+ * @returns Function artifact.
+ */
+function generateFunctionArtifact(
+  fn: NoirCompiledContractFunction,
+  contract: NoirCompiledContract,
+): Omit<FunctionArtifact, 'bytecode'> & { bytecode: string } {
+  const abi = generateFunctionAbi(fn, contract);
+  return {
+    ...abi,
+    bytecode: fn.bytecode,
+    debugSymbols: fn.debug_symbols,
     ...(fn.verification_key ? { verificationKey: fn.verification_key } : undefined),
   };
 }
@@ -169,11 +224,10 @@ function getFunctionType(fn: NoirCompiledContractFunction): FunctionType {
     return FunctionType.PRIVATE;
   } else if (fn.custom_attributes.includes(AZTEC_PUBLIC_ATTRIBUTE)) {
     return FunctionType.PUBLIC;
-  } else if (fn.is_unconstrained) {
-    return FunctionType.UNCONSTRAINED;
+  } else if (fn.custom_attributes.includes(AZTEC_UTILITY_ATTRIBUTE)) {
+    return FunctionType.UTILITY;
   } else {
-    // Default to a private function (see simple_macro_example_expanded for an example of this behavior)
-    return FunctionType.PRIVATE;
+    throw new Error(`Invalid function type for a noir contract function ${fn.name}`);
   }
 }
 
@@ -227,66 +281,48 @@ function getStorageLayout(input: NoirCompiledContract) {
 }
 
 /**
- * Generates records of the notes with note type ids of the artifact.
- * @param input - The compiled noir contract to get note types for
- * @return A record of the note types and their ids
+ * Given a post-processed Nargo output defined as `contract` generates an Aztec-compatible contract artifact.
+ *
+ * Does not include public bytecode, apart from the public_dispatch function.
  */
-function getNoteTypes(input: NoirCompiledContract) {
-  // The type is useless here as it does not give us any guarantee (e.g. `AbiValue` can be one of many different
-  // types) so we nuke it and later we manually check the values are as we expect.
-  const notes = input.outputs.globals.notes as any[];
-
-  if (!notes) {
-    return {};
-  }
-
-  return notes.reduce((acc: Record<string, Omit<ContractNote, 'id'> & { id: string }>, note) => {
-    const noteFields = note.fields;
-
-    // We find note type id by looking for respective kinds as each of them is unique
-    const rawNoteTypeId = noteFields.find((field: any) => field.kind === 'integer');
-    const rawName = noteFields.find((field: any) => field.kind === 'string');
-    const rawNoteFields = noteFields.find((field: any) => field.kind === 'struct');
-
-    if (!rawNoteTypeId || !rawName || !rawNoteFields) {
-      throw new Error(`Could not find note type id, name or fields for note ${note}`);
+function generateContractArtifact(contract: NoirCompiledContract): ContractArtifact {
+  try {
+    if (!contract.transpiled) {
+      throw new Error("Contract's public bytecode has not been transpiled");
     }
-
-    const noteTypeId = rawNoteTypeId.value as string;
-    const name = rawName.value as string;
-
-    // Note type id is encoded as a hex string
-    const fields = rawNoteFields.fields.map((field: any) => {
-      return {
-        name: field.name,
-        index: parseInt(field.value.fields[0].value.value, 16),
-        nullable: field.value.fields[1].value.value,
-      };
+    return ContractArtifactSchema.parse({
+      name: contract.name,
+      aztecVersion: contract.aztec_version,
+      functions: contract.functions.filter(f => retainBytecode(f)).map(f => generateFunctionArtifact(f, contract)),
+      nonDispatchPublicFunctions: contract.functions
+        .filter(f => !retainBytecode(f))
+        .map(f => generateFunctionAbi(f, contract)),
+      outputs: contract.outputs,
+      storageLayout: getStorageLayout(contract),
+      fileMap: contract.file_map,
     });
-    acc[name] = {
-      id: noteTypeId,
-      typ: name,
-      fields,
-    };
-    return acc;
-  }, {});
+  } catch (err) {
+    throw new Error(`Could not generate contract artifact for ${contract.name}: ${err}`);
+  }
 }
 
 /**
- * Given a Nargo output generates an Aztec-compatible contract artifact.
- * @param compiled - Noir build output.
- * @returns Aztec contract build artifact.
+ * Given a post-processed Nargo output defined as `contract` generates an Aztec-compatible contract artifact.
+ *
+ * Retains all public bytecode.
  */
-function generateContractArtifact(contract: NoirCompiledContract, aztecNrVersion?: string): ContractArtifact {
+function generateContractArtifactForPublic(contract: NoirCompiledContract): ContractArtifact {
   try {
     return ContractArtifactSchema.parse({
       name: contract.name,
+      aztecVersion: contract.aztec_version,
       functions: contract.functions.map(f => generateFunctionArtifact(f, contract)),
+      nonDispatchPublicFunctions: contract.functions
+        .filter(f => !retainBytecode(f))
+        .map(f => generateFunctionAbi(f, contract)),
       outputs: contract.outputs,
       storageLayout: getStorageLayout(contract),
-      notes: getNoteTypes(contract),
       fileMap: contract.file_map,
-      ...(aztecNrVersion ? { aztecNrVersion } : {}),
     });
   } catch (err) {
     throw new Error(`Could not generate contract artifact for ${contract.name}: ${err}`);

package/src/abi/decoder.ts

@@ -1,19 +1,41 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import type { ABIParameter, ABIVariable, AbiType } from './abi.js';
-import { isAztecAddressStruct, parseSignedInt } from './utils.js';
+import type { AbiType } from './abi.js';
+import { FunctionSelector } from './function_selector.js';
+import {
+  isAztecAddressStruct,
+  isEthAddressStruct,
+  isFunctionSelectorStruct,
+  isOptionStruct,
+  isWrappedFieldStruct,
+  parseSignedInt,
+} from './utils.js';
 
 /**
  * The type of our decoded ABI.
  */
-export type AbiDecoded = bigint | boolean | AztecAddress | AbiDecoded[] | { [key: string]: AbiDecoded };
+export type AbiDecoded =
+  | bigint
+  | boolean
+  | string
+  | AztecAddress
+  | EthAddress
+  | FunctionSelector
+  | Fr
+  | AbiDecoded[]
+  | { [key: string]: AbiDecoded }
+  | undefined;
 
 /**
  * Decodes values using a provided ABI.
  */
 class AbiDecoder {
-  constructor(private types: AbiType[], private flattened: Fr[]) {}
+  constructor(
+    private types: AbiType[],
+    private flattened: Fr[],
+  ) {}
 
   /**
    * Decodes a single return value from field to the given type.
@@ -48,6 +70,20 @@ class AbiDecoder {
         if (isAztecAddressStruct(abiType)) {
           return new AztecAddress(this.getNextField().toBuffer());
         }
+        if (isEthAddressStruct(abiType)) {
+          return EthAddress.fromField(this.getNextField());
+        }
+        if (isFunctionSelectorStruct(abiType)) {
+          return FunctionSelector.fromField(this.getNextField());
+        }
+        if (isWrappedFieldStruct(abiType)) {
+          return this.getNextField();
+        }
+        if (isOptionStruct(abiType)) {
+          const isSome = this.decodeNext(abiType.fields[0].type);
+          const value = this.decodeNext(abiType.fields[1].type);
+          return isSome ? value : undefined;
+        }
 
         for (const field of abiType.fields) {
           struct[field.name] = this.decodeNext(field.type);
@@ -55,11 +91,12 @@ class AbiDecoder {
         return struct;
       }
       case 'string': {
-        const array = [];
+        let str = '';
         for (let i = 0; i < abiType.length; i += 1) {
-          array.push(this.getNextField().toBigInt());
+          const charCode = Number(this.getNextField().toBigInt());
+          str += String.fromCharCode(charCode);
         }
-        return array;
+        return str;
       }
       case 'tuple': {
         const array = [];
@@ -91,13 +128,10 @@ class AbiDecoder {
    * @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 [];
+    if (this.types.length === 1) {
+      return this.decodeNext(this.types[0]);
     }
-    return this.decodeNext(this.types[0]);
+    return this.types.map(type => this.decodeNext(type));
   }
 }
 
@@ -110,78 +144,3 @@ class AbiDecoder {
 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();
-}