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

package/src/abi/contract_artifact.ts

@@ -7,8 +7,8 @@ import {
   type BasicValue,
   type ContractArtifact,
   ContractArtifactSchema,
-  type ContractNote,
   type FieldLayout,
+  type FunctionAbi,
   type FunctionArtifact,
   FunctionType,
   type IntegerValue,
@@ -20,6 +20,7 @@ import {
   AZTEC_INTERNAL_ATTRIBUTE,
   AZTEC_PRIVATE_ATTRIBUTE,
   AZTEC_PUBLIC_ATTRIBUTE,
+  AZTEC_UTILITY_ATTRIBUTE,
   AZTEC_VIEW_ATTRIBUTE,
   type NoirCompiledContract,
 } from '../noir/index.js';
@@ -38,12 +39,13 @@ 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.
  */
@@ -54,6 +56,16 @@ export function loadContractArtifact(input: NoirCompiledContract): ContractArtif
   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 +91,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,15 +131,21 @@ 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.`,
@@ -121,14 +155,14 @@ function generateFunctionArtifact(
   const isInternal = fn.custom_attributes.includes(AZTEC_INTERNAL_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`;
@@ -156,10 +190,26 @@ function generateFunctionArtifact(
     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 +219,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 +276,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 Nargo output generates an Aztec-compatible contract artifact.
+ * Does not include public bytecode, apart from the public_dispatch function.
+ * @param compiled - Noir build output.
+ * @returns Aztec contract build artifact.
  */
-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,
+      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.
+ * Retains all public bytecode.
  * @param compiled - Noir build output.
  * @returns Aztec contract build artifact.
  */
-function generateContractArtifact(contract: NoirCompiledContract, aztecNrVersion?: string): ContractArtifact {
+function generateContractArtifactForPublic(contract: NoirCompiledContract): ContractArtifact {
   try {
     return ContractArtifactSchema.parse({
       name: contract.name,
       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

@@ -7,13 +7,16 @@ import { isAztecAddressStruct, 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 | AbiDecoded[] | { [key: string]: AbiDecoded };
 
 /**
  * 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.
@@ -55,11 +58,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 +95,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));
   }
 }
 
@@ -116,7 +117,11 @@ export function decodeFromAbi(typ: AbiType[], buffer: Fr[]) {
  */
 export class FunctionSignatureDecoder {
   private separator: string;
-  constructor(private name: string, private parameters: ABIParameter[], private includeNames = false) {
+  constructor(
+    private name: string,
+    private parameters: ABIParameter[],
+    private includeNames = false,
+  ) {
     this.separator = includeNames ? ', ' : ',';
   }
 
@@ -143,7 +148,7 @@ export class FunctionSignatureDecoder {
       case 'struct':
         return `(${param.fields.map(field => `${this.decodeParameter(field)}`).join(this.separator)})`;
       default:
-        throw new Error(`Unsupported type: ${param}`);
+        throw new Error(`Unsupported type: ${param.kind}`);
     }
   }
 

package/src/abi/encoder.ts

@@ -1,7 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 
 import type { AbiType, FunctionAbi } from './abi.js';
-import { isAddressStruct, isFunctionSelectorStruct, isWrappedFieldStruct } from './utils.js';
+import { isAddressStruct, isBoundedVecStruct, isFunctionSelectorStruct, isWrappedFieldStruct } from './utils.js';
 
 /**
  * Encodes arguments for a function call.
@@ -10,7 +10,10 @@ import { isAddressStruct, isFunctionSelectorStruct, isWrappedFieldStruct } from
 class ArgumentEncoder {
   private flattened: Fr[] = [];
 
-  constructor(private abi: FunctionAbi, private args: any[]) {}
+  constructor(
+    private abi: FunctionAbi,
+    private args: any[],
+  ) {}
 
   static typeSize(abiType: AbiType): number {
     switch (abiType.kind) {
@@ -110,6 +113,11 @@ class ArgumentEncoder {
           this.encodeArgument({ kind: 'field' }, arg.inner ?? arg, `${name}.inner`);
           break;
         }
+        if (isBoundedVecStruct(abiType)) {
+          this.#encodeBoundedVec(abiType, arg, name);
+          break;
+        }
+
         for (const field of abiType.fields) {
           this.encodeArgument(field.type, arg[field.name], `${name}.${field.name}`);
         }
@@ -124,7 +132,7 @@ class ArgumentEncoder {
         }
         break;
       default:
-        throw new Error(`Unsupported type: ${abiType}`);
+        throw new Error(`Unsupported type: ${abiType.kind}`);
     }
   }
 
@@ -139,6 +147,83 @@ class ArgumentEncoder {
     }
     return this.flattened;
   }
+
+  /**
+   * Encodes an array as a BoundedVec struct.
+   * @dev BoundedVec is handled as a special case rather than a generic struct for two reasons:
+   * 1. It is a commonly used type
+   * 2. Manual encoding it is cumbersome
+   * Therefore, the input is simplified to accept a plain array of type T.
+   * @param abiType - The ABI type definition.
+   * @param arg - An array of items to encode.
+   * @param name - The name of the parameter.
+   *
+   * The BoundedVec struct is defined in Noir as:
+   *
+   * ```noir
+   * pub struct BoundedVec<T, let MaxLen: u32> {
+   *   storage: [T; MaxLen],
+   *   len: u32,
+   * }
+   * ```
+   *
+   * The encoding follows Noir's serialization format:
+   * 1. The storage array is encoded first
+   * 2. The length field is encoded second
+   */
+  #encodeBoundedVec(abiType: AbiType, arg: any, name?: string) {
+    // First we encode the storage array
+    {
+      // Get the storage array type from the BoundedVec struct
+      const storageField = (abiType as unknown as any).fields.find((f: any) => f.name === 'storage')!;
+      const maxLength = storageField.type.length;
+
+      if (arg.length > maxLength) {
+        // Create a preview of the array for the error message, limiting to first few elements
+        const preview = arg
+          .slice(0, 3)
+          .map((x: any) => {
+            if (typeof x === 'object' && x !== null) {
+              if (Array.isArray(x)) {
+                return `[${x.join(', ')}]`;
+              }
+              // Convert object to string representation of its key-value pairs
+              return `{${Object.entries(x)
+                .map(([k, v]) => `${k}: ${v}`)
+                .join(', ')}}`;
+            }
+            return `${x}`;
+          })
+          .join(', ');
+        const suffix = arg.length > 3 ? ', ...' : '';
+        throw new Error(
+          `Error encoding param '${name ?? 'unnamed'}': ` +
+            `expected an array of maximum length ${maxLength} and got ${arg.length} instead: [ ${preview}${suffix} ]`,
+        );
+      }
+
+      const storageArrayItemType = storageField.type.type;
+
+      // Now we encode each item in the input array
+      for (let i = 0; i < arg.length; i++) {
+        this.encodeArgument(storageArrayItemType, arg[i], `storage[${i}]`);
+      }
+
+      // Then we pad the storage array with zeros such that the BoundedVec max length is correct.
+      const numItemsToPad = maxLength - arg.length;
+      if (numItemsToPad > 0) {
+        const numFieldsToPad = numItemsToPad * ArgumentEncoder.typeSize(storageArrayItemType);
+        const paddingFields = new Array(numFieldsToPad).fill(Fr.ZERO);
+        this.flattened.push(...paddingFields);
+      }
+    }
+
+    // At last we encode the length field
+    {
+      const lenField = (abiType as unknown as any).fields.find((f: any) => f.name === 'len')!;
+      this.encodeArgument(lenField.type, arg.length, 'len');
+    }
+  }
 }
 
 /**

package/src/abi/event_metadata_definition.ts

@@ -0,0 +1,8 @@
+import type { AbiType } from './abi.js';
+import type { EventSelector } from './event_selector.js';
+
+export type EventMetadataDefinition = {
+  eventSelector: EventSelector;
+  abiType: AbiType;
+  fieldNames: string[];
+};

package/src/abi/function_call.ts

@@ -5,7 +5,7 @@ import { AztecAddress } from '../aztec-address/index.js';
 import { type AbiType, FunctionType } from './abi.js';
 import { FunctionSelector } from './function_selector.js';
 
-/** A request to call a function on a contract from a given address. */
+/** A request to call a function on a contract. */
 export class FunctionCall {
   constructor(
     /** The name of the function to call */
@@ -16,6 +16,8 @@ export class FunctionCall {
     public selector: FunctionSelector,
     /** Type of the function */
     public type: FunctionType,
+    /** Only applicable for enqueued public function calls. `hideMsgSender = true` will set the msg_sender field (the caller's address) to "null", meaning the public function (and observers around the world) won't know which smart contract address made the call. */
+    public hideMsgSender: boolean,
     /** Whether this call can make modifications to state or not */
     public isStatic: boolean,
     /** The encoded args */
@@ -30,6 +32,7 @@ export class FunctionCall {
       fields.to,
       fields.selector,
       fields.type,
+      fields.hideMsgSender,
       fields.isStatic,
       fields.args,
       fields.returnTypes,
@@ -50,6 +53,7 @@ export class FunctionCall {
       to: AztecAddress.ZERO,
       selector: FunctionSelector.empty(),
       type: FunctionType.PUBLIC,
+      hideMsgSender: false,
       isStatic: false,
       args: [],
       returnTypes: [],

package/src/abi/index.ts

@@ -2,6 +2,8 @@ export * from './abi.js';
 export * from './buffer.js';
 export * from './decoder.js';
 export * from './encoder.js';
+export * from './authorization_selector.js';
+export * from './event_metadata_definition.js';
 export * from './event_selector.js';
 export * from './function_selector.js';
 export * from './note_selector.js';

package/src/abi/utils.ts

@@ -49,6 +49,21 @@ export function isWrappedFieldStruct(abiType: AbiType) {
   );
 }
 
+/**
+ * Returns whether the ABI type is a BoundedVec struct from Noir's std::collections::bounded_vec.
+ * @param abiType - Type to check.
+ * @returns A boolean indicating whether the ABI type is a BoundedVec struct.
+ */
+export function isBoundedVecStruct(abiType: AbiType) {
+  return (
+    abiType.kind === 'struct' &&
+    abiType.path === 'std::collections::bounded_vec::BoundedVec' &&
+    abiType.fields.length === 2 &&
+    abiType.fields[0].name === 'storage' &&
+    abiType.fields[1].name === 'len'
+  );
+}
+
 /**
  * Returns a bigint by parsing a serialized 2's complement signed int.
  * @param b - The signed int as a buffer

package/src/auth_witness/auth_witness.ts

@@ -1,7 +1,10 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
+import type { AztecAddress } from '../aztec-address/index.js';
 import { hexSchemaFor } from '../schemas/schemas.js';
 import { Vector } from '../types/shared.js';
 
@@ -50,3 +53,29 @@ export class AuthWitness {
     return new AuthWitness(Fr.random(), [Fr.random(), Fr.random(), Fr.random()]);
   }
 }
+
+/**
+ * Compute the inner hash for an authentication witness.
+ * This is the "intent" of the message, before siloed with the consumer.
+ * @param args - The arguments to hash
+ * @returns The inner hash for the witness
+ */
+export const computeInnerAuthWitHash = (args: Fr[]) => {
+  return poseidon2HashWithSeparator(args, GeneratorIndex.AUTHWIT_INNER);
+};
+
+/**
+ * Compute the outer hash for an authentication witness.
+ * This is the value siloed with its "consumer" and what the `on_behalf_of`
+ * should be signing.
+ * The consumer is who will be consuming the message, for token approvals it
+ * is the token contract itself (because the token makes the call to check the approval).
+ * @param consumer - The address that can "consume" the authwit
+ * @param chainId - The chain id that can "consume" the authwit
+ * @param version - The version that can "consume" the authwit
+ * @param innerHash - The inner hash for the witness
+ * @returns The outer hash for the witness
+ */
+export const computeOuterAuthWitHash = (consumer: AztecAddress, chainId: Fr, version: Fr, innerHash: Fr) => {
+  return poseidon2HashWithSeparator([consumer.toField(), chainId, version, innerHash], GeneratorIndex.AUTHWIT_OUTER);
+};