@noir-lang/noir_codegen 0.24.0 → 0.25.0

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,47 @@
+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};
+}
+`;
+};
+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.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);
+    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/noir_types.d.ts

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,134 @@
+/**
+ * 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 };
+}

package/lib/parseArgs.d.ts

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

package/lib/parseArgs.js

@@ -0,0 +1,43 @@
+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.' },
+    }, {
+        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'],
+    };
+}

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/package.json

@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.24.0",
+  "version": "0.25.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.24.0",
+    "@noir-lang/types": "0.25.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.24.0",
+    "@noir-lang/noir_js": "0.25.0",
     "@types/chai": "^4",
     "@types/mocha": "^10.0.1",
     "@types/node": "^20.6.2",