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

package/src/abi/abi.ts

@@ -7,7 +7,6 @@ import { inflate } from 'pako';
 import { z } from 'zod';
 
 import { FunctionSelector } from './function_selector.js';
-import { NoteSelector } from './note_selector.js';
 
 /** A basic value. */
 export interface BasicValue<T extends string, V> {
@@ -165,7 +164,7 @@ const AbiErrorTypeSchema = z.union([
 export enum FunctionType {
   PRIVATE = 'private',
   PUBLIC = 'public',
-  UNCONSTRAINED = 'unconstrained',
+  UTILITY = 'utility',
 }
 
 /** The abi entry of a function. */
@@ -174,8 +173,8 @@ export interface FunctionAbi {
   name: string;
   /** Whether the function is secret. */
   functionType: FunctionType;
-  /** Whether the function is internal. */
-  isInternal: boolean;
+  /** Whether the function is marked as `#[only_self]` and hence callable only from within the contract. */
+  isOnlySelf: boolean;
   /** Whether the function can alter state or not */
   isStatic: boolean;
   /** Function parameters. */
@@ -191,12 +190,12 @@ export interface FunctionAbi {
 export const FunctionAbiSchema = z.object({
   name: z.string(),
   functionType: z.nativeEnum(FunctionType),
-  isInternal: z.boolean(),
+  isOnlySelf: z.boolean(),
   isStatic: z.boolean(),
   isInitializer: z.boolean(),
   parameters: z.array(z.object({ name: z.string(), type: AbiTypeSchema, visibility: z.enum(ABIParameterVisibility) })),
   returnTypes: z.array(AbiTypeSchema),
-  errorTypes: z.record(AbiErrorTypeSchema),
+  errorTypes: z.record(z.string(), AbiErrorTypeSchema.optional()),
 }) satisfies z.ZodType<FunctionAbi>;
 
 /** Debug metadata for a function. */
@@ -209,12 +208,19 @@ export interface FunctionDebugMetadata {
 
 export const FunctionDebugMetadataSchema = z.object({
   debugSymbols: z.object({
-    locations: z.record(
-      z.array(z.object({ span: z.object({ start: z.number(), end: z.number() }), file: z.number() })),
-    ),
-    brillig_locations: z.record(
-      z.record(z.array(z.object({ span: z.object({ start: z.number(), end: z.number() }), file: z.number() }))),
-    ),
+    location_tree: z.object({
+      locations: z.array(
+        z.object({
+          parent: z.number().nullable(),
+          value: z.object({
+            span: z.object({ start: z.number(), end: z.number() }),
+            file: z.number(),
+          }),
+        }),
+      ),
+    }),
+    acir_locations: z.record(z.number()),
+    brillig_locations: z.record(z.record(z.number())),
   }),
   files: z.record(z.object({ source: z.string(), path: z.string() })),
 }) satisfies z.ZodType<FunctionDebugMetadata>;
@@ -231,6 +237,11 @@ export interface FunctionArtifact extends FunctionAbi {
   debug?: FunctionDebugMetadata;
 }
 
+export interface FunctionArtifactWithContractName extends FunctionArtifact {
+  /** The name of the contract. */
+  contractName: string;
+}
+
 export const FunctionArtifactSchema = FunctionAbiSchema.and(
   z.object({
     bytecode: schemas.Buffer,
@@ -241,10 +252,10 @@ export const FunctionArtifactSchema = FunctionAbiSchema.and(
 ) satisfies ZodFor<FunctionArtifact>;
 
 /** A file ID. It's assigned during compilation. */
-export type FileId = number;
+type FileId = number;
 
 /** A pointer to a specific section of the source code. */
-export interface SourceCodeLocation {
+interface SourceCodeLocation {
   /** The section of the source code. */
   span: {
     /** The byte where the section starts. */
@@ -264,12 +275,22 @@ export type OpcodeLocation = string;
 
 export type BrilligFunctionId = number;
 
-export type OpcodeToLocationsMap = Record<OpcodeLocation, SourceCodeLocation[]>;
+export type OpcodeToLocationsMap = Record<OpcodeLocation, number>;
+
+export type LocationNodeDebugInfo = {
+  parent: number | null;
+  value: SourceCodeLocation;
+};
+
+export type LocationTree = {
+  locations: LocationNodeDebugInfo[];
+};
 
 /** The debug information for a given function. */
 export interface DebugInfo {
   /** A map of the opcode location to the source code location. */
-  locations: OpcodeToLocationsMap;
+  location_tree: LocationTree;
+  acir_locations: OpcodeToLocationsMap;
   /** For each Brillig function, we have a map of the opcode location to the source code location. */
   brillig_locations: Record<BrilligFunctionId, OpcodeToLocationsMap>;
 }
@@ -291,38 +312,6 @@ export type DebugFileMap = Record<
   }
 >;
 
-/** Type representing a field of a note (e.g. `amount` in `TokenNote`). */
-export type NoteField = {
-  /** Name of the field (e.g. `amount`). */
-  name: string;
-  /** Index where the note field starts in the serialized note array. */
-  index: number;
-  /** Whether the field can be unset when creating the note (in the partial notes flow). */
-  nullable: boolean;
-};
-
-export const NoteFieldSchema = z.object({
-  name: z.string(),
-  index: z.number(),
-  nullable: z.boolean(),
-}) satisfies z.ZodType<NoteField>;
-
-/** Type representing a note in use in the contract. */
-export type ContractNote = {
-  /** Note identifier */
-  id: NoteSelector;
-  /** Type of the note (e.g., 'TransparentNote') */
-  typ: string;
-  /** Fields of the note. */
-  fields: NoteField[];
-};
-
-export const ContractNoteSchema = z.object({
-  id: NoteSelector.schema,
-  typ: z.string(),
-  fields: z.array(NoteFieldSchema),
-}) satisfies ZodFor<ContractNote>;
-
 /** Type representing a field layout in the storage of a contract. */
 export type FieldLayout = {
   /** Slot in which the field is stored. */
@@ -334,12 +323,12 @@ export interface ContractArtifact {
   /** The name of the contract. */
   name: string;
 
-  /** The version of compiler used to create this artifact */
-  aztecNrVersion?: string;
-
-  /** The functions of the contract. */
+  /** The functions of the contract. Includes private and utility functions, plus the public dispatch function. */
   functions: FunctionArtifact[];
 
+  /** The public functions of the contract, excluding dispatch. */
+  nonDispatchPublicFunctions: FunctionAbi[];
+
   /** The outputs of the contract. */
   outputs: {
     structs: Record<string, AbiType[]>;
@@ -349,17 +338,14 @@ export interface ContractArtifact {
   /** Storage layout */
   storageLayout: Record<string, FieldLayout>;
 
-  /** The notes used in the contract. */
-  notes: Record<string, ContractNote>;
-
   /** The map of file ID to the source code and path of the file. */
   fileMap: DebugFileMap;
 }
 
 export const ContractArtifactSchema: ZodFor<ContractArtifact> = z.object({
   name: z.string(),
-  aztecNrVersion: z.string().optional(),
   functions: z.array(FunctionArtifactSchema),
+  nonDispatchPublicFunctions: z.array(FunctionAbiSchema),
   outputs: z.object({
     structs: z.record(z.array(AbiTypeSchema)).transform(structs => {
       for (const [key, value] of Object.entries(structs)) {
@@ -376,7 +362,6 @@ export const ContractArtifactSchema: ZodFor<ContractArtifact> = z.object({
     globals: z.record(z.array(AbiValueSchema)),
   }),
   storageLayout: z.record(z.object({ slot: schemas.Fr })),
-  notes: z.record(ContractNoteSchema),
   fileMap: z.record(z.coerce.number(), z.object({ source: z.string(), path: z.string() })),
 });
 
@@ -395,7 +380,7 @@ export function getFunctionArtifactByName(artifact: ContractArtifact, functionNa
 export async function getFunctionArtifact(
   artifact: ContractArtifact,
   functionNameOrSelector: string | FunctionSelector,
-): Promise<FunctionArtifact> {
+): Promise<FunctionArtifactWithContractName> {
   let functionArtifact;
   if (typeof functionNameOrSelector === 'string') {
     functionArtifact = artifact.functions.find(f => f.name === functionNameOrSelector);
@@ -416,7 +401,16 @@ export async function getFunctionArtifact(
 
   const debugMetadata = getFunctionDebugMetadata(artifact, functionArtifact);
 
-  return { ...functionArtifact, debug: debugMetadata };
+  return { ...functionArtifact, debug: debugMetadata, contractName: artifact.name };
+}
+
+/** Gets all function abis */
+export function getAllFunctionAbis(artifact: ContractArtifact): FunctionAbi[] {
+  return artifact.functions.map(f => f as FunctionAbi).concat(artifact.nonDispatchPublicFunctions || []);
+}
+
+export function parseDebugSymbols(debugSymbols: string): DebugInfo[] {
+  return JSON.parse(inflate(Buffer.from(debugSymbols, 'base64'), { to: 'string', raw: true })).debug_infos;
 }
 
 /**
@@ -432,14 +426,12 @@ export function getFunctionDebugMetadata(
   try {
     if (functionArtifact.debugSymbols && contractArtifact.fileMap) {
       // TODO(https://github.com/AztecProtocol/aztec-packages/issues/10546) investigate why debugMetadata is so big for some tests.
-      const programDebugSymbols = JSON.parse(
-        inflate(Buffer.from(functionArtifact.debugSymbols, 'base64'), { to: 'string', raw: true }),
-      );
+      const programDebugSymbols = parseDebugSymbols(functionArtifact.debugSymbols);
       // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5813)
       // We only support handling debug info for the contract function entry point.
       // So for now we simply index into the first debug info.
       return {
-        debugSymbols: programDebugSymbols.debug_infos[0],
+        debugSymbols: programDebugSymbols[0],
         files: contractArtifact.fileMap,
       };
     }
@@ -465,14 +457,15 @@ export function getFunctionDebugMetadata(
  * @param contractArtifact - The contract artifact.
  * @returns An initializer function, or none if there are no functions flagged as initializers in the contract.
  */
-export function getDefaultInitializer(contractArtifact: ContractArtifact): FunctionArtifact | undefined {
-  const initializers = contractArtifact.functions.filter(f => f.isInitializer);
+export function getDefaultInitializer(contractArtifact: ContractArtifact): FunctionAbi | undefined {
+  const functionAbis = getAllFunctionAbis(contractArtifact);
+  const initializers = functionAbis.filter(f => f.isInitializer);
   return initializers.length > 1
-    ? initializers.find(f => f.name === 'constructor') ??
+    ? (initializers.find(f => f.name === 'constructor') ??
         initializers.find(f => f.name === 'initializer') ??
         initializers.find(f => f.parameters?.length === 0) ??
         initializers.find(f => f.functionType === FunctionType.PRIVATE) ??
-        initializers[0]
+        initializers[0])
     : initializers[0];
 }
 
@@ -484,9 +477,10 @@ export function getDefaultInitializer(contractArtifact: ContractArtifact): Funct
 export function getInitializer(
   contract: ContractArtifact,
   initializerNameOrArtifact: string | undefined | FunctionArtifact,
-): FunctionArtifact | undefined {
+): FunctionAbi | undefined {
   if (typeof initializerNameOrArtifact === 'string') {
-    const found = contract.functions.find(f => f.name === initializerNameOrArtifact);
+    const functionAbis = getAllFunctionAbis(contract);
+    const found = functionAbis.find(f => f.name === initializerNameOrArtifact);
     if (!found) {
       throw new Error(`Constructor method ${initializerNameOrArtifact} not found in contract artifact`);
     } else if (!found.isInitializer) {
@@ -502,3 +496,39 @@ export function getInitializer(
     return initializerNameOrArtifact;
   }
 }
+
+export function emptyFunctionAbi(): FunctionAbi {
+  return {
+    name: '',
+    functionType: FunctionType.PRIVATE,
+    isOnlySelf: false,
+    isStatic: false,
+    parameters: [],
+    returnTypes: [],
+    errorTypes: {},
+    isInitializer: false,
+  };
+}
+
+export function emptyFunctionArtifact(): FunctionArtifact {
+  const abi = emptyFunctionAbi();
+  return {
+    ...abi,
+    bytecode: Buffer.from([]),
+    debugSymbols: '',
+  };
+}
+
+export function emptyContractArtifact(): ContractArtifact {
+  return {
+    name: '',
+    functions: [emptyFunctionArtifact()],
+    nonDispatchPublicFunctions: [emptyFunctionAbi()],
+    outputs: {
+      structs: {},
+      globals: {},
+    },
+    storageLayout: {},
+    fileMap: {},
+  };
+}

package/src/abi/authorization_selector.ts

@@ -0,0 +1,95 @@
+import { fromHex, toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { poseidon2HashBytes, randomBytes } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import { hexSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/foundation/serialize';
+
+import { Selector } from './selector.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+
+/** Authorization selector branding */
+export interface AuthorizationSelector {
+  /** Brand. */
+  _branding: 'AuthorizationSelector';
+}
+
+/**
+ * An authorization selector is the first 4 bytes of the hash of an authorization struct signature.
+ */
+export class AuthorizationSelector 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 AuthorizationSelector(value);
+  }
+
+  /**
+   * Converts a field to selector.
+   * @param fr - The field to convert.
+   * @returns The selector.
+   */
+  static fromField(fr: Fr) {
+    return new AuthorizationSelector(Number(fr.toBigInt()));
+  }
+
+  /**
+   * Creates a selector from a signature.
+   * @param signature - Signature to generate the selector for (e.g. "CallAuthorization(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 AuthorizationSelector.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 AuthorizationSelector length ${buf.length} (expected ${Selector.SIZE}).`);
+    }
+    return AuthorizationSelector.fromBuffer(buf);
+  }
+
+  /**
+   * Creates an empty selector.
+   * @returns An empty selector.
+   */
+  static empty() {
+    return new AuthorizationSelector(0);
+  }
+
+  /**
+   * Creates a random selector.
+   * @returns A random selector.
+   */
+  static random() {
+    return AuthorizationSelector.fromBuffer(randomBytes(Selector.SIZE));
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  static get schema() {
+    return hexSchemaFor(AuthorizationSelector);
+  }
+}

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,
@@ -17,9 +17,10 @@ import {
 } from '../abi/index.js';
 import {
   AZTEC_INITIALIZER_ATTRIBUTE,
-  AZTEC_INTERNAL_ATTRIBUTE,
+  AZTEC_ONLY_SELF_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,32 +131,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 +185,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 +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}`);