@aztec/noir-noir_codegen 0.75.0-commit.8a71f57856e217a77b6e50cbc8833c1cd5395b96

package/README.md

@@ -0,0 +1,4 @@
+
+## Acknowledgements
+
+`noir-codegen` repurposes the CLI code from https://github.com/dethcrypto/TypeChain, used under the MIT license.

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { CompiledCircuit } from '@noir-lang/types';
+export declare const codegen: (programs: [string, CompiledCircuit][], embedArtifact: boolean, useFixedLengthArrays: boolean) => string;

package/lib/index.js

@@ -0,0 +1,8 @@
+import { TypingsGenerator } from './utils/typings_generator.js';
+export const codegen = (programs, embedArtifact, useFixedLengthArrays) => {
+    return new TypingsGenerator(programs.map((program) => ({
+        circuitName: program[0],
+        artifact: embedArtifact ? program[1] : undefined,
+        abi: structuredClone(program[1].abi), // We'll mutate the ABI types when doing typescript codegen, so we clone it to avoid mutating the artifact.
+    })), useFixedLengthArrays).codegen();
+};

package/lib/main.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/lib/main.js

@@ -0,0 +1,37 @@
+#! /usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { parseArgs } from './parseArgs.js';
+import { glob } from './utils/glob.js';
+import { codegen } from './index.js';
+function main() {
+    const cliConfig = parseArgs();
+    const cwd = process.cwd();
+    const files = getFilesToProcess(cwd, cliConfig.files);
+    if (files.length === 0) {
+        throw new Error('No files passed.' + '\n' + `\`${cliConfig.files}\` didn't match any input files in ${cwd}`);
+    }
+    const programs = files.map((file_path) => {
+        const program_name = path.parse(file_path).name;
+        const file_contents = fs.readFileSync(file_path).toString();
+        const { abi, bytecode } = JSON.parse(file_contents);
+        return [program_name, { abi, bytecode }];
+    });
+    const result = codegen(programs, !cliConfig.externalArtifact, cliConfig.useFixedLengthArrays);
+    const outputDir = path.resolve(cliConfig.outDir ?? './codegen');
+    const outputFile = path.join(outputDir, 'index.ts');
+    if (!fs.existsSync(outputDir))
+        fs.mkdirSync(outputDir);
+    fs.writeFileSync(outputFile, result);
+}
+function getFilesToProcess(cwd, filesOrPattern) {
+    let res = glob(cwd, filesOrPattern);
+    if (res.length === 0) {
+        // If there are no files found, but first parameter is surrounded with single quotes, we try again without quotes
+        const match = filesOrPattern[0].match(/'([\s\S]*)'/)?.[1];
+        if (match)
+            res = glob(cwd, [match]);
+    }
+    return res;
+}
+main();

package/lib/parseArgs.d.ts

@@ -0,0 +1,8 @@
+export interface ParsedArgs {
+    files: string[];
+    outDir?: string | undefined;
+    inputDir?: string | undefined;
+    externalArtifact: boolean;
+    useFixedLengthArrays: boolean;
+}
+export declare function parseArgs(): ParsedArgs;

package/lib/parseArgs.js

@@ -0,0 +1,55 @@
+import { parse as commandLineArgs } from 'ts-command-line-args';
+const DEFAULT_GLOB_PATTERN = './target/**/*.json';
+export function parseArgs() {
+    const rawOptions = commandLineArgs({
+        glob: {
+            type: String,
+            defaultOption: true,
+            multiple: true,
+            defaultValue: [DEFAULT_GLOB_PATTERN],
+            description: 'Pattern that will be used to find program artifacts. Remember about adding quotes: noir-codegen "**/*.json".',
+        },
+        'out-dir': { type: String, optional: true, description: 'Output directory for generated files.' },
+        'input-dir': {
+            type: String,
+            optional: true,
+            description: 'Directory containing program artifact files. Inferred as lowest common path of all files if not specified.',
+        },
+        help: { type: Boolean, defaultValue: false, alias: 'h', description: 'Prints this message.' },
+        'external-artifact': {
+            type: Boolean,
+            defaultValue: false,
+            description: 'Does not embed the circuit artifact in the code, instead requiring passing the circuit artifact as an argument to the generated functions.',
+        },
+        'fixed-length-arrays': {
+            type: Boolean,
+            defaultValue: false,
+            description: 'Use fixed-length arrays for inputs and outputs.',
+        },
+    }, {
+        helpArg: 'help',
+        headerContentSections: [
+            {
+                content: `\
+          noir-codegen generates TypeScript wrappers for Noir programs to simplify replicating your Noir logic in JS.`,
+            },
+        ],
+        footerContentSections: [
+            {
+                header: 'Example Usage',
+                content: `\
+          noir-codegen --out-dir app/noir_programs './target/*.json'
+
+
+          You can read more about noir-codegen at {underline https://github.com/noir-lang/noir}.`,
+            },
+        ],
+    });
+    return {
+        files: rawOptions.glob,
+        outDir: rawOptions['out-dir'],
+        inputDir: rawOptions['input-dir'],
+        externalArtifact: rawOptions['external-artifact'],
+        useFixedLengthArrays: rawOptions['fixed-length-arrays'],
+    };
+}

package/lib/utils/abi_type_with_generics.d.ts

@@ -0,0 +1,70 @@
+import { AbiType } from '@noir-lang/noirc_abi';
+/**
+ * Represents a binding to a generic.
+ */
+export declare class BindingId {
+    id: number;
+    isNumeric: boolean;
+    constructor(id: number, isNumeric: boolean);
+}
+export type StructType = {
+    path: string;
+    fields: {
+        name: string;
+        type: AbiTypeWithGenerics;
+    }[];
+    /** The generics of the struct, bound to the fields */
+    generics: BindingId[];
+};
+export type StringType = {
+    kind: 'string';
+    length: number | BindingId | null;
+};
+export type Constant = {
+    kind: 'constant';
+    value: number;
+};
+export type ArrayType = {
+    kind: 'array';
+    length: number | BindingId | null;
+    type: AbiTypeWithGenerics;
+};
+export type Tuple = {
+    kind: 'tuple';
+    fields: AbiTypeWithGenerics[];
+};
+export type Struct = {
+    kind: 'struct';
+    structType: StructType;
+    /** The arguments are the concrete instantiation of the generics in the struct type. */
+    args: AbiTypeWithGenerics[];
+};
+export type AbiTypeWithGenerics = {
+    kind: 'field';
+} | {
+    kind: 'boolean';
+} | {
+    kind: 'integer';
+    sign: string;
+    width: number;
+} | {
+    kind: 'binding';
+    id: BindingId;
+} | {
+    kind: 'constant';
+    value: number;
+} | StringType | ArrayType | Tuple | Struct;
+/**
+ * Maps an ABI type to an ABI type with generics.
+ * This performs pure type conversion, and does not generate any bindings.
+ */
+export declare function mapAbiTypeToAbiTypeWithGenerics(abiType: AbiType): AbiTypeWithGenerics;
+/**
+ * Finds the structs in an ABI type.
+ * This won't explore nested structs.
+ */
+export declare function findStructsInType(abiType: AbiTypeWithGenerics): Struct[];
+/**
+ * Finds all the structs in an ABI type, including nested structs.
+ */
+export declare function findAllStructsInType(abiType: AbiTypeWithGenerics): Struct[];

package/lib/utils/abi_type_with_generics.js

@@ -0,0 +1,88 @@
+/**
+ * Represents a binding to a generic.
+ */
+export class BindingId {
+    id;
+    isNumeric;
+    constructor(id, isNumeric) {
+        this.id = id;
+        this.isNumeric = isNumeric;
+    }
+}
+/**
+ * Maps an ABI type to an ABI type with generics.
+ * This performs pure type conversion, and does not generate any bindings.
+ */
+export function mapAbiTypeToAbiTypeWithGenerics(abiType) {
+    switch (abiType.kind) {
+        case 'field':
+        case 'boolean':
+        case 'string':
+        case 'integer':
+            return abiType;
+        case 'array':
+            return {
+                kind: 'array',
+                length: abiType.length,
+                type: mapAbiTypeToAbiTypeWithGenerics(abiType.type),
+            };
+        case 'struct': {
+            const structType = {
+                path: abiType.path,
+                fields: abiType.fields.map((field) => ({
+                    name: field.name,
+                    type: mapAbiTypeToAbiTypeWithGenerics(field.type),
+                })),
+                generics: [],
+            };
+            return {
+                kind: 'struct',
+                structType,
+                args: [],
+            };
+        }
+        case 'tuple':
+            return {
+                kind: 'tuple',
+                fields: abiType.fields.map(mapAbiTypeToAbiTypeWithGenerics),
+            };
+        default: {
+            const exhaustiveCheck = abiType;
+            throw new Error(`Unhandled abi type: ${exhaustiveCheck}`);
+        }
+    }
+}
+/**
+ * Finds the structs in an ABI type.
+ * This won't explore nested structs.
+ */
+export function findStructsInType(abiType) {
+    switch (abiType.kind) {
+        case 'field':
+        case 'boolean':
+        case 'string':
+        case 'integer':
+            return [];
+        case 'array':
+            return findStructsInType(abiType.type);
+        case 'tuple':
+            return abiType.fields.flatMap(findStructsInType);
+        case 'struct':
+            return [abiType];
+        default: {
+            return [];
+        }
+    }
+}
+/**
+ * Finds all the structs in an ABI type, including nested structs.
+ */
+export function findAllStructsInType(abiType) {
+    let allStructs = [];
+    let lastStructs = findStructsInType(abiType);
+    while (lastStructs.length > 0) {
+        allStructs = allStructs.concat(lastStructs);
+        lastStructs = lastStructs.flatMap((struct) => struct.structType.fields.flatMap((field) => findStructsInType(field.type)));
+    }
+    return allStructs;
+}

package/lib/utils/demonomorphizer.d.ts

@@ -0,0 +1,46 @@
+import { type AbiTypeWithGenerics, type StructType } from './abi_type_with_generics.js';
+export interface DemonomorphizerConfig {
+    leaveArrayLengthsUnbounded: boolean;
+    leaveStringLengthsUnbounded: boolean;
+}
+/**
+ * Demonomorphizes a list of ABI types adding generics to structs.
+ * Since monomorphization of the generics destroys information, this process is not guaranteed to return the original structure.
+ * However, it should successfully unify all struct types that share the same name and field names.
+ */
+export declare class Demonomorphizer {
+    private types;
+    private config;
+    private variantsMap;
+    private visitedStructs;
+    private lastBindingId;
+    /**
+     * Demonomorphizes the passed in ABI types, mutating them.
+     */
+    static demonomorphize(abiTypes: AbiTypeWithGenerics[], config: DemonomorphizerConfig): void;
+    private constructor();
+    /**
+     * Finds all the variants of the structs in the types.
+     * A variant is every use of a struct with the same name and fields.
+     */
+    private fillVariantsMap;
+    private demonomorphizeStructs;
+    /**
+     * Demonomorphizes a struct, by demonomorphizing its dependencies first.
+     * Then it'll unify the types of the variants generating a unique generic type.
+     * It'll also generate args that instantiate the generic type with the concrete arguments for each variant.
+     */
+    private demonomorphizeStruct;
+    /**
+     * Tries to unify the types of a set of variants recursively.
+     * Unification will imply replacing some properties with bindings and pushing bindings to the generics of the struct.
+     */
+    private unifyTypes;
+    /**
+     * We consider a struct to be the same if it has the same name and field names.
+     * Structs with the same id will be unified into a single type by the demonomorphizer.
+     */
+    static buildIdForStruct(struct: StructType): string;
+    private buildBindingAndPushToVariants;
+    private buildNumericBindingAndPushToVariants;
+}

package/lib/utils/demonomorphizer.js

@@ -0,0 +1,223 @@
+import { BindingId, findAllStructsInType, findStructsInType, } from './abi_type_with_generics.js';
+/**
+ * Demonomorphizes a list of ABI types adding generics to structs.
+ * Since monomorphization of the generics destroys information, this process is not guaranteed to return the original structure.
+ * However, it should successfully unify all struct types that share the same name and field names.
+ */
+export class Demonomorphizer {
+    types;
+    config;
+    variantsMap;
+    visitedStructs;
+    lastBindingId = 0;
+    /**
+     * Demonomorphizes the passed in ABI types, mutating them.
+     */
+    static demonomorphize(abiTypes, config) {
+        new Demonomorphizer(abiTypes, config);
+    }
+    constructor(types, config) {
+        this.types = types;
+        this.config = config;
+        this.variantsMap = new Map();
+        this.fillVariantsMap();
+        this.visitedStructs = new Map();
+        this.demonomorphizeStructs();
+    }
+    /**
+     * Finds all the variants of the structs in the types.
+     * A variant is every use of a struct with the same name and fields.
+     */
+    fillVariantsMap() {
+        const allStructs = this.types.flatMap(findAllStructsInType);
+        for (const struct of allStructs) {
+            const id = Demonomorphizer.buildIdForStruct(struct.structType);
+            const variants = this.variantsMap.get(id) ?? [];
+            variants.push(struct);
+            this.variantsMap.set(id, variants);
+        }
+    }
+    demonomorphizeStructs() {
+        for (const type of this.types) {
+            const topLevelStructs = findStructsInType(type);
+            for (const struct of topLevelStructs) {
+                this.demonomorphizeStruct(struct);
+            }
+        }
+    }
+    /**
+     * Demonomorphizes a struct, by demonomorphizing its dependencies first.
+     * Then it'll unify the types of the variants generating a unique generic type.
+     * It'll also generate args that instantiate the generic type with the concrete arguments for each variant.
+     */
+    demonomorphizeStruct(struct) {
+        const id = Demonomorphizer.buildIdForStruct(struct.structType);
+        if (this.visitedStructs.has(id)) {
+            return;
+        }
+        const dependencies = struct.structType.fields.flatMap((field) => findStructsInType(field.type));
+        for (const dependency of dependencies) {
+            this.demonomorphizeStruct(dependency);
+        }
+        if (this.visitedStructs.has(id)) {
+            throw new Error('Circular dependency detected');
+        }
+        const variants = this.variantsMap.get(id);
+        const mappedStructType = struct.structType;
+        for (let i = 0; i < struct.structType.fields.length; i++) {
+            const variantTypes = variants.map((variant) => variant.structType.fields[i].type);
+            const mappedType = this.unifyTypes(variantTypes, mappedStructType.generics, variants);
+            mappedStructType.fields[i].type = mappedType;
+        }
+        // Mutate variants setting the new struct type
+        variants.forEach((variant) => (variant.structType = mappedStructType));
+        this.visitedStructs.set(id, mappedStructType);
+    }
+    /**
+     * Tries to unify the types of a set of variants recursively.
+     * Unification will imply replacing some properties with bindings and pushing bindings to the generics of the struct.
+     */
+    unifyTypes(types, generics, // Mutates generics adding new bindings
+    variants) {
+        const kinds = new Set(types.map((type) => type.kind));
+        if (kinds.size > 1) {
+            return this.buildBindingAndPushToVariants(types, generics, variants);
+        }
+        switch (types[0].kind) {
+            case 'field':
+            case 'boolean':
+            case 'binding':
+                return types[0];
+            case 'integer': {
+                if (allDeepEqual(types)) {
+                    return types[0];
+                }
+                else {
+                    return this.buildBindingAndPushToVariants(types, generics, variants);
+                }
+            }
+            case 'string': {
+                const strings = types;
+                const unifiedStringType = strings[0];
+                if (strings.every((string) => string.length === unifiedStringType.length)) {
+                    return unifiedStringType;
+                }
+                else if (!this.config.leaveStringLengthsUnbounded) {
+                    unifiedStringType.length = this.buildNumericBindingAndPushToVariants(strings.map((string) => {
+                        if (typeof string.length !== 'number') {
+                            throw new Error('Trying to unify strings with bindings');
+                        }
+                        return string.length;
+                    }), generics, variants);
+                    return unifiedStringType;
+                }
+                else {
+                    unifiedStringType.length = null;
+                    return unifiedStringType;
+                }
+            }
+            case 'array': {
+                const arrays = types;
+                const unifiedArrayType = arrays[0];
+                if (!arrays.every((array) => array.length === unifiedArrayType.length)) {
+                    if (!this.config.leaveArrayLengthsUnbounded) {
+                        unifiedArrayType.length = this.buildNumericBindingAndPushToVariants(arrays.map((array) => {
+                            if (typeof array.length !== 'number') {
+                                throw new Error('Trying to unify arrays with bindings');
+                            }
+                            return array.length;
+                        }), generics, variants);
+                    }
+                    else {
+                        unifiedArrayType.length = null;
+                    }
+                }
+                unifiedArrayType.type = this.unifyTypes(arrays.map((array) => array.type), generics, variants);
+                return unifiedArrayType;
+            }
+            case 'tuple': {
+                const tuples = types;
+                const unifiedTupleType = tuples[0];
+                for (let i = 0; i < unifiedTupleType.fields.length; i++) {
+                    unifiedTupleType.fields[i] = this.unifyTypes(tuples.map((tuple) => tuple.fields[i]), generics, variants);
+                }
+                return unifiedTupleType;
+            }
+            case 'struct': {
+                const structs = types;
+                const ids = new Set(structs.map((struct) => Demonomorphizer.buildIdForStruct(struct.structType)));
+                if (ids.size > 1) {
+                    // If the types are different structs, we can only unify them by creating a new binding.
+                    // For example, if we have a struct A { x: u32 } and a struct A { x: Field }, the only possible unification is A<T> { x: T }
+                    return this.buildBindingAndPushToVariants(types, generics, variants);
+                }
+                else {
+                    // If the types are the same struct, we must unify the arguments to the struct.
+                    // For example, if we have A<Field> and A<u32>, we need to unify to A<T> and push T to the generics of the struct type.
+                    const unifiedStruct = structs[0];
+                    if (!structs.every((struct) => struct.args.length === unifiedStruct.args.length)) {
+                        throw new Error('Same struct with different number of args encountered');
+                    }
+                    for (let i = 0; i < unifiedStruct.args.length; i++) {
+                        const argTypes = structs.map((struct) => struct.args[i]);
+                        unifiedStruct.args[i] = this.unifyTypes(argTypes, generics, variants);
+                    }
+                    return unifiedStruct;
+                }
+            }
+            case 'constant': {
+                const constants = types;
+                if (constants.every((constant) => constant.value === constants[0].value)) {
+                    return constants[0];
+                }
+                else {
+                    return this.buildBindingAndPushToVariants(types, generics, variants, true);
+                }
+            }
+            default: {
+                const exhaustiveCheck = types[0];
+                throw new Error(`Unhandled abi type: ${exhaustiveCheck}`);
+            }
+        }
+    }
+    /**
+     * We consider a struct to be the same if it has the same name and field names.
+     * Structs with the same id will be unified into a single type by the demonomorphizer.
+     */
+    static buildIdForStruct(struct) {
+        const name = struct.path.split('::').pop();
+        const fields = struct.fields.map((field) => field.name).join(',');
+        return `${name}(${fields})`;
+    }
+    buildBindingAndPushToVariants(concreteTypes, generics, variants, isNumeric = false) {
+        const bindingId = new BindingId(this.lastBindingId++, isNumeric);
+        for (let i = 0; i < variants.length; i++) {
+            const variant = variants[i];
+            const concreteType = concreteTypes[i];
+            variant.args.push(concreteType);
+        }
+        generics.push(bindingId);
+        return { kind: 'binding', id: bindingId };
+    }
+    buildNumericBindingAndPushToVariants(concreteNumbers, generics, variants) {
+        const bindingId = new BindingId(this.lastBindingId++, true);
+        for (let i = 0; i < variants.length; i++) {
+            const variant = variants[i];
+            variant.args.push({ kind: 'constant', value: concreteNumbers[i] });
+        }
+        generics.push(bindingId);
+        return bindingId;
+    }
+}
+function allDeepEqual(arr) {
+    if (arr.length === 0) {
+        return true;
+    }
+    const first = JSON.stringify(arr[0]);
+    for (let i = 0; i < arr.length; i++) {
+        if (JSON.stringify(arr[i]) !== first) {
+            return false;
+        }
+    }
+    return true;
+}

package/lib/utils/glob.d.ts

@@ -0,0 +1 @@
+export declare function glob(cwd: string, patternsOrFiles: string[]): string[];

package/lib/utils/glob.js

@@ -0,0 +1,5 @@
+import { sync as globSync } from 'glob';
+export function glob(cwd, patternsOrFiles) {
+    const matches = patternsOrFiles.map((p) => globSync(p, { ignore: 'node_modules/**', absolute: true, cwd }));
+    return [...new Set(matches.flat())];
+}

package/lib/utils/typings_generator.d.ts

@@ -0,0 +1,36 @@
+import { CompiledCircuit } from '@noir-lang/types';
+import { Abi } from '@noir-lang/noirc_abi';
+export declare class TypingsGenerator {
+    private useFixedLengthArrays;
+    /** All the types in the ABIs */
+    private allTypes;
+    /** The demonomorphized ABIs of the circuits */
+    private demonomorphizedAbis;
+    /** Maps struct id to name for structs with the same name and different field sets */
+    private structIdToTsName;
+    /** Collect all the primitives used in the types to add them to the codegen */
+    private primitiveTypesUsed;
+    constructor(circuits: {
+        abi: Abi;
+        circuitName: string;
+        artifact?: CompiledCircuit;
+    }[], useFixedLengthArrays: boolean);
+    codegen(): string;
+    private codegenAllStructs;
+    private getStructName;
+    private codegenStructType;
+    private codegenType;
+    /**
+     * Typescript does not allow us to check for equality of non-primitive types
+     * easily, so we create a addIfUnique function that will only add an item
+     * to the map if it is not already there by using JSON.stringify.
+     * @param item - The item to add to the map.
+     */
+    private addIfUnique;
+    /**
+     * Codegen all the interfaces for the circuits.
+     * For a circuit named Foo, we'll codegen FooInputType and FooReturnType.
+     */
+    private codegenAllInterfaces;
+    private codegenAllPrimitives;
+}

package/lib/utils/typings_generator.js

@@ -0,0 +1,254 @@
+import { findAllStructsInType, mapAbiTypeToAbiTypeWithGenerics, } from './abi_type_with_generics.js';
+import { Demonomorphizer } from './demonomorphizer.js';
+const codegenPrelude = `/* Autogenerated file, do not edit! */
+
+/* eslint-disable */
+
+import { Noir, InputMap, CompiledCircuit, ForeignCallHandler } from "@noir-lang/noir_js"
+
+export { ForeignCallHandler } from "@noir-lang/noir_js"
+`;
+/**
+ * Returns the last component of a path, e.g. "foo::bar::baz" -\> "baz"
+ * Note: that if we have a path such as "Baz", we will return "Baz".
+ *
+ * Since these paths corresponds to structs, we can assume that we
+ * cannot have "foo::bar::".
+ *
+ * We also make the assumption that since these paths are coming from
+ * Noir, then we will not have two paths that look like this:
+ * - foo::bar::Baz
+ * - cat::dog::Baz
+ * ie the last component of the path (struct name) is enough to uniquely identify
+ * the whole path.
+ *
+ * TODO: We should double check this assumption when we use type aliases,
+ * I expect that `foo::bar::Baz as Dog` would effectively give `foo::bar::Dog`
+ * @param str - The path to get the last component of.
+ * @returns The last component of the path.
+ */
+function getLastComponentOfPath(str) {
+    const parts = str.split('::');
+    const lastPart = parts[parts.length - 1];
+    return lastPart;
+}
+/**
+ * Replaces a numeric binding with the corresponding generics name or the actual value.
+ */
+function replaceNumericBinding(id, genericsNameMap) {
+    if (typeof id === 'number') {
+        return id.toString();
+    }
+    else {
+        return genericsNameMap.get(id.id) ?? 'unknown';
+    }
+}
+export class TypingsGenerator {
+    useFixedLengthArrays;
+    /** All the types in the ABIs */
+    allTypes = [];
+    /** The demonomorphized ABIs of the circuits */
+    demonomorphizedAbis = [];
+    /** Maps struct id to name for structs with the same name and different field sets */
+    structIdToTsName = new Map();
+    /** Collect all the primitives used in the types to add them to the codegen */
+    primitiveTypesUsed = new Map();
+    constructor(circuits, useFixedLengthArrays) {
+        this.useFixedLengthArrays = useFixedLengthArrays;
+        // Map all the types used in the ABIs to the demonomorphized types
+        for (const { abi, circuitName, artifact } of circuits) {
+            const params = abi.parameters.map((param) => {
+                const type = mapAbiTypeToAbiTypeWithGenerics(param.type);
+                this.allTypes.push(type);
+                return { name: param.name, type };
+            });
+            if (abi.return_type) {
+                const returnType = mapAbiTypeToAbiTypeWithGenerics(abi.return_type.abi_type);
+                this.allTypes.push(returnType);
+                this.demonomorphizedAbis.push({ circuitName, params, returnType, artifact });
+            }
+            else {
+                this.demonomorphizedAbis.push({ circuitName, params, artifact });
+            }
+        }
+        // Demonomorphize the types
+        Demonomorphizer.demonomorphize(this.allTypes, {
+            leaveArrayLengthsUnbounded: !useFixedLengthArrays,
+            leaveStringLengthsUnbounded: true,
+        });
+    }
+    codegen() {
+        this.primitiveTypesUsed = new Map();
+        const structsCode = this.codegenAllStructs();
+        const interfacesCode = this.codegenAllInterfaces();
+        const primitivesCode = this.codegenAllPrimitives();
+        return `
+${codegenPrelude}
+${primitivesCode}
+${structsCode}
+${interfacesCode}`;
+    }
+    codegenAllStructs() {
+        const allStructs = this.allTypes.flatMap(findAllStructsInType);
+        // First, deduplicate the structs used
+        const structTypesToExport = new Map();
+        for (const struct of allStructs) {
+            const id = Demonomorphizer.buildIdForStruct(struct.structType);
+            if (structTypesToExport.has(id)) {
+                continue;
+            }
+            structTypesToExport.set(id, struct.structType);
+        }
+        // Then, we have to consider the case where we have struct with the same name but different fields.
+        // For those, we'll naively append a number to the name.
+        const idsPerName = new Map();
+        for (const [id, structType] of structTypesToExport.entries()) {
+            const name = getLastComponentOfPath(structType.path);
+            const ids = idsPerName.get(name) ?? [];
+            ids.push(id);
+            idsPerName.set(name, ids);
+        }
+        this.structIdToTsName = new Map();
+        for (const [name, ids] of idsPerName.entries()) {
+            if (ids.length !== 1) {
+                ids.forEach((id, index) => {
+                    this.structIdToTsName.set(id, `${name}${index + 1}`);
+                });
+            }
+        }
+        // Now we can just generate the code for the structs
+        let resultCode = '';
+        for (const structType of structTypesToExport.values()) {
+            resultCode += this.codegenStructType(structType);
+        }
+        return resultCode;
+    }
+    getStructName(structType) {
+        return (this.structIdToTsName.get(Demonomorphizer.buildIdForStruct(structType)) || getLastComponentOfPath(structType.path));
+    }
+    codegenStructType(structType) {
+        // Generate names for the generic bindings.
+        const genericsNameMap = new Map();
+        structType.generics.forEach((generic, index) => {
+            genericsNameMap.set(generic.id, String.fromCharCode('A'.charCodeAt(0) + index));
+        });
+        const name = this.getStructName(structType);
+        const generics = structType.generics.length
+            ? `<${structType.generics
+                .map((generic) => `${genericsNameMap.get(generic.id)}${generic.isNumeric ? ' extends number' : ''}`)
+                .join(', ')}>`
+            : '';
+        let resultCode = `export type ${name}${generics} = {\n`;
+        for (const field of structType.fields) {
+            resultCode += `  ${field.name}: ${this.codegenType(field.type, genericsNameMap)};\n`;
+        }
+        resultCode += '}\n\n';
+        return resultCode;
+    }
+    codegenType(type, genericsNameMap) {
+        switch (type.kind) {
+            case 'field':
+                this.addIfUnique({ aliasName: 'Field', tsType: 'string' });
+                return 'Field';
+            case 'boolean':
+                return 'boolean';
+            case 'integer': {
+                const typeName = type.sign === 'signed' ? `i${type.width}` : `u${type.width}`;
+                // Even though noir accepts numbers or strings for integers, it always returns strings
+                // So we must use string as the type here.
+                this.addIfUnique({ aliasName: typeName, tsType: 'string' });
+                return typeName;
+            }
+            case 'binding':
+                return genericsNameMap.get(type.id.id) ?? 'unknown';
+            case 'constant':
+                return type.value.toString();
+            case 'string':
+                return `string`;
+            case 'array':
+                if (this.useFixedLengthArrays) {
+                    if (type.length === null) {
+                        throw new Error('Got unbounded array with fixed length arrays enabled');
+                    }
+                    return `FixedLengthArray<${this.codegenType(type.type, genericsNameMap)}, ${replaceNumericBinding(type.length, genericsNameMap)}>`;
+                }
+                else {
+                    return `${this.codegenType(type.type, genericsNameMap)}[]`;
+                }
+            case 'tuple': {
+                const fieldTypes = type.fields.map((field) => this.codegenType(field, genericsNameMap));
+                return `[${fieldTypes.join(', ')}]`;
+            }
+            case 'struct': {
+                const name = this.getStructName(type.structType);
+                if (type.args.length) {
+                    const args = type.args.map((arg) => this.codegenType(arg, genericsNameMap)).join(', ');
+                    return `${name}<${args}>`;
+                }
+                else {
+                    return name;
+                }
+            }
+        }
+    }
+    /**
+     * Typescript does not allow us to check for equality of non-primitive types
+     * easily, so we create a addIfUnique function that will only add an item
+     * to the map if it is not already there by using JSON.stringify.
+     * @param item - The item to add to the map.
+     */
+    addIfUnique(item) {
+        const key = JSON.stringify(item);
+        if (!this.primitiveTypesUsed.has(key)) {
+            this.primitiveTypesUsed.set(key, item);
+        }
+    }
+    /**
+     * Codegen all the interfaces for the circuits.
+     * For a circuit named Foo, we'll codegen FooInputType and FooReturnType.
+     */
+    codegenAllInterfaces() {
+        let resultCode = '';
+        for (const { circuitName, params, returnType, artifact } of this.demonomorphizedAbis) {
+            const functionSignature = {
+                inputs: params.map((param) => [param.name, this.codegenType(param.type, new Map())]),
+                returnValue: returnType ? this.codegenType(returnType, new Map()) : null,
+            };
+            resultCode += this.codegenStructType({
+                path: `${circuitName}InputType`,
+                fields: params,
+                generics: [],
+            });
+            if (returnType) {
+                resultCode += `export type ${circuitName}ReturnType = ${this.codegenType(returnType, new Map())};\n`;
+            }
+            resultCode += codegenFunction(circuitName, functionSignature, artifact);
+        }
+        return resultCode;
+    }
+    codegenAllPrimitives() {
+        let primitiveTypeAliases = this.useFixedLengthArrays
+            ? 'export type FixedLengthArray<T, L extends number> = L extends 0 ? never[]: T[] & { length: L }\n'
+            : '';
+        for (const [, value] of this.primitiveTypesUsed) {
+            primitiveTypeAliases += `export type ${value.aliasName} = ${value.tsType};\n`;
+        }
+        return primitiveTypeAliases;
+    }
+}
+const codegenFunction = (name, function_signature, compiled_program) => {
+    const args = function_signature.inputs.map(([name]) => `${name}`).join(', ');
+    const args_with_types = function_signature.inputs.map(([name, type]) => `${name}: ${type}`).join(', ');
+    const artifact = compiled_program
+        ? `export const ${name}_circuit: CompiledCircuit = ${JSON.stringify(compiled_program)};`
+        : '';
+    return `${artifact}
+
+export async function ${name}(${args_with_types}${compiled_program ? '' : `, ${name}_circuit: CompiledCircuit`}, foreignCallHandler?: ForeignCallHandler): Promise<${function_signature.returnValue}> {
+  const program = new Noir(${name}_circuit);
+  const args: InputMap = { ${args} };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as ${function_signature.returnValue};
+}
+`;
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@aztec/noir-noir_codegen",
+  "contributors": [
+    "The Noir Team <team@noir-lang.org>"
+  ],
+  "version": "0.75.0-commit.8a71f57856e217a77b6e50cbc8833c1cd5395b96",
+  "packageManager": "yarn@3.5.1",
+  "license": "(MIT OR Apache-2.0)",
+  "type": "module",
+  "homepage": "https://noir-lang.org/",
+  "repository": {
+    "url": "https://github.com/noir-lang/noir.git",
+    "directory": "compiler/wasm",
+    "type": "git"
+  },
+  "bugs": {
+    "url": "https://github.com/noir-lang/noir/issues"
+  },
+  "dependencies": {
+    "glob": "^10.3.10",
+    "ts-command-line-args": "^2.5.1",
+    "@aztec/noir-types": "0.75.0-commit.8a71f57856e217a77b6e50cbc8833c1cd5395b96"
+  },
+  "files": [
+    "lib",
+    "package.json"
+  ],
+  "source": "src/index.ts",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "bin": {
+    "noir-codegen": "lib/main.js"
+  },
+  "scripts": {
+    "dev": "tsc-multi --watch",
+    "build": "tsc",
+    "test": "yarn test:codegen && yarn test:node && yarn test:clean",
+    "test:codegen": "${NARGO:-nargo} export --program-dir=./test/test_lib && tsx src/main.ts ./test/test_lib/export/** --out-dir ./test/codegen",
+    "test:node": "mocha --timeout 25000 --exit --config ./.mocharc.json",
+    "test:clean": "rm -rf ./test/codegen ./test/test_lib/export",
+    "prettier": "prettier 'src/**/*.ts'",
+    "prettier:fix": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
+    "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0",
+    "nightly:version": "jq --arg new_version \"-$(git rev-parse --short HEAD)$1\" '.version = .version + $new_version' package.json > package-tmp.json && mv package-tmp.json package.json",
+    "publish": "echo 📡 publishing `$npm_package_name` && yarn npm publish",
+    "clean": "rm -rf ./lib"
+  },
+  "devDependencies": {
+    "@noir-lang/noir_js": "1.0.0-beta.1",
+    "@types/chai": "^4",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^20.6.2",
+    "@types/prettier": "^3",
+    "chai": "^4.4.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "mocha": "^10.2.0",
+    "prettier": "3.2.5",
+    "ts-node": "^10.9.1",
+    "tsx": "^4.6.2",
+    "typescript": "^5.4.2"
+  }
+}