@noir-lang/noir_codegen 0.30.0 → 0.31.0

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,47 +1,8 @@
-import { generateTsInterface, codegenStructDefinitions } from './noir_types.js';
-// TODO: reenable this. See `abiTypeToTs` for reasoning.
-// export type FixedLengthArray<T, L extends number> = L extends 0 ? never[]: T[] & { length: L };
-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"
-`;
-const codegenFunction = (name, compiled_program, function_signature) => {
-    const args = function_signature.inputs.map(([name]) => `${name}`).join(', ');
-    const args_with_types = function_signature.inputs.map(([name, type]) => `${name}: ${type}`).join(', ');
-    return `export const ${name}_circuit: CompiledCircuit = ${JSON.stringify(compiled_program)};
-
-export async function ${name}(${args_with_types}, 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};
-}
-`;
+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();
 };
-export const codegen = (programs) => {
-    let results = [codegenPrelude];
-    const primitiveTypeMap = new Map();
-    const structTypeMap = new Map();
-    const functions = [];
-    for (const [name, program] of programs) {
-        const function_sig = generateTsInterface(program.abi, structTypeMap, primitiveTypeMap);
-        functions.push(codegenFunction(name, stripUnwantedFields(program), function_sig));
-    }
-    const structTypeDefinitions = codegenStructDefinitions(structTypeMap, primitiveTypeMap);
-    // Add the primitive Noir types that do not have a 1-1 mapping to TypeScript.
-    const primitiveTypeAliases = [];
-    for (const value of primitiveTypeMap.values()) {
-        primitiveTypeAliases.push(`export type ${value.aliasName} = ${value.tsType};`);
-    }
-    results = results.concat(...primitiveTypeAliases, '', structTypeDefinitions, ...functions);
-    return results.join('\n');
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function stripUnwantedFields(value) {
-    const { abi, bytecode } = value;
-    return { abi, bytecode };
-}

package/lib/main.js

@@ -17,7 +17,7 @@ function main() {
         const { abi, bytecode } = JSON.parse(file_contents);
         return [program_name, { abi, bytecode }];
     });
-    const result = codegen(programs);
+    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))

package/lib/parseArgs.d.ts

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

package/lib/parseArgs.js

@@ -16,6 +16,16 @@ export function parseArgs() {
             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: [
@@ -39,5 +49,7 @@ export function parseArgs() {
         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/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

@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.30.0",
+  "version": "0.31.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
@@ -17,7 +17,7 @@
     "url": "https://github.com/noir-lang/noir/issues"
   },
   "dependencies": {
-    "@noir-lang/types": "0.30.0",
+    "@noir-lang/types": "0.31.0",
     "glob": "^10.3.10",
     "ts-command-line-args": "^2.5.1"
   },
@@ -46,7 +46,7 @@
     "clean": "rm -rf ./lib"
   },
   "devDependencies": {
-    "@noir-lang/noir_js": "0.30.0",
+    "@noir-lang/noir_js": "0.31.0",
     "@types/chai": "^4",
     "@types/mocha": "^10.0.1",
     "@types/node": "^20.6.2",

package/lib/noir_types.d.ts

@@ -1,40 +0,0 @@
-import { AbiType, Abi } from '@noir-lang/noirc_abi';
-/**
- * Keep track off all of the Noir primitive types that were used.
- * Most of these will not have a 1-1 definition in TypeScript,
- * so we will need to generate type aliases for them.
- *
- * We want to generate type aliases
- * for specific types that are used in the ABI.
- *
- * For example:
- * - If `Field` is used we want to alias that
- * with `number`.
- * - If `u32` is used we want to alias that with `number` too.
- */
-export type PrimitiveTypesUsed = {
-    /**
-     * The name of the type alias that we will generate.
-     */
-    aliasName: string;
-    /**
-     * The TypeScript type that we will alias to.
-     */
-    tsType: string;
-};
-/**
- * Generates a TypeScript interface for the ABI.
- * @param abiObj - The ABI to generate the interface for.
- * @returns The TypeScript code to define the interface.
- */
-export declare function generateTsInterface(abiObj: Abi, structsEncountered: Map<string, {
-    name: string;
-    type: AbiType;
-}[]>, primitiveTypeMap: Map<string, PrimitiveTypesUsed>): {
-    inputs: [string, string][];
-    returnValue: string | null;
-};
-export declare function codegenStructDefinitions(structsEncountered: Map<string, {
-    name: string;
-    type: AbiType;
-}[]>, primitiveTypeMap: Map<string, PrimitiveTypesUsed>): string;

package/lib/noir_types.js

@@ -1,134 +0,0 @@
-/**
- * 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.
- */
-function addIfUnique(primitiveTypeMap, item) {
-    const key = JSON.stringify(item);
-    if (!primitiveTypeMap.has(key)) {
-        primitiveTypeMap.set(key, item);
-    }
-}
-/**
- * Converts an ABI type to a TypeScript type.
- * @param type - The ABI type to convert.
- * @returns The typescript code to define the type.
- */
-function abiTypeToTs(type, primitiveTypeMap) {
-    switch (type.kind) {
-        case 'field':
-            addIfUnique(primitiveTypeMap, { aliasName: 'Field', tsType: 'string' });
-            return 'Field';
-        case 'integer': {
-            const typeName = type.sign === 'signed' ? `i${type.width}` : `u${type.width}`;
-            // Javascript cannot safely represent the full range of Noir's integer types as numbers.
-            // `Number.MAX_SAFE_INTEGER == 2**53 - 1` so we disallow passing numbers to types which may exceed this.
-            // 52 has been chosen as the cutoff rather than 53 for safety.
-            const tsType = type.width <= 52 ? `string | number` : `string`;
-            addIfUnique(primitiveTypeMap, { aliasName: typeName, tsType });
-            return typeName;
-        }
-        case 'boolean':
-            return `boolean`;
-        case 'array':
-            // We can't force the usage of fixed length arrays as this currently throws errors in TS.
-            // The array would need to be `as const` to support this whereas that's unlikely to happen in user code.
-            // return `FixedLengthArray<${abiTypeToTs(type.type, primitiveTypeMap)}, ${type.length}>`;
-            return `${abiTypeToTs(type.type, primitiveTypeMap)}[]`;
-        case 'string':
-            // We could enforce that literals are the correct length but not generally.
-            // This would run into similar problems to above.
-            return `string`;
-        case 'struct':
-            return getLastComponentOfPath(type.path);
-        case 'tuple': {
-            const field_types = type.fields.map((field) => abiTypeToTs(field, primitiveTypeMap));
-            return `[${field_types.join(', ')}]`;
-        }
-        default:
-            throw new Error(`Unknown ABI type ${JSON.stringify(type)}`);
-    }
-}
-/**
- * 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;
-}
-/**
- * Generates TypeScript interfaces for the structs used in the ABI.
- * @param type - The ABI type to generate the interface for.
- * @param output - The set of structs that we have already generated bindings for.
- * @returns The TypeScript code to define the struct.
- */
-function generateStructInterfaces(type, structsEncountered, primitiveTypeMap) {
-    // Edge case to handle the array of structs case.
-    if (type.kind === 'array' &&
-        type.type.kind === 'struct' &&
-        !structsEncountered.has(getLastComponentOfPath(type.type.path))) {
-        generateStructInterfaces(type.type, structsEncountered, primitiveTypeMap);
-    }
-    if (type.kind !== 'struct')
-        return;
-    const structName = getLastComponentOfPath(type.path);
-    if (!structsEncountered.has(structName)) {
-        for (const field of type.fields) {
-            generateStructInterfaces(field.type, structsEncountered, primitiveTypeMap);
-        }
-        structsEncountered.set(structName, type.fields);
-    }
-}
-/**
- * Generates a TypeScript interface for the ABI.
- * @param abiObj - The ABI to generate the interface for.
- * @returns The TypeScript code to define the interface.
- */
-export function generateTsInterface(abiObj, structsEncountered, primitiveTypeMap) {
-    // Define structs for composite types
-    for (const param of abiObj.parameters) {
-        generateStructInterfaces(param.type, structsEncountered, primitiveTypeMap);
-    }
-    // Generating Return type, if it exists
-    if (abiObj.return_type != null) {
-        generateStructInterfaces(abiObj.return_type.abi_type, structsEncountered, primitiveTypeMap);
-    }
-    return getTsFunctionSignature(abiObj, primitiveTypeMap);
-}
-export function codegenStructDefinitions(structsEncountered, primitiveTypeMap) {
-    let codeGeneratedStruct = '';
-    for (const [structName, structFields] of structsEncountered) {
-        codeGeneratedStruct += `export type ${structName} = {\n`;
-        for (const field of structFields) {
-            codeGeneratedStruct += `  ${field.name}: ${abiTypeToTs(field.type, primitiveTypeMap)};\n`;
-        }
-        codeGeneratedStruct += `};\n\n`;
-    }
-    return codeGeneratedStruct;
-}
-function getTsFunctionSignature(abi, primitiveTypeMap) {
-    const inputs = abi.parameters.map((param) => [
-        param.name,
-        abiTypeToTs(param.type, primitiveTypeMap),
-    ]);
-    const returnValue = abi.return_type ? abiTypeToTs(abi.return_type.abi_type, primitiveTypeMap) : null;
-    return { inputs, returnValue };
-}